iarchive.hpp

/************************************************************************************
 *    This file is part of the MynahSA streaming and archiving toolkit              *
 *    Copyright (C) 2006 Mynah-Software Ltd. All Rights Reserved.                   *
 *                                                                                  *
 *    This program is free software; you can redistribute it and/or modify          *
 *    it under the terms of the GNU General Public License, version 2               *
 *    as published by the Free Software Foundation.                                 *
 *                                                                                  *
 *    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 General Public License for more details.                                  *
 *                                                                                  *
 *    You should have received a copy of the GNU General Public License along       *
 *    with this program; if not, write to the Free Software Foundation, Inc.,       *
 *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.                   *
 *                                                                                  *
 ************************************************************************************/

#ifndef __i_archive_hpp
#define __i_archive_hpp

#include "archive.hpp"

#include <mynahsa/spimpl.hpp>


#include <string>

#include <map>

#include <stdexcept>


#include <iostream>

namespace MynahSA {
  
  template<class T>
  class IArchive : public Archive { 
  public:
  

  
    IArchive(T& s) : _stream(s) {
    }
      
    IArchive(const IArchive<T>& i) : Archive(i), 
                                     _stream(i._stream) {
    }
  
  
    ~IArchive() {
    }
  
  

  
    //  Implementation of pure base follows
  

    
    // must treat int / bool / float / double / char
  
    virtual Archive& operator&(long long& j) { 
      _stream >> j;
      return *this;
    }
    
    virtual Archive& operator&(unsigned long long& j) { 
      _stream >> j;
      return *this;
    }
  
    virtual Archive& operator&(unsigned int& i) {
      _stream >> i;
      return *this;
    }
  
    virtual Archive& operator&(int& i) { 
      _stream >> i;
      return *this;
    }
    
    virtual Archive& operator&(short& s) { 
      _stream >> s;
      return *this;
    }
    
    virtual Archive& operator&(unsigned short& s) { 
      _stream >> s;
      return *this;
    }
    
    virtual Archive& operator&(char& c) { 
      _stream >> c;
      return *this;
    }
    
    virtual Archive& operator&(unsigned char& c) {
      _stream >> c;
      return *this;
    }
    
    virtual Archive& operator&(bool& b) { 
      _stream >> b;
      return *this;
    }
    
    virtual Archive& operator&(float& f) {
      _stream >> f;
      return *this;
    }
    
    virtual Archive& operator&(double& d) {
      _stream >> d;
      return *this;
    }
  
  
  
    virtual Archive& operator&(std::string& s) { 
      // note: stream operator defines behavior for string streaming.  If the std library streams
      // are used the string s must note contain a space, since the std streams split strings by space
      _stream >> s;
      return *this;
    }
  
    template <class Type>
    Archive& operator>>(SHARED_PTR<Type>& instance) { 
    std::string name; // get the class name
    (*this) & instance;
    return *this;
    }
    
    template <class Type>
    Archive& operator>>(Type& instance) { 
      instance.serialize(*this);
      return *this;
    }
  
    

  
    using Archive::operator&;
  
  
    // IArchive must provide STL wrappers for operator>> - we can simply use Archive::operator& to do the work, but we must provide the function
    // override s.t. the compiler will have a method for implementing the unidirectional stream operator
    template<class Type>
    Archive& operator>>(std::list<Type>& l) { 
      (*this) & l;
      return *this;
    }
    
    template<class Type>
    Archive& operator>>(std::vector<Type>& v) { 
      (*this) & v;
      return *this;
    }
    
    template<class A, class B>
    Archive& operator>>(std::pair<A,B>& p) { 
      (*this) & p;
      return *this;
    }
    
    template<class index_type, class value_type>
    Archive& operator>>(std::map<index_type, value_type>& m) { 
      (*this) & m;
      return *this;
    }
    
    template<class index_type, class value_type>
    Archive& operator>>(std::multimap<index_type, value_type>& m) { 
      (*this) & m;
      return *this;
    }
  
    template<class value_type>
    Archive& operator>>(std::set<value_type>& s) { 
      (*this) & s;
      return *this;
    }
  
  
  
  
  
  
  
  
  protected:
    ArchiveMode getArchiveMode() const { 
      return Archive::ARCHIVE_READ;
    }
  
  
  private:

  
    T& _stream;
  
  };
};


#endif