STK_String.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2004-2016  Serge Iovleff, Université Lille 1, Inria
 
    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 : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  STKernel::Base
 * Purpose:  Define the fundamental type String.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_STRING_H
#define STK_STRING_H
 
#include <ctype.h>
#include <algorithm>
 
namespace STK
{
template<>
struct Arithmetic<String>: public std::numeric_limits<String>
{
  static String NA() throw() { return String();}
  static const bool hasNA = true;
  static bool isNA(String const& x) throw() { return (x == NA());}
  static bool isInfinite(String const& x) throw() { return false; }
  static bool isFinite(String const& x) throw() { return (!isNA(x));}
};
 
template<>
struct IdTypeImpl<String>
{
  static Base::IdType returnType() { return(Base::string_);}
};
 
#ifndef IS_RTKPP_LIB
extern String stringNa;
 
extern int stringNaSize;
 
inline void setStringNa(String const& na)
{ stringNa = na; stringNaSize = na.size();}
 
#else /* is rtkpp lib */
 
static const String stringNa = _T("NA");
static const int stringNaSize = 2;
 
#endif
 
inline String const& toUpperString( String& s)
{
  // iterate along the String
  for (String::iterator it = s.begin(); it != s.end(); ++it)
  { *it = std::toupper(*it);}
  // return upper cased string
 return s;
}
 
inline String toUpperString( String const& s)
{
  // iterate along the String
  String str = s;
  for (String::iterator it = str.begin(); it != str.end(); ++it)
  { *it = std::toupper(*it);}
  // return upper cased string
 return str;
}
 
inline String removeWhiteSpaces( String const& s)
{
  // iterate along the String
  String str = s;
  str.erase(remove_if(str.begin(), str.end(), isspace), str.end());
  return str;
}
 
}
 
#include "STK_Proxy.h"
 
namespace STK
{
template <class Type>
bool stringToType( Type &t, String const& s
                 , std::ios_base& (*f)(std::ios_base&) = std::dec
                 )
{ istringstream iss(s);
  return !( iss >> f >> Proxy<Type>(t)).fail();
}
 
template <class Type>
Type stringToType( String const& s)
{
  Type t;
  istringstream iss(s);
  iss >> Proxy<Type>(t);
  return(t);
}
 
template <class Type>
String typeToString( Type const& t, std::ios_base& (*f)(std::ios_base&) = std::dec)
{
  if (Arithmetic<Type>::isNA(t)) return stringNa;
  ostringstream oss;
  return static_cast<ostringstream&>(oss << f << Proxy<Type>(t)).str();
}
 
} // namespace STK
 
#endif /*STK_STRING_H*/