Crest::CrestContainer Class Reference

It compares timestamp in string format. More...

#include <CrestContainer.h>

Collaboration diagram for Crest::CrestContainer:

Public Member Functions
	CrestContainer (ModeId mode=ModeId::Standard)
	Constructor of CrestContainer.
	~CrestContainer ()
	Destructor of CrestContainer.
void	addColumn (const std::string &name, TypeId type)
	It adds a column to the payload specification.
void	addColumn (const std::string &name, const std::string &type)
	It adds a column to the payload specification.
bool	isVectorPayload ()
	It sets the Vector mode of the container.
void	setVectorPayload (bool isVectorPayload)
	Set the Vectore mode of the container.
void	putRow2Vector ()
	It adds row data to vector.
void	addNullRecord (const std::string &name)
	It adds a null value to the payload.
void	addRecord (const std::string &name, int number,...)
	It adds a record to the payload.
void	addData (const std::string &channel_id)
	It associate the payload row to a channel_id.
void	addExternalData (const std::string &channel_id, const nlohmann::json &data)
	It associate the payload row to a channel_id.
void	addIov (const uint64_t since)
	It adds an IOV to the json object m_iov_data.
const std::vector< std::pair< std::string, TypeId > > &	getMPayloadSpec ()
	Return tag specification in vector format.
const nlohmann::json &	getPayload ()
	Return current payload in json format.
const nlohmann::json &	getIovData ()
	Return selected IOV in json format.
const nlohmann::json	getPayloadChannel (const std::string &channel_id)
	Return payload in json format for selected channel id.
nlohmann::json	getPayloadSpec ()
	Return payload specification in json format.
int	getColumnIndex (const std::string &name)
	It returns the index of the column with the given name.
void	flush ()
	It reinitializes the containers.
void	clear ()
	It clear data the container.
void	selectIov (const uint64_t since)
	It select timestamp as active.
std::vector< std::string >	channelIds ()
	Return list of channel id in string format.
std::string	getJsonPayload ()
	It returns the json representation of the container.
std::string	getJsonIovData ()
	It returns the json representation of the container.
void	dumpJsonToFile (const nlohmann::json &j, const std::string &filename)
	It creates a file with the json representation of the container.
nlohmann::json	readJsonFromFile (const std::string &filename, const std::string &spec_filename)
	It reads a json file and returns the json object.
std::vector< uint64_t >	fromJson (uint64_t since, const nlohmann::json &j)
	It reads a json object to fill the container.
nlohmann::json	getStoreSetDto (uint64_t period=-1)
	It return StoreSetDto in json format.
uint64_t	getFirstTime ()
	It return minimal timestamp in concainer.
void	parseData (const nlohmann::json &values)
	It reads a json object, parse it and fill the container.

Private Member Functions
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)

Private Attributes
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

Detailed Description

It compares timestamp in string format.

Definition at line 58 of file CrestContainer.h.

Constructor & Destructor Documentation

CrestContainer()

Crest::CrestContainer::CrestContainer

(

Crest::ModeId

mode = ModeId::Standard

)

Constructor of CrestContainer.

Parameters

mode	Set mode of data. In current moment support two mode: Standard (default mode) and DCS_FULL (DCS mode with full data for each timestamp)

Definition at line 13 of file CrestContainer.cxx.

: m_modeId(mode) { ; }

~CrestContainer()

Crest::CrestContainer::~CrestContainer

(

)

Destructor of CrestContainer.

Definition at line 14 of file CrestContainer.cxx.

{
  flush();
}

Member Function Documentation

addColumn() [1/2]

void Crest::CrestContainer::addColumn	(	const std::string &	name,
		const std::string &	type )

It adds a column to the payload specification.

Parameters

name	The name of the column.
type	The type of the column in string format.

This method adds a column to the payload specification. filling the vector m_payload_spec. The methods with a different signature are just overloads to make it easier to use.

Definition at line 39 of file CrestContainer.cxx.

{
    
  for(auto& t:  s_typeToString){
    if(t.second.compare(type)==0){
      addColumn(name, t.first);
      return;
    }
  }
  throw CommonCrestException("The type of parameter is not defined.");  
}

addColumn() [2/2]

void Crest::CrestContainer::addColumn	(	const std::string &	name,
		TypeId	type )

