CkptRawDAO.h

Go to the documentation of this file.

#ifndef RAWDAO_H_
#define RAWDAO_H_

#include "CkptDAO.h"
#include "CkptByteArray.h"

class RawOutputDAO : public OutputDAO {
 public:
  virtual ~RawOutputDAO() {}
  #define PROCESS_OUTPUT_PRIM(Prim) \
  virtual void processPrim(Prim &t) { \
    bArray.write(t); \
  };

  //PROCESS_OUTPUT_PRIM(bool)
  PROCESS_OUTPUT_PRIM(char)
  PROCESS_OUTPUT_PRIM(unsigned char)
  PROCESS_OUTPUT_PRIM(int)
  PROCESS_OUTPUT_PRIM(unsigned int)
  PROCESS_OUTPUT_PRIM(short)
  PROCESS_OUTPUT_PRIM(unsigned short)
  PROCESS_OUTPUT_PRIM(long)
  PROCESS_OUTPUT_PRIM(unsigned long)
  PROCESS_OUTPUT_PRIM(float)
  PROCESS_OUTPUT_PRIM(double)
  PROCESS_OUTPUT_PRIM(std::string)
 
  virtual void byteCopy(char* data, unsigned int dataSize) {
    bArray.write(dataSize);
    bArray.writeBytes(data, dataSize);
  };
  
  virtual DAOSerializable* processExternalObj(DAOSerializable* t) {
    //std::cout << "[OUTPUT] External object. type=" << t->getClassname() << std::endl;
    std::string cName = t->getClassname();
    bArray.write(cName);
    return t;   
  };

  virtual byte_array* getOutputData() { return &bArray; };
  
private:
  byte_array bArray;
};
class RawInputDAO : public InputDAO{
 public:
  RawInputDAO() : InputDAO() { }
  RawInputDAO(byte_array *bA) : InputDAO(bA) { }
  virtual ~RawInputDAO() {}

  #define PROCESS_INPUT_PRIM(Prim, AccessFunc) \
  virtual void processPrim(Prim &t) { \
    t = bArray->AccessFunc(); \
  };
  
  //PROCESS_INPUT_PRIM(bool, readBool)
  PROCESS_INPUT_PRIM(char, readChar)
  PROCESS_INPUT_PRIM(unsigned char, readUChar)
  PROCESS_INPUT_PRIM(int, readInt)
  PROCESS_INPUT_PRIM(unsigned int, readUInt)
  PROCESS_INPUT_PRIM(short, readShort)
  PROCESS_INPUT_PRIM(unsigned short, readUShort)
  PROCESS_INPUT_PRIM(long, readLong)
  PROCESS_INPUT_PRIM(unsigned long, readULong)
  PROCESS_INPUT_PRIM(float, readFloat)
  PROCESS_INPUT_PRIM(double, readDouble)
  PROCESS_INPUT_PRIM(std::string, readString)

  virtual void byteCopy(char* data, unsigned int dataSize) {
    dataSize = bArray->readUInt();
    unsigned int actual = bArray->readBytes(data, dataSize);
    assert(actual == dataSize);
  };
 
  virtual DAOSerializable* processExternalObj(DAOSerializable* t) {
    std::string cName = bArray->readString();
    //std::cout << "[INPUT] External object. type=" << cName << std::endl;
    assert(ofMap[cName] != NULL);
    return (DAOSerializable*)ofMap[cName]();
  };

};

class RawDAOFactory : public DAOInterfaceFactory {
 public:
  DAOInterface* createInputDAO() { 
     return new DAOInterface(new RawInputDAO()); 
  };
  DAOInterface* createInputDAO(byte_array *bA) {
     return new DAOInterface(new RawInputDAO(bA));
  };
  DAOInterface* createOutputDAO() {
     return new DAOInterface(new RawOutputDAO);
  };
};

#endif /*RAWDAO_H_*/

---