STK_String_Util.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2007  Serge Iovleff

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this program; if not, write to the
    Free Software Foundation, Inc.,
    59 Temple Place,
    Suite 330,
    Boston, MA 02111-1307
    USA

    Contact : Serge.Iovleff@stkpp.org
*/

/*
 * Project:  stkpp::STKernel::Base
 * Purpose:  Define miscenaleous utility functions for Strings.
 * Author:   Serge Iovleff, serge.iovleff@stkpp.org
 *
 **/

#ifndef STK_STRING_UTIL_H
#define STK_STRING_UTIL_H

#include "STK_String.h"
#include "STK_Stream.h"

#include "STK_Proxy.h"

namespace STK
{
static const String STRING_NA      = String(_T("."));

static const int STRING_NA_SIZE  = 1;

template <class TYPE>
bool stringToType( TYPE  &t
                 , String const& s
                 , std::ios_base& (*f)(std::ios_base&) = std::dec
                 )
{
  istringstream iss(s);
  Proxy<TYPE> wrapper_t(t);
  bool flag1 = (iss >> f >> wrapper_t).fail();
  iss >> std::ws;
  // ok if the conversion success and the String is exhausted
  return ( !flag1 && iss.eof() );
}

template <class TYPE>
String typeToString( TYPE const& t
                   , std::ios_base& (*f)(std::ios_base&) = std::dec
                   )
{
  ostringstream oss;
  oss << f << ConstProxy<TYPE>(t);
  return oss.str();
}

template <class TYPE>
ostream& operator << (ostream& os, const ConstProxy<TYPE>& output)
{ if (Arithmetic<TYPE>::isNA(output))
    return (os <<  STRING_NA);
  else
   return (os << static_cast<TYPE const &>(output));
}


template <class TYPE>
istream& operator >> (istream& is, Proxy<TYPE>& input)
{
  TYPE buff;
  // get current position in the stream
  typename std::ios::pos_type pos = is.tellg();

  // If the standard Conversion failed
  if ((is >> buff).fail())
  {
    // clear failbit state
    is.clear(is.rdstate() & ~std::ios::failbit);
    // clear eofbit state if necessary and rewind position
    if (is.eof())
    {
      is.seekg(pos);
      is.clear(is.rdstate() & ~std::ios::eofbit);
    }
    // in all case input is a NA object
    input = Arithmetic<TYPE>::NA();

    // get current position in the stream
    pos = is.tellg();

    // Create a String buffer
    Char Lbuff[STRING_NA_SIZE+1];

    // try to read a NA String
    is.getline(Lbuff, STRING_NA_SIZE+1);

    // if we don't get a NA String, rewind stream
    if (!(STRING_NA.compare(Lbuff) == 0))
    { is.seekg(pos);}
  }
  else
  { input = buff;}
  // return the stream
  return is;
}

istream& operator >> (istream& is, Proxy<String>& input);

String& toUpperString( String& s);

String toUpperString( String const& s);

} // namespace STK

#endif /* STK_STRING_UTIL_H */