#include <CrestContainer.h>

Collaboration diagram for Crest::CrestContainer:

Public Member Functions
	CrestContainer ()

	~CrestContainer ()

void	addColumn (const std::string &name, TypeId type)
	It adds a column to the payload specification. More...

void	addColumn (const std::string &name, const char *type)

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

bool	isVectorPayload ()
	It sets the mode of the container. More...

void	setVectorPayload (bool isVectorPayload)

Crest::TypeId	stringToTypeId (const std::string &type) const

Crest::TypeId	intToTypeId (int value) const

void	putRow2Vector ()
	It adds row data to vector. More...

void	addNullRecord (const char *name)
	It adds a null value to the payload. More...

void	addRecord (const char *name, int number,...)
	It adds a record to the payload. More...

void	addData (const char *channel_id)
	It associate the payload row to a channel_id. More...

void	addExternalData (const char *channel_id, const nlohmann::json &data)
	It associate the payload row to a channel_id. More...

void	addIov (const uint64_t since)
	It adds an IOV to the json object m_iov_data. More...

const std::vector< std::pair< std::string, TypeId > > &	getMPayloadSpec ()

template<typename T >
T	getRecord (const std::string &name)

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)

nlohmann::json	getPayloadSpec ()

void	setPayloadSpec (const nlohmann::json &j)

int	getColumnIndex (const std::string &name)
	It returns the index of the column with the given name. More...

void	flush ()
	It reinitializes the containers. More...

void	clear ()

void	selectIov (const uint64_t since)

std::vector< std::string >	channelIds ()

std::string	getJsonPayload ()
	It returns the json representation of the container. More...

std::string	getJsonIovData ()
	It returns the json representation of the container. More...

void	dump_json_to_file (const nlohmann::json &j, const std::string &filename)
	It creates a file with the json representation of the container. More...

nlohmann::json	read_json_from_file (const std::string &filename, const std::string &spec_filename)
	It reads a json file and returns the json object. More...

void	from_json (const uint64_t since, const nlohmann::json &j)
	It reads a json object to fill the containers. More...

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

Static Public Member Functions
static std::string	base64_encode (const uint8_t *bytes_to_encode, unsigned int in_len)
	It encodes the input string to base64. More...

static std::vector< unsigned char >	base64_decode (const std::string &encodedData)
	It decodes the input string from base64. More...

Private Member Functions
void	validatePayloadSize (const nlohmann::json &data) const

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

const nlohmann::json &	getRow ()

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()

nlohmann::json	m_full_data ={}

ModeId	m_modeId

bool	m_isVectorPayload =false

Detailed Description

Definition at line 54 of file CrestContainer.h.

Constructor & Destructor Documentation

◆ CrestContainer()

Crest::CrestContainer::CrestContainer ( )

Definition at line 17 of file CrestContainer.cxx.

17 : m_modeId(ModeId::Standard) { ; }

◆ ~CrestContainer()

Crest::CrestContainer::~CrestContainer ( )

Definition at line 18 of file CrestContainer.cxx.

 {
   flush();
 }

Member Function Documentation

◆ addColumn() [1/3]

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

Definition at line 84 of file CrestContainer.cxx.

 {
   addColumn(name, stringToTypeId(type));
 }

◆ addColumn() [2/3]

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 79 of file CrestContainer.cxx.

 {
   m_payload_spec.emplace_back(name, type);
 }

◆ addColumn() [3/3]

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

Definition at line 89 of file CrestContainer.cxx.

 {
   addColumn(name, static_cast<TypeId>(type));
 }

◆ addData()

void Crest::CrestContainer::addData ( const char * 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 160 of file CrestContainer.cxx.

 {
   addExternalData(channel_id, getRow());
 }

◆ addExternalData()

void Crest::CrestContainer::addExternalData	(	const char *	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 165 of file CrestContainer.cxx.

 {
  
   validatePayloadSize(data);
   nlohmann::json arr_data = m_isVectorPayload ? nlohmann::json::array() : nlohmann::json();
  
   for (const auto &data_row : data)//m_vector_data)
   {
     auto row_arr_data = createRowArray(data_row);
  
     if (m_isVectorPayload)
     {
       arr_data.push_back(row_arr_data);
     }
     else
     {
       arr_data = row_arr_data;
     }
   }
   m_payload[channel_id] = arr_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 214 of file CrestContainer.cxx.

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

◆ addNullRecord()

void Crest::CrestContainer::addNullRecord ( const char * 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 94 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 char *	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 106 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);
       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::Blob64k:
     case TypeId::Blob16M:
       m_row[name] = std::string(va_arg(ap, const char *));
       break;
     default:
       throw CommonCrestException("Unsupported column type.");
     }
   }
   va_end(ap);
 }

