HeaderBase.hh

/*
$Id: HeaderBase.hh 2247 2011-04-27 05:20:41Z jisuzuki $
*/


#ifndef HEADERBASE
#define HEADERBASE

#include <map>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <napi.h>

#include "Header.hh"
#include "Map.hh"
#include "SplitString.hh"
#include "ReadWriteTextFile.hh"
#include "CppToPython.hh"
#include "StringTools.hh"


class HeaderBase
{
private:
  std::map<string, int> _keymap;
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int ver);

  //friend class WriteNeXusFile;        // to aboid re-declaration
  template <class Write>
  void NXwrite(Write &W) const ;

  friend class ReadNeXusFile;
  template <class Read>
  void NXread(Read &R) ;

protected:
  Map< Int4 >              *Int4Map;
  Map< Double >            *DoubleMap;
  Map< string >            *StringMap;
  Map< vector< Int4 >  >  *Int4VectorMap;
  Map< vector< Double > > *DoubleVectorMap;
  Map< vector< string > > *StringVectorMap;
  void MakeMaps();
//  CppToPython *PyConverter;

public:
  HeaderBase();
  //HeaderBase( string DumpedString );
  /* Constructor, the argument is a string
   which should be generated by "DumpToString()".
   The new object constructed by itself has the same information
   as the contents of the argument.*/

 ~HeaderBase();
  HeaderBase( const HeaderBase &ob );
  //HeaderBase &operator=( HeaderBase &ob );
  HeaderBase operator=( const HeaderBase &ob );
  
  void Add( string Key, Int4   value );
  void Add( string Key, Double value );
  void Add( string Key, string value );
  void Add( string Key, vector<Int4>   value );
  void Add( string Key, vector<Double> value );
  void Add( string Key, vector<string> value );
  void AddHeader( string Key, Int4   value ){ Add( Key, value ); }
  void AddHeader( string Key, Double value ){ Add( Key, value ); }
  void AddHeader( string Key, string value ){ Add( Key, value ); }
  void AddHeader( string Key, vector<Int4>   value ){ Add( Key, value ); }
  void AddHeader( string Key, vector<Double> value ){ Add( Key, value ); }
  void AddHeader( string Key, vector<string> value ){ Add( Key, value ); }
  void add( string Key, Int4   value ){ Add( Key, value ); }
  void add( string Key, Double value ){ Add( Key, value ); }
  void add( string Key, string value ){ Add( Key, value ); }
  void add( string Key, vector<Int4>   value ){ Add( Key, value ); }
  void add( string Key, vector<Double> value ){ Add( Key, value ); }
  void add( string Key, vector<string> value ){ Add( Key, value ); }
  void AddInt4List( string Key, PyObject *List );
  void AddDoubleList( string Key, PyObject *List );
  void AddStringList( string Key, PyObject *List );
  
  bool Empty(void) {return _keymap.empty(); }
  
  void Erase( string Key );
  void erase( string Key ){ Erase( Key ); }
  void clear();
  void Clear(){ clear(); }
  void OverWrite( string Key, Int4   value ){Erase( Key ); Add( Key, value );}
  void OverWrite( string Key, Double value ){Erase( Key ); Add( Key, value );}
  void OverWrite( string Key, string value ){Erase( Key ); Add( Key, value );}
  void OverWrite( string Key, vector<Int4>   value ){Erase( Key ); Add( Key, value );}
  void OverWrite( string Key, vector<Double> value ){Erase( Key ); Add( Key, value );}
  void OverWrite( string Key, vector<string> value ){Erase( Key ); Add( Key, value );}
  void Dump();
  PyObject* PyDump();
  void dump(){ Dump(); }
  void DumpHeader(){ Dump(); }

  void Search( string Key );
  UInt4 CheckKey( string Key ) {return (_keymap[Key] > 0) ? 1 : 0;}
  Int4 PutInt4( string Key );
  Double PutDouble( string Key );
  string PutString( string Key );
  vector<Int4>   PutInt4Vector( string Key );
  vector<Double> PutDoubleVector( string Key );
  vector<string> PutStringVector( string Key );
  Int4   PutInt4(   UInt4 Index ){ return Int4Map->Put(Index); }
  Double PutDouble( UInt4 Index ){ return DoubleMap->Put(Index); }
  string PutString( UInt4 Index ){ return StringMap->Put(Index); }
  vector<Int4>   PutInt4Vector(   UInt4 Index ){ return Int4VectorMap->Put(Index); }
  vector<Double> PutDoubleVector( UInt4 Index ){ return DoubleVectorMap->Put(Index); }
  vector<string> PutStringVector( UInt4 Index ){ return StringVectorMap->Put(Index); }

  string DumpToString();
  void InputString( string s );
  void InputFile( string FileName );

  Int4   i( string Key ){ return PutInt4( Key ); }
  Double d( string Key ){ return PutDouble( Key ); }
  Float  f( string Key){ return (Double)( d( Key ) ); }
  string s( string Key ){ return PutString( Key ); }
  vector<Int4>   iv( string Key ){ return PutInt4Vector( Key ); }
  vector<Double> dv( string Key ){ return PutDoubleVector( Key ); }
  vector<string> sv( string Key ){ return PutStringVector( Key ); }
  friend class WriteNeXusFile;
  friend class NeutronExchanger;
  UInt4 PutKeyLocation( string Key ){ return _keymap[Key]; };
};
 