It adds a column to the payload specification.

Parameters

name	The name of the column.
type	The type of the column.

This method adds a column to the payload specification. filling the vector m_payload_spec. The methods with a different signature are just overloads to make it easier to use.

Definition at line 34 of file CrestContainer.cxx.

{
  m_payload_spec.emplace_back(name, type);
}

addData()

void Crest::CrestContainer::addData

(

const std::string &

channel_id

)

It associate the payload row to a channel_id.

Parameters

channel_id

The channel_id to associate the payload row.

The method adds the current payload row to the json object m_payload. The row is associated with the channel_id.

Definition at line 118 of file CrestContainer.cxx.

{
  addExternalData(channel_id, getRow());
}

addExternalData()

void Crest::CrestContainer::addExternalData	(	const std::string &	channel_id,
		const nlohmann::json &	data )

It associate the payload row to a channel_id.

Parameters

channel_id	The channel_id to associate the payload row.
data	The data to be associated with the channel_id.

The method adds the payload row to the json object m_payload. The row is associated with the channel_id. The data is the data to be associated with the channel_id, and they belong to a previously filled payload row.

Definition at line 123 of file CrestContainer.cxx.

{
  nlohmann::json arr_data = m_isVectorPayload ? nlohmann::json::array() : nlohmann::json();
  if (m_isVectorPayload){
    for (const auto &data_row : data)
    {
        arr_data.emplace_back(createRowArray(data_row));
    }
    m_payload[channel_id] = std::move(arr_data);
    }
  else{
    m_payload[channel_id] = createRowArray(data);
  }
  m_vector_data.clear();
  m_row.clear();
}

addIov()

void Crest::CrestContainer::addIov

(

const uint64_t

since

)

It adds an IOV to the json object m_iov_data.

Parameters

since

The since value of the IOV.

The data is a json object containing all channels stored before, and kept in m_payload.

Definition at line 155 of file CrestContainer.cxx.

{
  m_iov_data["since"] = since;
  m_iov_data["data"] = m_payload;
  m_full_data[since]=m_payload;
  m_payload.clear();
}

addNullRecord()

void Crest::CrestContainer::addNullRecord

(

const std::string &

name

)

It adds a null value to the payload.

Parameters

name	The name of the column.

This method adds a null to the payload. It fills the json object m_row.

Definition at line 51 of file CrestContainer.cxx.

{
  auto it = std::find_if(m_payload_spec.begin(), m_payload_spec.end(),
                         [&name](const auto &column)
                         { return column.first == name; });
 
  if (it != m_payload_spec.end())
  {
    m_row[name] = nlohmann::json::value_t::null;
  }
}

addRecord()

void Crest::CrestContainer::addRecord	(	const std::string &	name,
		int	number,
			... )

It adds a record to the payload.

Parameters

name	The name of the column.
number	The number of parameters.
...	The values of the record.

This method adds a record to the payload. It fills the json object m_row.

Definition at line 63 of file CrestContainer.cxx.

{
  va_list ap;
  va_start(ap, number);
 
  for (auto &column : m_payload_spec)
  {
    if (column.first != name)
    {
      continue;
    }
 
    switch (column.second)
    {
    case TypeId::Bool:
      m_row[name] = va_arg(ap, int)==1;
      break;
    case TypeId::UChar:
      m_row[name] = static_cast<unsigned char>(va_arg(ap, int));
      break;
    case TypeId::Int16:
    case TypeId::Int32:
      m_row[name] = va_arg(ap, int);
      break;
    case TypeId::UInt16:
    case TypeId::UInt32:
      m_row[name] = va_arg(ap, unsigned int);
      break;
    case TypeId::UInt63:
      m_row[name] = va_arg(ap, uint64_t);
      break;
    case TypeId::Int64:
      m_row[name] = va_arg(ap, int64_t);
      break;
    case TypeId::Float:
    case TypeId::Double:
      m_row[name] = va_arg(ap, double);
      break;
    case TypeId::String255:
    case TypeId::String4k:
    case TypeId::String64k:
    case TypeId::String16M:
    case TypeId::String128M:
    case TypeId::Blob64k:
    case TypeId::Blob16M:
    case TypeId::Blob128M:
      m_row[name] = std::string(va_arg(ap, const char *));
      break;
    default:
      throw CommonCrestException("Unsupported column type.");
    }
  }
  va_end(ap);
}

