Record.h

Go to the documentation of this file.

// $Id: Record.h 4472 2020-04-15 13:33:18Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_Record
#define DABC_Record
 
#ifndef DABC_Object
#include "dabc/Object.h"
#endif
 
#ifndef DABC_Buffer
#include "dabc/Buffer.h"
#endif
 
#include <vector>
#include <map>
 
namespace dabc {
 
   class ConfigIO;
   class DateTime;
 
   // =================================================================================
 
   class RecordFieldsMap;
 
   class iostream {
      protected:
         bool fInput;
 
         virtual uint64_t tmpbuf_size() const { return 0; }
         virtual char* tmpbuf() const { return 0; }
 
         iostream() : fInput(false) { }
         iostream(bool isinp) : fInput(isinp) { }
 
      public:
         virtual ~iostream() {}
 
         bool is_input() const { return fInput; }
         bool is_output() const { return !fInput; }
         virtual bool is_real() const { return true; }
 
         bool skip_object();
 
         bool verify_size(uint64_t pos, uint64_t sz);
 
         virtual bool write(const void* src, uint64_t len) { return false; }
         virtual bool read(void* tgt, uint64_t len) { return false; }
         virtual bool shift(uint64_t len) { return false; }
         virtual uint64_t size() const { return 0; }
 
         virtual uint64_t maxstoresize() const { return 0; }
 
         bool write_int32(int32_t v) { return write(&v, sizeof(int32_t)); }
         bool write_uint32(uint32_t v) { return write(&v, sizeof(uint32_t)); }
         bool write_int64(int64_t v) { return write(&v, sizeof(int64_t)); }
         bool write_uint64(uint64_t v) { return write(&v, sizeof(uint64_t)); }
         bool write_double(double v) { return write(&v, sizeof(double)); }
 
         bool read_int32(int32_t& v) { return read(&v, sizeof(int32_t)); }
         bool read_uint32(uint32_t& v) { return read(&v, sizeof(uint32_t)); }
         bool read_int64(int64_t& v) { return read(&v, sizeof(int64_t)); }
         bool read_uint64(uint64_t& v) { return read(&v, sizeof(uint64_t)); }
         bool read_double(double& v) { return read(&v, sizeof(double)); }
 
 
         static uint64_t str_storesize(const std::string &str);
 
         bool write_str(const std::string &str);
 
         bool read_str(std::string& str);
   };
 
   // ===================================================================================
 
   class sizestream : public iostream {
      protected:
         uint64_t fLength;
 
      public:
 
         sizestream() :
            iostream(false),
            fLength(0)
         {
         }
 
         virtual ~sizestream() {}
 
         virtual uint64_t size() const { return fLength; }
         virtual uint64_t maxstoresize() const { return 0xffffffffLLU; }
 
         virtual bool is_real() const { return false; }
 
         virtual bool shift(uint64_t len) { fLength += len; return true; }
 
         virtual bool write(const void* src, uint64_t len) { fLength += len; return true; }
 
         virtual bool read(void* tgt, uint64_t len) { return true; }
 
   };
 
   // ===================================================================================
 
   class memstream : public iostream {
      protected:
         char* fMem;
         uint64_t fLength;
         char* fCurr;
         uint64_t fRemains;
 
         virtual uint64_t tmpbuf_size() const { return fRemains; }
         virtual char* tmpbuf() const { return fCurr; }
 
      public:
 
         virtual uint64_t size() const { return fCurr - fMem; }
         virtual uint64_t maxstoresize() const { return fRemains; }
 
         virtual bool shift(uint64_t len);
         virtual bool write(const void* src, uint64_t len);
         virtual bool read(void* tgt, uint64_t len);
 
         memstream(bool isinp, char* buf, uint64_t len) :
            iostream(isinp),
            fMem(buf),
            fLength(len),
            fCurr(buf),
            fRemains(len)
         {
         }
 
         virtual ~memstream() {}
   };
 
