CkptDAO.h

Go to the documentation of this file.

#ifndef CKPTDAO_H_
#define CKPTDAO_H_

#include "CkptTypeRegistry.h"
#include "CkptByteArray.h"
#include <string>

class DAOInterface;

class DAOSerializable {
 public:
  virtual void serialize(DAOInterface &dao)=0;
  virtual char* getClassname()=0;
};

enum DAOMode { DAO_INPUT, DAO_OUTPUT };

class CommonDAO {
 public:
  #define DECLARE_BUILTIN_PRIM(PRIMITIVE_TYPE) \
   virtual void processPrim(PRIMITIVE_TYPE &t)=0;

  //DECLARE_BUILTIN_PRIM(bool)
  DECLARE_BUILTIN_PRIM(char)
  DECLARE_BUILTIN_PRIM(unsigned char)
  DECLARE_BUILTIN_PRIM(int)
  DECLARE_BUILTIN_PRIM(unsigned int)
  DECLARE_BUILTIN_PRIM(short)
  DECLARE_BUILTIN_PRIM(unsigned short)
  DECLARE_BUILTIN_PRIM(long)
  DECLARE_BUILTIN_PRIM(unsigned long)
  DECLARE_BUILTIN_PRIM(float)
  DECLARE_BUILTIN_PRIM(double)
  DECLARE_BUILTIN_PRIM(std::string)
  
  virtual void byteCopy(char* data, unsigned int dataSize)=0;
  virtual DAOSerializable* processExternalObj(DAOSerializable* t)=0;
  virtual DAOMode getMode()=0;
};

class InputDAO : public CommonDAO {
 public:
  InputDAO() : bArray(NULL) { };
  InputDAO(byte_array* bA) : bArray(bA) { };
  void setInputData(byte_array* bA) { bArray = bA; };
  virtual DAOMode getMode() { return DAO_INPUT; };
 protected:
  byte_array* bArray;
};

 class OutputDAO : public CommonDAO {
 public:
   virtual DAOMode getMode() { return DAO_OUTPUT; };
   virtual byte_array* getOutputData()=0;
};


class DAOInterface {
 public:
  DAOInterface(CommonDAO *daoImpl) : impl(daoImpl) { };
  virtual ~DAOInterface() { delete impl; };
  virtual DAOMode getMode() { return impl->getMode(); };

  #define PROCESS_IFACE_PRIM(PRIMITIVE) \
  DAOInterface& operator&(PRIMITIVE & t) { \
     impl->processPrim(t); \
     return *this; \
   }; 
   
  PROCESS_IFACE_PRIM(char)
  PROCESS_IFACE_PRIM(unsigned char)
  PROCESS_IFACE_PRIM(int)
  PROCESS_IFACE_PRIM(unsigned int)
  PROCESS_IFACE_PRIM(short)
  PROCESS_IFACE_PRIM(unsigned short)
  PROCESS_IFACE_PRIM(long)
  PROCESS_IFACE_PRIM(unsigned long)
  PROCESS_IFACE_PRIM(float)
  PROCESS_IFACE_PRIM(double)
  PROCESS_IFACE_PRIM(std::string)

  template<class RawObj>
  DAOInterface& byteCopy(RawObj *obj, unsigned int dataSize) {
    impl->byteCopy((char*)obj, dataSize);
    return *this;
  };

  DAOInterface& operator&(DAOSerializable &t) {
    t.serialize(*this);
    return *this;
  };

  byte_array* getOutputData() {
    if (getMode() == DAO_OUTPUT) return ((OutputDAO*)impl)->getOutputData();
    return NULL;
  };
  
  template<class ExtClass>
  void invokeExternalSerializer(ExtClass &extObj, void (*eS)(DAOInterface&,ExtClass&)) {
     eS(*this, extObj);
  }
  

  template<class Serializable>
  DAOInterface& operator&(Serializable* & t) {
    t = (Serializable*)impl->processExternalObj((DAOSerializable*)t);
    t->serialize(*this);
    return *this;
  };

 private:
  CommonDAO* impl;
};

class DAOInterfaceFactory {
 public:
  virtual DAOInterface* createInputDAO()=0;
  virtual DAOInterface* createOutputDAO()=0;
};

#endif /*CKPTDAO_H_*/

---