STK_Sign.h

Go to the documentation of this file.

/*--------------------------------------------------------------------*/
/*     Copyright (C) 2007-2015  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 : S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
*/
 
/*
 * Project:  Base
 * Purpose:  Define the fundamental type Sign.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 *
 **/
 
#ifndef STK_SIGN_H
#define STK_SIGN_H
 
#include <map>
 
namespace STK
{
enum Sign
{ negative_ =-1, 
 positive_ = 1, 
 signNA_ = INT_MIN  
};
enum Sign {…};
 
// forward declaration
template<typename Type> struct Arithmetic;
template<typename Type> struct IdTypeImpl;
 
template<>
struct Arithmetic<Sign>: public std::numeric_limits<Sign>
{
   static Sign NA() throw() { return signNA_;}
   static const bool hasNA = true;
   static bool isNA(const Sign& x) throw() { return (x==signNA_);}
   static bool isInfinite(const Sign& x) throw() { return false; }
   static bool isFinite(const Sign& x) throw() { return (!isNA(x) && !isInfinite(x));}
 };
struct Arithmetic<Sign>: public std::numeric_limits<Sign> {…};
 
template<>
struct IdTypeImpl<Sign>
{
  static Base::IdType returnType() { return(Base::sign_);}
};
struct IdTypeImpl<Sign> {…};
 
inline ostream& operator << (ostream& os, const Sign& value)
{ return Arithmetic<Sign>::isNA(value)
      ? (os << stringNa) : (os << static_cast<int>(value));
}
inline ostream& operator << (ostream& os, const Sign& value) {…}
 
inline istream& operator >> (istream& is, Sign& value)
{
  // get current file position
  int res;
  // try to read an integer
  if (!(is >> res).fail())
  {
    switch (res)
    {
      case 1:
        value = positive_;
        break;
      case -1:
        value = negative_;
        break;
      default:
        value = signNA_;
        break;
    }
  }
  else
  { value = signNA_; is.clear(); is.setstate(std::ios::failbit);}
  return is;
}
inline istream& operator >> (istream& is, Sign& value) {…}
 
inline Sign stringToSign( String const& str)
{
  if (toUpperString(str) == toUpperString(_T("-1"))) return negative_;
  if (toUpperString(str) == toUpperString(_T("1"))) return positive_;
  return signNA_;
}
inline Sign stringToSign( String const& str) {…}
 
inline Sign stringToSign( String const& str, std::map<String, Sign> const& mapping)
{
  std::map<String, Sign>::const_iterator it=mapping.find(str);
  if (it == mapping.end())  return signNA_;
  return it->second;
}
inline Sign stringToSign( String const& str, std::map<String, Sign> const& mapping) {…}
 
inline String signToString( Sign const& value, std::ios_base& (*f)(std::ios_base&) = std::dec)
{
  if (Arithmetic<Sign>::isNA(value)) return stringNa;
  ostringstream os;
  os << f << static_cast<int>(value);
  return os.str();
}
inline String signToString( Sign const& value, std::ios_base& (*f)(std::ios_base&) = std::dec) {…}
 
inline String signToString( Sign const& value, std::map<Sign, String> mapping)
{ return mapping.find(value)->second;}
inline String signToString( Sign const& value, std::map<Sign, String> mapping) {…}
 
template<>
inline Sign stringToType<Sign>( String const& str)
{ return stringToSign(str);}
inline Sign stringToType<Sign>( String const& str) {…}
 
template<>
inline String typeToString<Sign>( Sign const& t, std::ios_base& (*f)(std::ios_base&))
{ return signToString(t);}
inline String typeToString<Sign>( Sign const& t, std::ios_base& (*f)(std::ios_base&)) {…}
 
 
} // namespace STK
 
#endif /*STK_SIGN_H*/