   // ===================================================================================
 
 
   enum HStoreMask {
      storemask_Compact =    0x03,   // 0..3 level of compactness
      storemask_Version =    0x04,   // write all versions
      storemask_TopVersion = 0x08,   // write version only for top node
      storemask_History =    0x10,   // write full history in the output
      storemask_NoChilds =   0x20,
      storemask_AsXML    =   0x80    // create XML output
   };
 
   // ===================================================================================
 
   class HStore {
      protected:
         unsigned          fMask;
         std::string       buf;
         int               lvl;
         std::vector<int>  numflds;
         std::vector<int>  numchilds;
         uint64_t          fVersion;
         unsigned          fHLimit;
         bool              first_node;
 
         unsigned compact() const { return mask() & storemask_Compact; }
 
         void NewLine()
         {
            if (compact()<2) buf.append("\n"); else
            if (compact()<3) buf.append(" ");
         }
 
         bool isxml() { return (mask() & storemask_AsXML) != 0; }
 
      public:
         HStore(unsigned m = 0) : fMask(m), buf(), lvl(0), numflds(), numchilds(), fVersion(0), fHLimit(0), first_node(true) {}
         virtual ~HStore() {}
 
         void SetLimits(uint64_t v, unsigned hlimit) { fVersion = v; fHLimit = hlimit; }
 
         unsigned mask() const { return fMask; }
         void SetMask(unsigned m) { fMask = m; }
 
         uint64_t version() const { return fVersion; }
         unsigned hlimit() const { return fHLimit; }
 
         std::string GetResult() { return buf; }
 
         void CreateNode(const char * nodename);
         void SetField(const char * name, const char * value);
         void BeforeNextChild(const char* basename = 0);
         void CloseChilds();
         void CloseNode(const char * nodename);
   };
 
   // =========================================================
 
   class RecordField {
      friend class RecordFieldsMap;
 
      protected:
         enum ValueKind {
            kind_none      = 0,
            kind_bool      = 1,
            kind_int       = 2,
            kind_datime    = 3,
            kind_uint      = 4,
            kind_double    = 5,
            kind_arrint    = 6,
            kind_arruint   = 7,
            kind_arrdouble = 8,
            kind_string    = 9,
            kind_arrstr    = 10,
            kind_buffer    = 11,
            kind_reference = 12
         };
 
         ValueKind fKind;
 
         union {
            int64_t valueInt;      
            uint64_t valueUInt;    
            double valueDouble;    
         };
 
         union {
            int64_t* arrInt;       
            uint64_t* arrUInt;     
            double* arrDouble;     
            char* valueStr;        
            Buffer* valueBuf;      
            Reference* valueRef;   
         };
 
         bool                fModified;    
         bool                fTouched;     
         bool                fProtected;   
 
         void release();
 
         bool modified(bool reallychanged = true)
         {
            if (reallychanged) fModified = true;
            return true;
         }
 
         bool isreadonly() const { return false; }
         bool cannot_modify();
 
         void SetArrStrDirect(int64_t size, char* arr, bool owner = false);
 
         void constructor() { fKind = kind_none; fModified = false; fTouched = false; fProtected = false; }
 
      public:
         RecordField();
         RecordField(const RecordField& src);
         RecordField(const char* v) { constructor(); SetStr(v); }
         RecordField(const std::string &v) { constructor(); SetStr(v); }
         RecordField(const int& v) { constructor(); SetInt(v); }
         RecordField(const int64_t& v) { constructor(); SetInt(v); }
         RecordField(const unsigned& v) { constructor(); SetUInt(v); }
         RecordField(const uint64_t& v) { constructor(); SetUInt(v); }
         RecordField(const double& v) { constructor(); SetDouble(v); }
         RecordField(const bool& v) { constructor(); SetBool(v); }
         RecordField(const DateTime& v) { constructor(); SetDatime(v); }
         RecordField(const std::vector<int64_t>& v) { constructor(); SetVectInt(v); }
         RecordField(const std::vector<uint64_t>& v) { constructor(); SetVectUInt(v); }
         RecordField(const std::vector<double>& v) { constructor(); SetVectDouble(v); }
         RecordField(const std::vector<std::string>& v) { constructor(); SetStrVect(v); }
         RecordField(const Buffer& buf) { constructor(); SetBuffer(buf); }
         RecordField(const Reference& ref) { constructor(); SetReference(ref); }
 