channelIds()

std::vector< std::string > Crest::CrestContainer::channelIds

(

)

Return list of channel id in string format.

Definition at line 183 of file CrestContainer.cxx.

                                                    {
  std::vector<std::string> chs;
  for (auto& x : m_iov_data["data"].items()){
    chs.push_back(x.key());
  }
  sort(chs.begin(), chs.end(), compareStrTimestamp);
  return chs;
}

clear()

void Crest::CrestContainer::clear

(

)

It clear data the container.

Definition at line 338 of file CrestContainer.cxx.

                               {
  m_payload.clear();
  m_iov_data.clear();
  m_row.clear();
  m_vector_data.clear();
  m_full_data={};
}

createRowArray()

nlohmann::json Crest::CrestContainer::createRowArray ( const nlohmann::json & data_row ) const

private

Definition at line 140 of file CrestContainer.cxx.

{
  nlohmann::json row_arr_data = nlohmann::json::array();
  for (const auto &column : m_payload_spec)
  {
    if (data_row.find(column.first) == data_row.end())
    {
      std::string msg = "The data does not contain the column: " + column.first;
      throw CommonCrestException(msg.c_str());
    }
    row_arr_data.push_back(data_row[column.first]);
  }
  return row_arr_data;
}

dumpJsonToFile()

void Crest::CrestContainer::dumpJsonToFile	(	const nlohmann::json &	j,
		const std::string &	filename )

It creates a file with the json representation of the container.

Definition at line 347 of file CrestContainer.cxx.

{
  std::ofstream file(filename);
  if (file.is_open())
  {
    file << std::setprecision(6) << j.dump(4);
    file.close();
  }
  else
  {
    std::cerr << "CondContainer::dumpJsonToFile: Error opening file: " << filename << std::endl;
    throw std::runtime_error("CondContainer::dumpJsonToFile: Error opening file.");
  }
}

flush()

void Crest::CrestContainer::flush

(

)

It reinitializes the containers.

Definition at line 330 of file CrestContainer.cxx.

{
  m_iov_data.clear();
  m_row.clear();
  m_vector_data.clear();
  m_full_data={};
}

fromJson()

std::vector< uint64_t > Crest::CrestContainer::fromJson	(	uint64_t	since,
		const nlohmann::json &	j )

It reads a json object to fill the container.

Definition at line 565 of file CrestContainer.cxx.

                                                                                        {
  if(m_modeId==Crest::ModeId::Standard)
  { 
    nlohmann::json j = j_in;
    if (j.is_string()){
      std::istringstream ss(to_string(j));
      std::string st;
      ss >> std::quoted(st);
      j = json::parse(st);
    }
    // Accessing the "data" object
    if (j.contains("data") && j["data"].is_object())
    {
      //const auto &data = j["data"];     
      readCommonType(since,j_in);
    }
    else if(j.is_object()){
      readCommonType(since,j);        
    }
    else
    {
      std::cerr << "CrestContainer::fromJson json:"<<j<<std::endl;
      throw CommonCrestException("CrestContainer::fromJson: JSON  is not a JSON object.");
    }
    std::vector<uint64_t> ret;
    ret.push_back(since);
    return ret;
  }
  else if(m_modeId==Crest::ModeId::DCS_FULL)
  {
    return readDcsFullType(j_in);
  }
  else
  {
    throw CommonCrestException("CrestContainer::fromJson: Unsupported type of payload.");     
  }  
}

getColumnIndex()

int Crest::CrestContainer::getColumnIndex

(

const std::string &

name

)

It returns the index of the column with the given name.

Parameters

name	The name of the column. It checks the payload spec array to get the index back.

Definition at line 211 of file CrestContainer.cxx.

{
  auto it = std::find_if(m_payload_spec.begin(), m_payload_spec.end(),
                         [&name](const auto &column)
                         { return column.first == name; });
 
  if (it != m_payload_spec.end())
  {
    return std::distance(m_payload_spec.begin(), it);
  }
  else
  {
    throw CommonCrestException("The column name is not found.");
  }
}

getFirstTime()

uint64_t Crest::CrestContainer::getFirstTime

(

)

It return minimal timestamp in concainer.