◆ base64_decode()

std::vector< unsigned char > Crest::CrestContainer::base64_decode ( const std::string & encodedData )

static

It decodes the input string from base64.

Definition at line 65 of file CrestContainer.cxx.

 {
   using namespace boost::archive::iterators;
   typedef transform_width<binary_from_base64<std::string::const_iterator>, 8, 6> base64_decoder;
  
   std::string encodedDataNoPadding = encodedData;
   boost::algorithm::erase_all(encodedDataNoPadding, "=");
  
   std::vector<unsigned char> decodedData;
   std::copy(base64_decoder(encodedDataNoPadding.begin()), base64_decoder(encodedDataNoPadding.end()), std::back_inserter(decodedData));
  
   return decodedData;
 }

◆ base64_encode()

std::string Crest::CrestContainer::base64_encode	(	const uint8_t *	bytes_to_encode,
		unsigned int	in_len
	)

static

It encodes the input string to base64.

Definition at line 50 of file CrestContainer.cxx.

 {
   using namespace boost::archive::iterators;
   typedef base64_from_binary<transform_width<const char *, 6, 8>> base64_encoder;
  
   std::string encodedData;
   std::copy(base64_encoder(data), base64_encoder(data + len), std::back_inserter(encodedData));
  
   size_t numPaddingChars = (3 - len % 3) % 3;
   encodedData.append(numPaddingChars, '=');
  
   return encodedData;
 }

◆ channelIds()

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

Definition at line 227 of file CrestContainer.cxx.

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

◆ clear()

void Crest::CrestContainer::clear ( )

Definition at line 394 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 199 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;
 }

◆ dump_json_to_file()

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

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

Definition at line 403 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::dump_json_to_file: Error opening file: " << filename << std::endl;
   }
 }

◆ flush()

void Crest::CrestContainer::flush ( )

It reinitializes the containers.

Definition at line 386 of file CrestContainer.cxx.

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

◆ from_json()

void Crest::CrestContainer::from_json	(	const uint64_t	since,
		const nlohmann::json &	j
	)

It reads a json object to fill the containers.

Definition at line 547 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);      
   }
   if(m_modeId!=ModeId::Standard)
     throw CommonCrestException("Unsupported type of payload.");
   // Accessing the "data" object
   if (j.contains("data") && j["data"].is_object())
   {
     const auto &data = j["data"];
  
     // Loop over each channel in the data
     for (const auto &channel : data.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)
       {
       // TODO: this will not work for vector payloads
       // Check if the number of values in the array matches the expected number of columns
         if (values.is_array() && values.size() == m_payload_spec.size())
         {
           for (size_t i = 0; i < values.size(); ++i)
           {
             const auto &spec = m_payload_spec[i];
             std::string colName = spec.first;
             TypeId colType = spec.second;
             if(values[i].is_string() &&( 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;
         }
             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("Unsupported column type.");          
             }
       }
         }
     else
     {
       std::cerr << "CrestContainer::from_json: Mismatch in number of values for channel " << channelKey << std::endl;
     }
     if(m_isVectorPayload)
       putRow2Vector();
       }
       addData(channelKey.c_str());
     }
   }
   else
   {
     std::cerr << "CrestContainer::from_json: JSON does not contain a 'data' object or it is not a JSON object." << std::endl;
     std::cerr << "CrestContainer::from_json json:"<<j<<std::endl;
   }
   addIov(since);
 }

◆ 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 266 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.");
   }
 }

◆ getIovData()

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

Definition at line 318 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 343 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 338 of file CrestContainer.cxx.

 {
   return getPayload().dump();
 }

◆ getMPayloadSpec()

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

Definition at line 234 of file CrestContainer.cxx.

 {
   return m_payload_spec;
 }

◆ getPayload()

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

Definition at line 304 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 char * channel_id )

Definition at line 239 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());
   }
   if (m_row.empty())
   {
     for (const auto &column : m_payload_spec)
     {
       int index = getColumnIndex(column.first);
       if (index == -1)
       {
         throw std::runtime_error("Column name not found.");
       }
       m_row[column.first] = it.value()[index];
     }
   }
   return it.value();
 }

◆ getPayloadSpec()

json Crest::CrestContainer::getPayloadSpec ( )

Definition at line 348 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;
 }

◆ getRecord()

template<typename T >

T Crest::CrestContainer::getRecord ( const std::string & name )

inline

Definition at line 143 of file CrestContainer.h.

       {
         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.");
       }

◆ getRow()

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

private

Definition at line 296 of file CrestContainer.cxx.

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

◆ intToTypeId()

Crest::TypeId Crest::CrestContainer::intToTypeId ( int value ) const