         RecordField& operator=(const RecordField& src) { SetValue(src); return *this; }
 
         virtual ~RecordField();
 
         bool null() const { return fKind == kind_none; }
 
         bool IsModified() const { return fModified; }
         void SetModified(bool on = true) { fModified = on; }
 
         bool IsProtected() const { return fProtected; }
         void SetProtected(bool on = true) { fProtected = on; }
 
         bool IsArray() const
         {
            return (fKind == kind_arrint) ||
                   (fKind == kind_arruint) ||
                   (fKind == kind_arrdouble) ||
                   (fKind == kind_arrstr);
         }
         int64_t GetArraySize() const { return IsArray() ? valueInt : -1; }
 
         bool AsBool(bool dflt = false) const;
         int64_t AsInt(int64_t dflt = 0) const;
         uint64_t AsUInt(uint64_t dflt = 0) const;
         double AsDouble(double dflt = 0.) const;
         std::string AsStr(const std::string &dflt = "") const;
         std::vector<int64_t> AsIntVect() const;
         int64_t* GetIntArr() const { return fKind == kind_arrint ? arrInt : 0; }
         std::vector<uint64_t> AsUIntVect() const;
         uint64_t* GetUIntArr() const { return fKind == kind_arruint ? arrUInt : 0; }
         std::vector<double> AsDoubleVect() const;
         double* GetDoubleArr() const { return fKind == kind_arrdouble ? arrDouble : 0; }
         std::vector<std::string> AsStrVect() const;
         dabc::Buffer AsBuffer() const;
         dabc::Reference AsReference() const;
 
         std::string AsJson() const;
 
         bool SetValue(const RecordField& src);
         bool SetNull();
         bool SetBool(bool v);
         bool SetInt(int64_t v);
         bool SetDatime(uint64_t v);
         bool SetDatime(const DateTime& v);
         bool SetUInt(uint64_t v);
         bool SetDouble(double v);
         bool SetStr(const std::string &v);
         bool SetStr(const char* v);
         bool SetStrVect(const std::vector<std::string>& vect);
         bool SetBuffer(const Buffer& buf);
         bool SetReference(const Reference& ref);
 
         bool SetArrInt(int64_t size, int64_t* arr, bool owner = false);
         bool SetVectInt(const std::vector<int64_t>& v);
         bool SetArrUInt(int64_t size, uint64_t* arr, bool owner = false);
         bool SetVectUInt(const std::vector<uint64_t>& v);
         bool SetArrDouble(int64_t size, double* arr, bool owner = false);
         bool SetVectDouble(const std::vector<double>& v);
 
         bool SetArrStr(int64_t size, char* arr, bool owner = false);
 
         uint64_t StoreSize();
         bool Stream(iostream& s);
 
         static bool NeedJsonReformat(const std::string &str);
         static std::string JsonReformat(const std::string &str);
 
         static bool StrToStrVect(const char* str, std::vector<std::string>& vect, bool verbose = true);
   };
 
   class RecordFieldsMap {
      protected:
         typedef std::map<std::string, dabc::RecordField> FieldsMap;
 
         FieldsMap fMap;
 
         bool   fChanged;               
 
         void clear() { fMap.clear(); }
 
         static bool match_prefix(const std::string &name, const std::string &prefix);
 
      public:
 
         RecordFieldsMap();
         virtual ~RecordFieldsMap();
 
         uint64_t StoreSize(const std::string &nameprefix = "");
         bool Stream(iostream& s, const std::string &nameprefix = "");
 
         bool HasField(const std::string &name) const;
         bool RemoveField(const std::string &name);
 