Definition at line 175 of file CrestContainer.cxx.

                                          {
  if(m_full_data.size()==0)
  {
    throw CommonCrestException("No IOV in CrestContainer");
  }
  return m_full_data.begin()->first;
}

getIovData()

const nlohmann::json & Crest::CrestContainer::getIovData

(

)

Return selected IOV in json format.

JSON has two filed: since (for timestamp) and data (for payload).

Definition at line 262 of file CrestContainer.cxx.

{
  if (m_iov_data.empty())
  {
    std::string msg = "The iov data is empty.";
    throw CommonCrestException(msg.c_str());
  }
  return m_iov_data;
}

getJsonIovData()

std::string Crest::CrestContainer::getJsonIovData

(

)

It returns the json representation of the container.

Definition at line 287 of file CrestContainer.cxx.

{
  return m_iov_data.dump();
}

getJsonPayload()

std::string Crest::CrestContainer::getJsonPayload

(

)

It returns the json representation of the container.

Definition at line 282 of file CrestContainer.cxx.

{
  return getPayload().dump();
}

getMPayloadSpec()

const std::vector< std::pair< std::string, Crest::TypeId > > & Crest::CrestContainer::getMPayloadSpec

(

)

Return tag specification in vector format.

Elements of vector is pair: name and type.

Definition at line 191 of file CrestContainer.cxx.

{
  return m_payload_spec;
}

getPayload()

const nlohmann::json & Crest::CrestContainer::getPayload

(

)

Return current payload in json format.

Definition at line 248 of file CrestContainer.cxx.

{
  if (m_payload.empty() && m_iov_data.empty())
  {
    std::string msg = "The payload is empty.";
    throw CommonCrestException(msg.c_str());
  }
  if (m_payload.empty())
  {
    m_payload = m_iov_data["data"];
  }
  return m_payload;
}

getPayloadChannel()

const nlohmann::json Crest::CrestContainer::getPayloadChannel

(

const std::string &

channel_id

)

Return payload in json format for selected channel id.

Parameters

channel_id

The channel id.

Definition at line 196 of file CrestContainer.cxx.

{
  if (m_payload.empty())
  {
    m_payload = m_iov_data["data"];
  }
  auto it = m_payload.find(channel_id);
  if (it == m_payload.end())
  {
    std::string msg = "Channel id " + std::string(channel_id) + " is not found.";
    throw CommonCrestException(msg.c_str());
  }
  return it.value();
}

getPayloadSpec()

json Crest::CrestContainer::getPayloadSpec

(

)

Return payload specification in json format.

Definition at line 292 of file CrestContainer.cxx.

{
  json pspec_data=json::array();
  for (auto &column : m_payload_spec)
  {
    json j={};
    std::map<TypeId, std::string>::const_iterator pos = Crest::s_typeToString.find(column.second);
    if (pos == Crest::s_typeToString.end()) {
      throw CommonCrestException("Type do not exist in the map.");
    } else {
      j[column.first] = pos->second;
    }
    pspec_data.push_back(j);
  }
  return pspec_data;
}

getRow()

const nlohmann::json & Crest::CrestContainer::getRow ( )

private

Definition at line 241 of file CrestContainer.cxx.

{
  if (m_isVectorPayload)
    return m_vector_data;
  return m_row;
}

getStoreSetDto()

nlohmann::json Crest::CrestContainer::getStoreSetDto

(

uint64_t

period = -1

)

It return StoreSetDto in json format.

Parameters

period

It set max interval for DSC data. Value '-1' mean that store all DCS data in one StoreDto. This parameter do not use for standard mode.

Definition at line 657 of file CrestContainer.cxx.