template <class Archive>
void HeaderBase::
serialize(Archive &ar, const unsigned int ver) {
  ar & boost::serialization::make_nvp("Keymap", _keymap);

  ar & boost::serialization::make_nvp("Int4Map",      *Int4Map);
  ar & boost::serialization::make_nvp("DoubleMap",    *DoubleMap);
  ar & boost::serialization::make_nvp("StringMap",    *StringMap);
  ar & boost::serialization::make_nvp("Int4Vector",   *Int4VectorMap);
  ar & boost::serialization::make_nvp("DoubleVector", *DoubleVectorMap);
  ar & boost::serialization::make_nvp("StringVector", *StringVectorMap);

}

template <class Write>
void HeaderBase::
NXwrite(Write &W) const {
        W.WriteData("_Keymap", _keymap);

  for (std::map<std::string, int>::const_iterator p=_keymap.begin(),
        end=_keymap.end();p!=end;++p) {
    switch (p->second) {
    case 1:
      W.WriteData(p->first, (*Int4Map)[p->first]);
      break;
    case 2:
      W.WriteData(p->first, (*DoubleMap)[p->first]);
      break;
    case 3:
      W.WriteData(p->first, (*StringMap)[p->first]);
      break;
    case 4:
      W.WriteData(p->first, (*Int4VectorMap)[p->first]);
      break;
    case 5:
      W.WriteData(p->first, (*DoubleVectorMap)[p->first]);
      break;
    case 6:
      W.WriteData(p->first, (*StringVectorMap)[p->first]);
      break;
    }
  }

}
template <class Read>
void HeaderBase::
NXread(Read &R) {
  R.ReadData("_Keymap", _keymap);

  for (std::map<std::string, int>::const_iterator p=_keymap.begin(),
        end=_keymap.end();p!=end;++p) {
    switch (p->second) {
    case 1:
      R.ReadData(p->first, (*Int4Map)[p->first]);
      break;
    case 2:
      R.ReadData(p->first, (*DoubleMap)[p->first]);
      break;
    case 3:
      R.ReadData(p->first, (*StringMap)[p->first]);
      break;
    case 4:
      R.ReadData(p->first, (*Int4VectorMap)[p->first]);
      break;
    case 5:
      R.ReadData(p->first, (*DoubleVectorMap)[p->first]);
      break;
    case 6:
      R.ReadData(p->first, (*StringVectorMap)[p->first]);
      break;
    }
  }
}
#endif