STK_Proxy.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:  stkpp::STKernel::Base
 * Purpose:  Define the Proxy classes for wrapping any types.
 * Author:   Serge Iovleff, S..._Dot_I..._At_stkpp_Dot_org (see copyright for ...)
 **/
 
#ifndef STK_PROXY_H
#define STK_PROXY_H
 
namespace STK
{
 template<class Type>
 class Proxy
 {
   protected:
     Type& x_; 
     Type const& y_; 
 
   public:
     template< typename U >
     Proxy( typename hidden::If< hidden::isSame<Type const, U>::value_, Type, U>::Result& x)
          : x_(x), y_(x) {}
     inline Proxy(Type const& x) : x_(const_cast<Type&>(x)), y_(x) {}
     inline Proxy(Proxy const& p) : x_(p.x_), y_(p.y_) {}
     Proxy& operator=(Proxy const& p) { x_ = p.x_; return *this;}
     inline ~Proxy() {}
     inline operator Type &() { return x_;}
     inline operator Type const &() const { return y_;}
     friend istream& operator >> (istream& is, Proxy<Type> p)
     {
       // get current file position
       std::ios::pos_type pos = is.tellg();
       // failed to read directly the Type value
       if ( (is >> p.x_).fail() )
       {
         p.x_ = Arithmetic<Type>::NA();
         // clear and reset position
         is.clear(); is.seekg(pos);
         // Try to read a NA value, in all case value is a NA object
         Char* buffer = new Char[stringNaSize+1];
 
         if (is.get(buffer,stringNaSize+1).fail())
         { is.clear(); is.seekg(pos); is.setstate(std::ios::failbit);}
         else if (!(stringNa.compare(buffer) == 0))
              { is.clear(); is.seekg(pos); is.setstate(std::ios::failbit);}
 
         delete[] buffer;
       }
       return is;
     }
     inline friend ostream& operator << (ostream& os, Proxy<Type> const& p)
     { return Arithmetic<Type>::isNA(p.y_) ? (os <<  stringNa) : (os << p.y_);}
};
 
  template<>
  class Proxy<String>
  {
    protected:
      String& x_; 
      String const& y_; 
 
    public:
      inline Proxy(String &x) : x_(x), y_(x) {}
      inline Proxy(String const& x) : x_(const_cast<String&>(x)), y_(x) {}
      inline Proxy(Proxy const& p) : x_(p.x_), y_(p.y_) {}
      Proxy& operator=(Proxy const& p) { x_ = p.x_; return *this;}
      inline ~Proxy() {}
      inline operator String &() { return x_;}
      inline operator String const &() const { return y_;}
      friend istream& operator >> (istream& is, Proxy<String> p)
      {
        String buff;
        is >> std::skipws >> buff;
        p = (buff  == stringNa) ? Arithmetic<String>::NA() : buff;
        return is;
      }
      inline friend ostream& operator << (ostream& os, Proxy<String> const& p)
      { return Arithmetic<String>::isNA(p.x_) ? (os <<  stringNa) : (os << p.y_);}
 };
 
} // namespace STK
 
#endif /*STK_PROXY_H*/