{
  nlohmann::json j;
  nlohmann::json resources = nlohmann::json::array();
  if(m_modeId==Crest::ModeId::Standard){
    nlohmann::json storeDto;
    // Loop over the iov list container to add the data to the storeDto
    for (const auto& [key, value] : m_full_data)
    {
      storeDto["since"] = key;
      storeDto["data"] = value.dump();
      storeDto["streamerInfo"] = "";//m_streamer_info_data.dump();
      resources.push_back(storeDto);
    }
  }
  else if(m_modeId==Crest::ModeId::DCS_FULL){
    uint64_t since = getFirstTime();
    nlohmann::json storeDto;
    nlohmann::json dcs_payload;
    nlohmann::json curPayload=m_full_data[since];
    for (const auto& [key, value] : m_full_data)
    {
      curPayload.update(value);     
      dcs_payload[std::to_string(key)]=curPayload;
      if(period>0 && (key-since)>period){
        storeDto["since"]=since;
    storeDto["data"]=dcs_payload.dump();
    storeDto["streamerInfo"] = "";
    resources.push_back(storeDto);
    since=key;
    dcs_payload={};
      }
    }
    if(dcs_payload.size()>0){
      storeDto["since"]=since;
      storeDto["data"]=dcs_payload.dump();
      storeDto["streamerInfo"] = "";
      resources.push_back(storeDto);
    }    
  }
  j["resources"] = resources;
  j["format"] = "StoreSetDto";
  j["datatype"] = "data";
  j["size"] = resources.size();
  
  return j;
}

isVectorPayload()

bool Crest::CrestContainer::isVectorPayload

(

)

It sets the Vector mode of the container.

Definition at line 19 of file CrestContainer.cxx.

{
  return m_isVectorPayload;
}

parseData()

void Crest::CrestContainer::parseData

(

const nlohmann::json &

values

)

It reads a json object, parse it and fill the container.

Parameters

values

The input json with data.

Definition at line 494 of file CrestContainer.cxx.

                                                              {
        if (values.is_array() && values.size() == m_payload_spec.size())
        {
          for (size_t i = 0; i < values.size(); ++i)
          {
            const auto & [colName,colType] = m_payload_spec[i];
            //const std::string & colName = spec.first;
            //TypeId colType = spec.second;
            if(values[i].is_string() &&( colType== TypeId::UChar || colType==TypeId::Bool || colType==TypeId::Int16 || colType==TypeId::UInt16
             || colType==TypeId::Int32 || colType==TypeId::UInt32 || colType==TypeId::Int64 || colType==TypeId::UInt63 || colType==TypeId::Float || colType==TypeId::Double))
        {
          parseOldFormat(colName,colType,values[i]);
          continue;
        }
        if(values[i].is_null()){
          m_row[colName] =  nullptr;
              continue;       
        }
            switch (colType)
            {
            case TypeId::Bool:
              m_row[colName] = values[i].get<bool>();
              break;
            case TypeId::UChar:
              m_row[colName] = values[i].get<unsigned char>();
              break;
            case TypeId::Int16:
            case TypeId::Int32:
              m_row[colName] = values[i].get<int>();
              break;
            case TypeId::UInt16:
            case TypeId::UInt32:
              m_row[colName] = values[i].get<unsigned int>();
            break;
            case TypeId::UInt63:
              m_row[colName] = values[i].get<uint64_t>();
              break;
            case TypeId::Int64:
              m_row[colName] = values[i].get<int64_t>();
              break;
            case TypeId::Float:
            case TypeId::Double:
              m_row[colName] = values[i].get<double>();
              break;
            case TypeId::String255:
            case TypeId::String4k:
            case TypeId::String64k:
            case TypeId::String16M:
            case TypeId::String128M:
              m_row[colName] = values[i].get<std::string>();
              break;
            case TypeId::Blob128M:
            case TypeId::Blob64k:
            case TypeId::Blob16M:
              m_row[colName] = values[i].get<std::string>();
              break;
            default:
              throw CommonCrestException("CrestContainer::parseData: Unsupported column type.");
            }
      }
        }
    else
    {
      if(!values.is_array())
        std::cerr << "CrestContainer::parseData values is not array"<<std::endl;
          else
            std::cerr << "CrestContainer::parseData values number="<<values.size() << " m_payload_spec.size()="<<m_payload_spec.size()<<std::endl;        
      throw CommonCrestException("CrestContainer::parseData: Mismatch in number of values.");   
    }
}

parseOldFormat()

void Crest::CrestContainer::parseOldFormat ( const std::string & colName, const TypeId & typespec, const nlohmann::json & j )

private

