CrestContainer.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 */

 
 
#ifndef CREST_COND_CONTAINER_H
#define CREST_COND_CONTAINER_H
#include <vector>
#include <string>
#include <utility>
#include <map>
#include "nlohmann/json.hpp"
 
namespace Crest {
  enum class TypeId {
    Bool, UChar, Int16, UInt16,
    Int32, UInt32, UInt63, Int64,
    Float, Double, String, String255, String4k,
    String64k, String16M, String128M, Blob64k, Blob16M, Blob128M, Blob, TypeIdCount
  };
  const static std::map<TypeId, std::string> s_typeToString = { 
    { TypeId::Bool, "Bool" },
    { TypeId::UChar, "UChar" },
    { TypeId::Int16, "Int16" },
    { TypeId::UInt16, "UInt16" },
    { TypeId::Int32, "Int32" },
    { TypeId::UInt32, "UInt32" },
    { TypeId::UInt63, "UInt63" },
    { TypeId::Int64, "Int64" },
    { TypeId::Float, "Float" },
    { TypeId::Double, "Double" },
    {TypeId::String, "String"},
    { TypeId::String255, "String255" },
    { TypeId::String4k, "String4k" },
    { TypeId::String64k, "String64k" },
    { TypeId::String16M, "String16M" },
    { TypeId::String128M,"String128M"},
    { TypeId::Blob64k, "Blob64k" },
    { TypeId::Blob16M, "Blob16M" },
    { TypeId::Blob128M, "Blob128M" },
    { TypeId::Blob, "Blob" } 
  };
 
  enum class ModeId{
    Standard, DCS, DCS_FULL
  };

  //static bool compareStrTimestamp(std::string& as, std::string& bs);
 
  class CrestContainer{
    public:       
      CrestContainer(ModeId mode=ModeId::Standard);
      ~CrestContainer();
      void addColumn(const std::string& name, TypeId type);      
      void addColumn(const std::string& name, const std::string& type);
      bool isVectorPayload();
      void setVectorPayload(bool isVectorPayload);
      void putRow2Vector();
      void addNullRecord(const std::string& name);
      void addRecord(const std::string& name,int number, ...);
      void addData(const std::string& channel_id);
      void addExternalData(const std::string& channel_id, const nlohmann::json& data);
      void addIov(const uint64_t since);
      const std::vector<std::pair<std::string,TypeId>>& getMPayloadSpec();
      const nlohmann::json& getPayload();
      const nlohmann::json& getIovData();
      const nlohmann::json getPayloadChannel(const std::string& channel_id);

      nlohmann::json getPayloadSpec();
      int getColumnIndex(const std::string& name);
      void flush();
      void clear();
      void selectIov(const uint64_t since);
      std::vector<std::string> channelIds();
      std::string getJsonPayload();
      std::string getJsonIovData();
      void dumpJsonToFile(const nlohmann::json& j, const std::string& filename);
      nlohmann::json readJsonFromFile(const std::string& filename, const std::string& spec_filename);
      std::vector<uint64_t> fromJson(uint64_t since,const nlohmann::json& j);
      nlohmann::json getStoreSetDto(uint64_t period=-1);
      uint64_t getFirstTime();
      void parseData(const nlohmann::json & values);
 
    private:
      std::vector<std::pair<std::string,TypeId>> m_payload_spec;
      nlohmann::json m_payload={};
      nlohmann::json m_row={};
      nlohmann::json m_iov_data={};
      nlohmann::json m_vector_data=nlohmann::json::array();
      std::map<uint64_t,nlohmann::json> m_full_data;
      ModeId m_modeId;
      bool m_isVectorPayload=false;
 
      nlohmann::json createRowArray(const nlohmann::json& data_row) const;
      const nlohmann::json& getRow();
      void parseOldFormat(const std::string& colName, const TypeId& typespec, const nlohmann::json & j);
      void readCommonType(uint64_t since, const nlohmann::json &j_in);
      std::vector<uint64_t> readDcsFullType(const nlohmann::json &j_in);
      void setIovData(const nlohmann::json& j);
      void setPayload(const nlohmann::json& j);
      void setPayloadSpec(const nlohmann::json& j);
 
  };
}
#endif