Definition at line 42 of file CrestContainer.cxx.

 {
     if (value < 0 || value >= static_cast<int>(Crest::TypeId::TypeIdCount)) {
         throw std::out_of_range("Invalid integer value for TypeId");
     }
     return static_cast<Crest::TypeId>(value);
 }

◆ isVectorPayload()

bool Crest::CrestContainer::isVectorPayload ( )

It sets the mode of the container.

Definition at line 23 of file CrestContainer.cxx.

 {
   return m_isVectorPayload;
 }

◆ parseOldFormat()

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

Definition at line 449 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!");
         break;
       }
     }
  
   }
   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 282 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());
   }
 }

◆ read_json_from_file()

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

It reads a json file and returns the json object.

Definition at line 418 of file CrestContainer.cxx.

 {
  
   std::ifstream specfile(spec_filename);
   nlohmann::json jspec;
   if (specfile.is_open())
   {
     specfile >> jspec;
     specfile.close();
   }
   else
   {
     std::cerr << "CondContainer::read_json_from_file: Error opening file: " << spec_filename << std::endl;
   }
   // 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::read_json_from_file: Error opening file: " << filename << std::endl;
   }
   return j;
 }

◆ selectIov()

void Crest::CrestContainer::selectIov ( const uint64_t since )

Definition at line 222 of file CrestContainer.cxx.

                                                        {
   m_iov_data["since"]=since;
   m_iov_data["data"]=m_full_data[std::to_string(since)];
 }

◆ setIovData()

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

Definition at line 328 of file CrestContainer.cxx.

 {
   m_iov_data = j;
 }

◆ setPayload()

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

Definition at line 333 of file CrestContainer.cxx.

 {
   m_payload = j;
 }

◆ setPayloadSpec()

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

Definition at line 365 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 )

Definition at line 27 of file CrestContainer.cxx.

 {
   m_isVectorPayload = isVectorPayload;
 }

◆ stringToTypeId()

Crest::TypeId Crest::CrestContainer::stringToTypeId ( const std::string & type ) const

Definition at line 32 of file CrestContainer.cxx.

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

◆ validatePayloadSize()

void Crest::CrestContainer::validatePayloadSize ( const nlohmann::json & data ) const

private

Definition at line 189 of file CrestContainer.cxx.

 {
   if (!data.is_array())
     throw CommonCrestException("The format of data is wrong. It should be the vector (size 1 for non vector payload)");
   if (!m_isVectorPayload && m_vector_data.size() > 1)
   {
     throw CommonCrestException("The payload is not a vector, but the size seems to be larger than 1....");
   }
 }

Member Data Documentation

◆ m_full_data

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

private

Definition at line 61 of file CrestContainer.h.

◆ m_iov_data

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

private

Definition at line 59 of file CrestContainer.h.

◆ m_isVectorPayload

bool Crest::CrestContainer::m_isVectorPayload =false

private

Definition at line 63 of file CrestContainer.h.

◆ m_modeId

ModeId Crest::CrestContainer::m_modeId

private

Definition at line 62 of file CrestContainer.h.

◆ m_payload

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

private

Definition at line 57 of file CrestContainer.h.

◆ m_payload_spec

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

private

Definition at line 56 of file CrestContainer.h.

◆ m_row

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

private

Definition at line 58 of file CrestContainer.h.

◆ m_vector_data

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

private

Definition at line 60 of file CrestContainer.h.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CrestContainer()

◆ ~CrestContainer()

Member Function Documentation

◆ addColumn() [1/3]

◆ addColumn() [2/3]

◆ addColumn() [3/3]

◆ addData()

◆ addExternalData()

◆ addIov()

◆ addNullRecord()

◆ addRecord()

◆ base64_decode()

◆ base64_encode()

◆ channelIds()

◆ clear()

◆ createRowArray()

◆ dump_json_to_file()

◆ flush()

◆ from_json()

◆ getColumnIndex()

◆ getIovData()

◆ getJsonIovData()

◆ getJsonPayload()

◆ getMPayloadSpec()

◆ getPayload()

◆ getPayloadChannel()

◆ getPayloadSpec()

◆ getRecord()

◆ getRow()

◆ intToTypeId()

◆ isVectorPayload()

◆ parseOldFormat()

◆ putRow2Vector()

◆ read_json_from_file()

◆ selectIov()

◆ setIovData()

◆ setPayload()

◆ setPayloadSpec()

◆ setVectorPayload()

◆ stringToTypeId()

◆ validatePayloadSize()

Member Data Documentation

◆ m_full_data

◆ m_iov_data

◆ m_isVectorPayload

◆ m_modeId

◆ m_payload

◆ m_payload_spec

◆ m_row

◆ m_vector_data