Definition at line 396 of file CrestContainer.cxx.

                                                                                                                     {
  try{
    if (thisVal.is_null()){
      m_row[colName] ="NULL";
      return;
    }
    std::string strVal = to_string(thisVal);
    if(strVal.size()>2&& strVal[0]=='"'&& strVal[strVal.size()-1]=='"')
    strVal=strVal.substr(1,strVal.size()-2);
    if((strVal.compare("NULL")==0||strVal.compare("null")==0)&&
          (typespec==TypeId::Bool || typespec==TypeId::Int16 || typespec==TypeId::UInt16
          || typespec==TypeId::Int32 || typespec==TypeId::UInt32
          || typespec==TypeId::Int64 || typespec==TypeId::UInt63
          || typespec==TypeId::Float || typespec==TypeId::Double)){
          m_row[colName] ="NULL";
      return;
    }
    switch (typespec) {
    case TypeId::Bool:
      {
        const bool newVal=(strVal == "true");
        m_row[colName] = newVal;
        break;
      }
    case TypeId::UChar:
      {
        m_row[colName]=std::stoul(strVal);
        break;
      }
    case TypeId::Int16:
      {
        m_row[colName]=std::stol(strVal);
        break;
      }
    case TypeId::UInt16:
      {
        m_row[colName]=std::stoul(strVal);
        break;
      }
    case TypeId::Int32:
      {
        m_row[colName]=std::stoi(strVal);
        break;
      }
    case TypeId::UInt32:
      {
        m_row[colName]=std::stoull(strVal);
        break;
      }
    case TypeId::UInt63:
      {
        m_row[colName]=std::stoull(strVal);
        break;
      }
    case TypeId::Int64:
      {
        m_row[colName]=std::stoll(strVal);
        break;
      }
    case TypeId::Float:
      {
        m_row[colName]=std::stof(strVal);
        break;
      }
    case TypeId::Double:
      {
        m_row[colName]=std::stod(strVal);
        break;
      }
    case TypeId::String255:
    case TypeId::String4k:
    case TypeId::String64k:
    case TypeId::String16M:
    case TypeId::String128M:
      {
        m_row[colName]=thisVal.get<std::string>();
        break;
      }
    case TypeId::Blob128M:
    case TypeId::Blob16M:
    case TypeId::Blob64k:
      {
            m_row[colName]=thisVal.get<std::string>();
        break;
      }
    default:
      {
        throw std::runtime_error("UNTREATED TYPE!");
      }
    }
 
  }
  catch(json::exception& e){
    std::cerr << e.what() << std::endl;
    throw std::runtime_error(e.what());      
  }
}

putRow2Vector()

void Crest::CrestContainer::putRow2Vector

(

)

It adds row data to vector.

This method should use for Vector type of data. It should call after all data of row is added.

Definition at line 227 of file CrestContainer.cxx.

{
  if (m_isVectorPayload)
  { 
    m_vector_data.push_back(m_row);
    m_row.clear();
  }
  else
  {
    std::string msg = "The payload is not a vector.";
    throw CommonCrestException(msg.c_str());
  }
}

readCommonType()

void Crest::CrestContainer::readCommonType ( uint64_t since, const nlohmann::json & j_in )

private

Definition at line 629 of file CrestContainer.cxx.

{
   if(j_in.empty()){
     addIov(since);      
     return;       
   }       
    // Loop over each channel in the data
    for (const auto &channel : j_in.items())
    {
      std::string channelKey = channel.key();
      const auto &data_ch = channel.value();
      nlohmann::json vecJson(json::value_t::array);
    if(m_isVectorPayload)
        vecJson=data_ch;
      else
        vecJson.push_back(data_ch);
 
      for (const auto &values : vecJson)
      {
        parseData(values);
    if(m_isVectorPayload)
      putRow2Vector();
      }
      addData(channelKey);
    }
  addIov(since);
}

readDcsFullType()

std::vector< uint64_t > Crest::CrestContainer::readDcsFullType ( const nlohmann::json & j_in )

private

Definition at line 602 of file CrestContainer.cxx.

{
  nlohmann::json j = j_in;
  if (j.is_string()){
    std::istringstream ss(to_string(j));
    std::string st;
    ss >> std::quoted(st);
    j = json::parse(st);
  } 
  nlohmann::json dcs_data;
  if (j.contains("data") && j["data"].is_object())
  {
    dcs_data = j["data"];
  }
  else
    dcs_data=j;
  std::vector<uint64_t> ret;
  if(j.is_object())
  {  
    for (const auto& [key, value] : dcs_data.items()){
      uint64_t since=std::stoull(key);
      readCommonType(since,value);
      ret.push_back(since);
    }
  }
  return ret;
}

