UInt4Container.hh

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


#ifndef UINT4CONTAINER
#define UINT4CONTAINER

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

#include "Header.hh"
#include "HeaderBase.hh"
#include "CppToPython.hh"
#include "SplitString.hh"
#include "ElementContainer.hh"


class UInt4Container
{
private:
  vector< vector< UInt4 >* > v;
  vector< string > s;
  vector< vector< Double >* > vd;
  vector< string > sd;

  HeaderBase *header;
  CppToPython *PythonConverter;
  void SetupPythonConverter();

  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive &ar, const unsigned int ver);

  friend class WriteNeXusFile;
  template <class Write>
  void NXwrite(Write &W) const ;

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

protected:

public:
  UInt4Container();
  UInt4Container( HeaderBase *Header );
  //UInt4Container( HeaderBase Header );

  UInt4Container( const UInt4Container &ob );
  UInt4Container operator=( const UInt4Container &ob );
  
 ~UInt4Container();

  UInt4 PutTableSize(){ return v.size(); }
  UInt4 PutSize(){ return PutTableSize(); }

  UInt4 PutTableSizeDouble(){ return vd.size(); }
  UInt4 PutSizeDouble(){ return PutTableSizeDouble(); }

  UInt4 PutSize( UInt4 IndexNumber ){ return v[IndexNumber] -> size(); }
  UInt4 PutSize( string Key ){ return Put(Key) . size(); }

  UInt4 PutSizeDouble( UInt4 IndexNumber ){ return vd[IndexNumber] -> size(); }
  UInt4 PutSizeDouble( string Key ){ return PutDouble(Key) . size(); }

  UInt4 PutIndexNumber( string Key );
  UInt4 PutIndexNumberDouble( string Key );

  string PutName( UInt4 IndexNumber ){ return s[IndexNumber]; }
  string PutNameDouble( UInt4 IndexNumber ){ return sd[IndexNumber]; }

  HeaderBase PutHeader();
  HeaderBase *PutHeaderPointer(){ return header; }
  void InputHeader( HeaderBase Header );

  void Reverse(void) {
        std::cout << "UInt4Container::Reverse() not implemented yet" << std::endl;
  }

  void DumpKey();
  void Dump();
  void DumpValue();
  void DumpFromVectorContainer();
  void DumpFromVectorContainer( UInt4 size );
  void Dump( UInt4 size );
  void DumpValue( UInt4 size );

  void Add( string Key, vector< UInt4 > value );
  void Add( string Key, PyObject *value );
  void Add( string Key, UInt4 *&Array, UInt4 ArraySize );

  void AddDouble( string Key, vector< Double > value );
  void AddDouble( string Key, PyObject *value );
  void AddDouble( string Key, Double *&Array, UInt4 ArraySize );

  vector<UInt4> Put( UInt4 IndexNumber );
  vector<Double> PutDouble( UInt4 IndexNumber );
  vector<UInt4> Put( string Key );
  vector<Double> PutDouble( string Key );
  UInt4  Put( string Key, UInt4 Index );
  Double PutDouble( string Key, UInt4 Index );

  PyObject *PutList( string Key );
  PyObject *PutListDouble( string Key );
  UInt4 CheckKey( string Key );
  UInt4 CheckKeyDouble( string Key );

  // These methods will be utilized for making NeXus file.
  string PutMergedKey(); 
  string PutMergedKeyDouble(); 
  vector<UInt4>  PutSizeVector();
  vector<UInt4>  PutSizeVectorDouble();
  vector<UInt4>  PutMergedDataVector();
  vector<Double>  PutMergedDataVectorDouble();

  // A data container will be built with the arguments of this method,
  // and this method will be called from "ReadNeXusFile" and "WriteNeXusFile".
  void MakeContainer( string MergedKey, 
                      vector<UInt4> SizeVector, 
                      vector<UInt4> MergedDataVector, 
                      HeaderBase h );
  void MakeContainer( string MergedKey, 
                      vector<UInt4> SizeVector, 
                      vector<UInt4> MergedDataVector,
                      string MergedKeyDouble,
                      vector<UInt4> SizeVectorDouble,
                      vector<Double> MergedDataVectorDouble,
                      HeaderBase h );
  vector<UInt4>* operator[]( string Key );
  vector<UInt4>* operator[]( UInt4 index );
  vector<UInt4>* operator()( string Key );
  vector<UInt4>* operator()( UInt4 index );
  ElementContainer ConvertIntoElementContainer();

  UInt4Container &operator+=(const UInt4Container &r) {
        std::cout << "operator += for UInt4Container was not implemented" << std::endl;
        return *this;
  }
  UInt4Container &operator-=(const UInt4Container &r) {
        std::cout << "operator -= for UInt4Container was not implemented" << std::endl;
        return *this;
  }
  UInt4Container &operator*=(const UInt4Container &r) {
        std::cout << "operator *= for UInt4Container was not implemented" << std::endl;
        return *this;
  }
  UInt4Container &operator/=(const UInt4Container &r) {
        std::cout << "operator /= for UInt4Container was not implemented" << std::endl;
        return *this;
  }

  UInt4Container operator+(UInt4Container &r) {
        std::cout << "operator + for UInt4Container was not implemented" << std::endl;
        return *this;
  }
  UInt4Container operator-(UInt4Container &r) {
        std::cout << "operator - for UInt4Container was not implemented" << std::endl;
        return *this;
  }
  UInt4Container operator*(UInt4Container &r) {
        std::cout << "operator * for UInt4Container was not implemented" << std::endl;
        return *this;
  }
  UInt4Container operator/(UInt4Container &r) {
        std::cout << "operator / for UInt4Container was not implemented" << std::endl;
        return *this;
  }
};

template <class Archive>
void UInt4Container::
serialize(Archive &ar, const unsigned int ver) {
  ar & boost::serialization::make_nvp("UInt4Keys", s);
  ar & boost::serialization::make_nvp("UInt4Values", v);

  ar & boost::serialization::make_nvp("DoubleKeys", sd);
  ar & boost::serialization::make_nvp("DoubleValues", vd);

  ar & boost::serialization::make_nvp("Header", *header);
}

template <class Write>
void UInt4Container::
NXwrite(Write &W) const {
  W.WriteData("UInt4Keys", s);
  W.WriteData("UInt4Values", v);

  W.WriteData("DoubleKeys", sd);
  W.WriteData("DoubleValues", vd);

  if (!header->Empty())
  W.WriteData("Header", *header);
}

template <class Read>
void UInt4Container::
NXread(Read &R) {
  R.ReadData("UInt4Keys", s);
  R.ReadData("UInt4Values", v);

  R.ReadData("DoubleKeys", sd);
  R.ReadData("DoubleValues", vd);

  NXname _name, _class;
  int _id, _status;
  while ((_status=R.GetNextEntry2(_name, _class, &_id))==1) {
//      std::cerr << "NEXTENTRY: " << _name << "," << _class << ", "
//                        << _id << "," << _status << std::endl;
        if (strcmp(_name, "Header")==0)
          R.ReadData("Header", *header);
  }
}
#endif