Clcm.hxx

#ifndef Clcm_HXX
#define Clcm_HXX

#include <cstddef> // for __GLIBCXX__
 
#ifdef __GLIBCXX__ // for memory management with shared_ptr
#  include <tr1/memory>
#else
#  ifdef __IBMCPP__
#    define __IBMCPP_TR1__
#  endif
#  include <memory>
#endif

#include <cerrno>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <sstream>
#include <vector>
#include <fstream>
#include <complex>
#include<boost/shared_ptr.hpp>
#include<boost/shared_array.hpp>
#include<boost/variant.hpp>
#include "LCMexception.hxx"
extern "C" {
#include <dirent.h>
#include "lcm.h"
}

#define IntPtr boost::shared_array<int_32>
#define FloatPtr boost::shared_array<float_32>
#define StringPtr boost::shared_ptr<std::string>
#define DoublePtr boost::shared_array<double_64>
#define BoolPtr boost::shared_array<bool>
#define ComplexPtr boost::shared_array< std::complex<float_32> >
#define StringVecPtr boost::shared_ptr< std::vector<std::string> >
#define ClcmPtr boost::shared_ptr<Clcm>

// support for pinning. 
#define AnyPtr boost::variant<IntPtr, FloatPtr, StringPtr, DoublePtr, BoolPtr, ComplexPtr>
#define IntPtrConst boost::shared_array<const int_32>
#define FloatPtrConst boost::shared_array<const float_32>
#define StringPtrConst boost::shared_ptr<const std::string>
#define DoublePtrConst boost::shared_array<const double_64>
#define BoolPtrConst boost::shared_array<const bool>
#define ComplexPtrConst boost::shared_array<const std::complex<float_32> >

namespace ganlib {

class Clcm {
public:
  Clcm(const std::string stype, const std::string myName, const std::string myPath) throw(LCMexception);

  Clcm(lcm *, Clcm *, const int_32, const std::string, const int_32, const std::string) throw(LCMexception);

  Clcm(const std::string stype, ClcmPtr myClcm) throw(LCMexception);

  Clcm(lcm *mylcm, const int_32 type, const int_32 access, const std::string OSname);

  ~Clcm();

  friend std::ostream & operator<<(std::ostream &s, ClcmPtr myClcm) throw(LCMexception);

  void expor(const std::string stype);

  void expor(const std::string stype, const std::string new_name);

  void except();

  std::string getName() throw();

  std::string getPath() throw();

  int_32 getType() throw();

  int_32 getLength() throw(LCMexception);

  std::string getDirectory() throw(LCMexception);

  int_32 getAccess() throw(LCMexception);

  int_32 getLrda() throw();
    
  int_32 getVersion() throw();
    
  bool isEmpty() throw(LCMexception);

  bool isNew() throw();

  void open(const std::string saccess) throw(LCMexception);

  void close(const std::string saccess) throw(LCMexception);

  int_32 length(const std::string key) throw(LCMexception);

  int_32 length(const int_32 iset) throw(LCMexception);

  int_32 type(const std::string key) throw(LCMexception);

  int_32 type(const int_32 iset) throw(LCMexception);

  void lib() throw(LCMexception);

  void val() throw(LCMexception);

  ClcmPtr setDictionary(const std::string key) throw(LCMexception);

  ClcmPtr setDictionary(const int_32 iset) throw(LCMexception);

  ClcmPtr setList(const std::string key, const int_32 ilong) throw(LCMexception);

  ClcmPtr setList(const int_32 iset, const int_32 ilong) throw(LCMexception);

  ClcmPtr getClcm(const std::string key) throw(LCMexception);

  ClcmPtr getClcm(const int_32 iset) throw(LCMexception);

  IntPtrConst getInt(const std::string key) throw(LCMexception);

  IntPtrConst getInt(const int_32 iset) throw(LCMexception);

  FloatPtrConst getFloat(const std::string key) throw(LCMexception);

  FloatPtrConst getFloat(const int_32 iset) throw(LCMexception);

  StringPtrConst getString(const std::string key) throw(LCMexception);

  StringPtrConst getString(const int_32 iset) throw(LCMexception);

  StringVecPtr getVecString(const std::string key, const int_32 size) throw(LCMexception);

  StringVecPtr getVecString(const int_32 iset, const int_32 size) throw(LCMexception);

  DoublePtrConst getDouble(const std::string key) throw(LCMexception);

  DoublePtrConst getDouble(const int_32 iset) throw(LCMexception);

  BoolPtrConst getBool(const std::string key) throw(LCMexception);

  BoolPtrConst getBool(const int_32 iset) throw(LCMexception);

  ComplexPtrConst getComplex(const std::string key) throw(LCMexception);

  ComplexPtrConst getComplex(const int_32 iset) throw(LCMexception);

  StringVecPtr keys() throw(LCMexception);

  void put(const std::string key, IntPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const int_32 iset, IntPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const std::string key, FloatPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const int_32 iset, FloatPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const std::string key, StringPtr myArray) throw(LCMexception);

  void put(const int_32 iset, StringPtr myArray) throw(LCMexception);

  void put(const std::string key, StringVecPtr myArray) throw(LCMexception);

  void put(const int_32 iset, StringVecPtr myArray) throw(LCMexception);

  void put(const std::string key, DoublePtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const int_32 iset, DoublePtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const std::string key, BoolPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const int_32 iset, BoolPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const std::string key, ComplexPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const int_32 iset, ComplexPtr myArray, const int_32 myLength) throw(LCMexception);

  void put(const std::string key, ClcmPtr myClcm) throw(LCMexception);

  void put(const int_32 iset, ClcmPtr myClcm) throw(LCMexception);

  lcm *extract();

private:
  std::vector<AnyPtr> *global_list; // container for the global references
  lcm *addr;                  // address of the LCM object
  Clcm *root;                 // address of Clcm root object
  std::ofstream aFile;        // embedded file if type >= 3
  int_32 lrda;                // used with direct access files only
  std::string name;           // object name
  std::string path;           // path to access the Clcm file to import
  std::string nammy;          // directory name inside LCM object
  bool empty;                 // empty flag
  int_32 ilong;               // -1 (dictionary) or list length
  int_32 objtype;             // type of the object =1: LCM; =2: XSM; =3: binary Fortran file
                              // =4: ASCII Fortran file; =5: direct access Fortran file
  int_32 access;              // =0: closed object; =1: object in read/write mode
                              // =2: object in read-only mode
  int_32 version;             // original ganlib version of object
  bool untoutched;            // brand new object flag
  bool isroot;                // true if addr is pointing on the root object
}; // class Clcm
  std::ostream & operator<<(std::ostream &, ClcmPtr) throw(LCMexception);

} // namespace ganlib
#endif