readJsonFromFile()

nlohmann::json Crest::CrestContainer::readJsonFromFile	(	const std::string &	filename,
		const std::string &	spec_filename )

It reads a json file and returns the json object.

Definition at line 363 of file CrestContainer.cxx.

{
 
  std::ifstream specfile(spec_filename);
  nlohmann::json jspec;
  if (specfile.is_open())
  {
    specfile >> jspec;
    specfile.close();
  }
  else
  {
    std::cerr << "CondContainer::readJsonFromFile: Error opening file: " << spec_filename << std::endl;
    throw std::runtime_error("CondContainer::readJsonFromFile: Error opening file. "); 
  }
  // Set the payload spec
  setPayloadSpec(jspec);
  // Read data file
  std::ifstream file(filename);
  nlohmann::json j;
  if (file.is_open())
  {
    file >> j;
    file.close();
  }
  else
  {
    std::cerr << "CondContainer::readJsonFromFile: Error opening file: " << filename << std::endl;
    throw std::runtime_error("CondContainer::readJsonFromFile: Error opening file. ");
  }
  return j;
}

selectIov()

void Crest::CrestContainer::selectIov

(

const uint64_t

since

)

It select timestamp as active.

Parameters

since

It is selected timastamp.

Definition at line 163 of file CrestContainer.cxx.

                                                       {
  m_iov_data["since"]=since;
  if(m_full_data.contains(since)){
    m_iov_data["data"]=m_full_data[since];
    m_payload=m_full_data[since];
  }
  else{
    m_iov_data["data"]={};
    m_payload={};
  }
}

setIovData()

void Crest::CrestContainer::setIovData ( const nlohmann::json & j )

private

Definition at line 272 of file CrestContainer.cxx.

{
  m_iov_data = j;
}

setPayload()

void Crest::CrestContainer::setPayload ( const nlohmann::json & j )

private

Definition at line 277 of file CrestContainer.cxx.

{
  m_payload = j;
}

setPayloadSpec()

void Crest::CrestContainer::setPayloadSpec ( const nlohmann::json & j )

private

Definition at line 309 of file CrestContainer.cxx.

{
  if (j.is_array())
  {
    for (const auto &column : j)
    {
      for (const auto &[name, type] : column.items())
      {
        addColumn(name, static_cast<TypeId>(std::stoi(type.get<std::string>())));
      }
    }
  }
  else
  {
    for (const auto &[name, type] : j.items())
    {
      addColumn(name, static_cast<TypeId>(type.get<int>()));
    }
  }
}

setVectorPayload()

void Crest::CrestContainer::setVectorPayload

(

bool

isVectorPayload

)

Set the Vectore mode of the container.

Parameters

isVectorPayload

True if it is Vector payload.

Definition at line 23 of file CrestContainer.cxx.

{
  m_isVectorPayload = isVectorPayload;
}

Member Data Documentation

m_full_data

std::map<uint64_t,nlohmann::json> Crest::CrestContainer::m_full_data

private

Definition at line 227 of file CrestContainer.h.

m_iov_data

nlohmann::json Crest::CrestContainer::m_iov_data ={}

private

Definition at line 225 of file CrestContainer.h.

{};

m_isVectorPayload

bool Crest::CrestContainer::m_isVectorPayload =false

private

Definition at line 229 of file CrestContainer.h.

m_modeId

ModeId Crest::CrestContainer::m_modeId

private

Definition at line 228 of file CrestContainer.h.

m_payload

nlohmann::json Crest::CrestContainer::m_payload ={}

private

Definition at line 223 of file CrestContainer.h.

{};

m_payload_spec

std::vector<std::pair<std::string,TypeId> > Crest::CrestContainer::m_payload_spec

private

Definition at line 222 of file CrestContainer.h.

m_row

nlohmann::json Crest::CrestContainer::m_row ={}

private

Definition at line 224 of file CrestContainer.h.

{};

m_vector_data

nlohmann::json Crest::CrestContainer::m_vector_data =nlohmann::json::array()

private

Definition at line 226 of file CrestContainer.h.

---

The documentation for this class was generated from the following files:

• CrestContainer.h
• CrestContainer.cxx