         unsigned NumFields() const { return fMap.size(); }
         std::string FieldName(unsigned n) const;
 
         RecordField& Field(const std::string &name) { return fMap[name]; }
 
         bool SaveTo(HStore& res);
 
         void CopyFrom(const RecordFieldsMap& src, bool overwrite = true);
 
         void MoveFrom(RecordFieldsMap& src);
 
         void MakeAsDiffTo(const RecordFieldsMap& src);
 
         void ApplyDiff(const RecordFieldsMap& diff);
 
         RecordFieldsMap* Clone();
 
         bool WasChanged() const;
 
         bool WasChangedWith(const std::string &prefix);
 
         void ClearChangeFlags();
   };
 
   // ===========================================================================
 
   class RecordContainer : public Object {
      friend class Record;
      friend class RecordField;
      friend class ConfigIO;
      friend class RecordFieldsMap;
 
      protected:
         RecordFieldsMap* fFields;
 
         RecordContainer(const std::string &name, unsigned flags = flIsOwner);
 
         RecordContainer(Reference parent, const std::string &name, unsigned flags = flIsOwner);
 
         RecordFieldsMap* TakeFieldsMap();
 
         void SetFieldsMap(RecordFieldsMap* newmap);
 
         virtual bool HasField(const std::string &name) const
            { return Fields().HasField(name); }
 
         virtual bool RemoveField(const std::string &name)
            { return Fields().RemoveField(name); }
 
         virtual unsigned NumFields() const
            { return Fields().NumFields(); }
 
         virtual std::string FieldName(unsigned cnt) const
            { return Fields().FieldName(cnt); }
 
         virtual RecordField GetField(const std::string &name) const
            { return Fields().Field(name); }
 
         virtual bool SetField(const std::string &name, const RecordField& v)
            { return Fields().Field(name).SetValue(v); }
 
         virtual bool SaveTo(HStore& store, bool create_node = true);
 
      public:
 
         virtual ~RecordContainer();
 
         virtual const char* ClassName() const { return "Record"; }
 
         virtual void Print(int lvl = 0);
 
         RecordFieldsMap& Fields() const { return *fFields; }
   };
 
   // ===================================================================================
 
 
   class Record : public Reference  {
 
      DABC_REFERENCE(Record, Reference, RecordContainer)
 
      bool HasField(const std::string &name) const
        { return null() ? false : GetObject()->HasField(name); }
 
      bool RemoveField(const std::string &name)
        { return null() ? false : GetObject()->RemoveField(name); }
 
      unsigned NumFields() const
        { return null() ? 0 : GetObject()->NumFields(); }
 
      std::string FieldName(unsigned cnt) const
        { return null() ? std::string() : GetObject()->FieldName(cnt); }
 
      RecordField GetField(const std::string &name) const
        { return null() ? RecordField() : GetObject()->GetField(name); }
 
      RecordField* GetFieldPtr(const std::string &name) const
        { return HasField(name) ?  &(GetObject()->Fields().Field(name)) : 0; }
 
      bool SetField(const std::string &name, const RecordField &v)
        { return null() ? false : GetObject()->SetField(name, v); }
 
      bool SetFieldModified(const std::string &name, bool on = true)
      {
         if (!HasField(name)) return false;
         GetObject()->Fields().Field(name).SetModified(on);
         return true;
      }
 
      bool SetFieldProtected(const std::string &name, bool on = true)
      {
         if (!HasField(name)) return false;
         GetObject()->Fields().Field(name).SetProtected(on);
         return true;
      }
 
      bool SaveTo(HStore &store, bool create_node = true)
      {  return null() ? false : GetObject()->SaveTo(store, create_node); }
 
      std::string SaveToJson(unsigned mask = 0);
 
      std::string SaveToXml(unsigned mask = 0);
 
      bool Stream(iostream &s);
 
      dabc::Buffer SaveToBuffer();
 
      bool ReadFromBuffer(const dabc::Buffer &buf);
 
      virtual void CreateRecord(const std::string &name);
 
   };
 
}
 
#endif