CrestContainer.h

Go to the documentation of this file.

/*
   Copyright (C) 2019-2024 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef CREST_COND_CONTAINER_H
#define CREST_COND_CONTAINER_H
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <utility>
#include <map>
#include "nlohmann/json.hpp"
 
namespace Crest {
  enum class TypeId {
    Bool, UChar, Int16, UInt16,
    Int32, UInt32, UInt63, Int64,
    Float, Double, String255, String4k,
    String64k, String16M, String128M, Blob64k, Blob16M, Blob128M, 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::String255, "String255" },
    { TypeId::String4k, "String4k" },
    { TypeId::String64k, "String64k" },
    { TypeId::String16M, "String16M" },
    { TypeId::String128M,"String128M"},
    { TypeId::Blob64k, "Blob64k" },
    { TypeId::Blob16M, "Blob16M" },
    { TypeId::Blob128M, "Blob128M" } 
  };
 
  enum class ModeId{
    Standard, DCS, DCS_FULL
  };
  class CrestContainer{
    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();
      nlohmann::json m_full_data={};
      ModeId m_modeId;
      bool m_isVectorPayload=false;
 
      void validatePayloadSize(const nlohmann::json &data) const;
      nlohmann::json createRowArray(const nlohmann::json& data_row) const;
      const nlohmann::json& getRow();
 
    public:
      CrestContainer();
      ~CrestContainer();
      void addColumn(const std::string& name, TypeId type);
      void addColumn(const std::string& name, const char* type);
      void addColumn(const std::string& name, uint32_t type);
 
      bool isVectorPayload();
      void setVectorPayload(bool isVectorPayload);
 
      Crest::TypeId stringToTypeId(const std::string& type) const;
      Crest::TypeId intToTypeId(int value) const;
 
      void putRow2Vector();
 
      void addNullRecord(const char* name);
 
      void addRecord(const char* name,int number, ...);
      void addData(const char* channel_id);
      void addExternalData(const char* channel_id, const nlohmann::json& data);
      void addIov(const uint64_t since);
 
      const std::vector<std::pair<std::string,TypeId>>& getMPayloadSpec();
 
      template<typename T> T getRecord(const std::string& name) 
      {
        for (const auto& column : m_payload_spec) {
          if (column.first == name) {
              try {
                  return m_row.at(name).get<T>();
              } catch (nlohmann::json::exception& e) {
                  throw std::runtime_error("JSON exception for key: " + name);
              }
          }
        }
        throw std::runtime_error("Column name not found or type mismatch.");
      }
 
      const nlohmann::json& getPayload();
      const nlohmann::json& getIovData();
 
      const nlohmann::json& getPayloadChannel(const char* channel_id);
 
 
      void setIovData(const nlohmann::json& j);
      void setPayload(const nlohmann::json& j);
      // return the payload spec as a copy
      nlohmann::json getPayloadSpec();
      void setPayloadSpec(const nlohmann::json& j);
 
      static std::string base64_encode(const uint8_t* bytes_to_encode, unsigned int in_len);
      static std::vector<unsigned char> base64_decode(const std::string& encodedData);
      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 dump_json_to_file(const nlohmann::json& j, const std::string& filename);
      nlohmann::json read_json_from_file(const std::string& filename, const std::string& spec_filename);
      void from_json(const uint64_t since, const nlohmann::json& j);
 
      void parseOldFormat(std::string& colName, TypeId& typespec,const nlohmann::json & j);
  };
}
#endif