dunedaq Namespace Reference

The DUNE-DAQ namespace. More...

Namespaces
namespace	appfwk
namespace	appmodel
namespace	asiolibs
namespace	cibmodules
namespace	cmdlib
namespace	conffwk
namespace	config
namespace	confmodel
namespace	crtmodules
namespace	ctbmodules
namespace	daphnemodules
namespace	daqdataformats
namespace	datahandlinglibs
namespace	detchannelmaps
namespace	detdataformats
namespace	dfmessages
	Dataflow Messages.
namespace	dfmodules
	An ERS Issue for DataStore creation failure.
namespace	dpdklibs
namespace	env
namespace	erskafka
namespace	ersschema
namespace	fddetdataformats
namespace	fdreadoutlibs
namespace	flxlibs
namespace	hdf5libs
namespace	hermesmodules
namespace	hsilibs
namespace	iomanager
namespace	ipm
	An ERS Error indicating that an exception was thrown from ZMQ while performing an operation.
namespace	kafkaopmon
namespace	listrev
namespace	logging
namespace	oks
namespace	oksconflibs
namespace	oksdalgen
namespace	oksutils
namespace	opmon
namespace	opmonlib
namespace	rawdatautils
namespace	rcif
namespace	restcmd
namespace	snbmodules
namespace	sspmodules
namespace	tdemodules
namespace	timing
	< Message parameters
namespace	timinglibs
namespace	tpglibs
namespace	trgdataformats
namespace	trgtools
namespace	trigger
namespace	utilities
namespace	wibmod

Functions
	ERS_DECLARE_ISSUE (cibmodules, CIBCommunicationError, " CIB Hardware Communication Error: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(cibmodules
CIB Buffer std::string descriptor	ERS_DECLARE_ISSUE (cibmodules, CIBWordMatchError, " CIB Word Matching Error: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(cibmodules
CIB Buffer std::string descriptor Message from std::string descriptor	ERS_DECLARE_ISSUE (cibmodules, CIBWrongState, " CIB in the wrong state: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(cibmodules
CIB Buffer std::string descriptor Message from std::string descriptor CIB process std::string descriptor	ERS_DECLARE_ISSUE (cibmodules, CIBModuleError, " CIB Module error: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(cibmodules
	ERS_DECLARE_ISSUE (daphnemodules, ConfigurationFailed, name<< " failed to retrieve its conf object",((std::string) name)) ERS_DECLARE_ISSUE(daphnemodules
Invalid std::string ip	ERS_DECLARE_ISSUE (daphnemodules, InvalidChannelConfiguration, "Channel "<< id<< " has invalid configuration, trim: "<< trim<< ", offset: "<< offset<< ", gain:"<< gain,((uint32_t) id)((uint32_t) trim)((uint32_t) offset)((uint32_t) gain)) ERS_DECLARE_ISSUE(daphnemodules
Invalid std::string ip Too many full stream channels Total size_t tot	ERS_DECLARE_ISSUE (daphnemodules, UnsuccessfulConfiguration, name<< ": board reports configuration failure. Message: "<< message,((std::string) name)((std::string) message)) ERS_DECLARE_ISSUE(daphnemodules
	ERS_DECLARE_ISSUE (daphnemodules, FailedPing, "Failed to ping daphne board at "<< ip<< ':'<< port,((std::string) ip)((int) port)) ERS_DECLARE_ISSUE(daphnemodules
	DUNE_DAQ_SERIALIZABLE (dfmessages::DataRequest, "DataRequest")
	DUNE_DAQ_SERIALIZABLE (dfmessages::HSIEvent, "HSIEvent")
	DUNE_DAQ_SERIALIZABLE (dfmessages::TimeSync, "TimeSync")
	DUNE_DAQ_SERIALIZABLE (dfmessages::TriggerDecision, "TriggerDecision")
	DUNE_DAQ_SERIALIZABLE (dfmessages::TriggerDecisionToken, "TriggerDecisionToken")
	DUNE_DAQ_SERIALIZABLE (dfmessages::TriggerInhibit, "TriggerInhibit")
	DUNE_DAQ_SERIALIZABLE (dfmessages::TRMonRequest, "TRMonRequest")
	ERS_DECLARE_ISSUE (flxlibs, CardError, " FELIX Card Internal Error: "<< intererror,((std::string) intererror)) ERS_DECLARE_ISSUE(flxlibs
FELIX Initialization std::string initerror	ERS_DECLARE_ISSUE (flxlibs, ConfigurationError, " FELIX Configuration Error: "<< conferror,((std::string) conferror)) ERS_DECLARE_ISSUE(flxlibs
FELIX Initialization std::string initerror FELIX queue timed std::string queuename	ERS_DECLARE_ISSUE (flxlibs, ChannelAlignment, " Channel not aligned: "<< channel,((int) channel)) ERS_DECLARE_ISSUE(flxlibs
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int	chunksize ((size_t) expected)) ERS_DECLARE_ISSUE(flxlibs
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed std::string chunk	ERS_DECLARE_ISSUE (flxlibs, ElinkConfigurationInconsistency, " Inconsistent number of ELinks requested. Num links: "<< num_links,((int) num_links)) ERS_DECLARE_ISSUE(flxlibs
	ERS_DECLARE_ISSUE (timinglibs, TimingEndpointNotReady, endpoint<< " timing endpoint did not become ready in time. State 0x"<< std::hex<< state,((std::string) endpoint)((uint) state)) namespace timinglibs
	ERS_DECLARE_ISSUE_BASE (timinglibs, ProgressUpdate, appfwk::GeneralDAQModuleIssue, message,((std::string) name),((std::string) message)) ERS_DECLARE_ISSUE_BASE(timinglibs
	ERS_DECLARE_ISSUE (timinglibs, GatherThreadingIssue, "Gather Threading Issue detected: "<< err,((std::string) err)) ERS_DECLARE_ISSUE(timinglibs
	An ERS Issue raised when a threading state error occurs.
	DUNE_DAQ_SERIALIZABLE (timinglibs::timingcmd::TimingHwCmd, "TimingHwCmd")
	DUNE_DAQ_SERIALIZABLE (nlohmann::json, "JSON")
	ERS_DECLARE_ISSUE (timinglibs, TimingMasterNotReady, master<< " timing master did not become ready in time.",((std::string) master)) namespace timinglibs
	ERS_DECLARE_ISSUE (appfwk, NotADaqApplication, "Application "<< app<< " is neither a DaqApplication nor a SmartDaqApplication ",((std::string) app)) ERS_DECLARE_ISSUE(appfwk
No such std::string what	ERS_DECLARE_ISSUE (appfwk, ActionPlanValidationFailed, "Action plan validation failed: "<< cmd<< ", module "<< module<< ": "<< message,((std::string) cmd)((std::string) module)((std::string) message)) namespace appfwk
	ERS_DECLARE_ISSUE (appfwk, DAQModuleCreationFailed, "Failed to create DAQModule "<< instance_name<< " of type "<< plugin_name,((std::string) plugin_name)((std::string) instance_name)) ERS_DECLARE_ISSUE(appfwk
	A ERS Issue for DAQModule creation failure.
DAQModule std::string name	ERS_DECLARE_ISSUE_BASE (appfwk, DAQModuleInitFailed, appfwk::GeneralDAQModuleIssue, " init failed.",((std::string) name), ERS_EMPTY) ERS_DECLARE_ISSUE_BASE(appfwk
	Initialization failed ERS Issue (used by DAQModuleManager).
	ERS_DECLARE_ISSUE (appfwk, ApplicationNotInitialized, "Application "<< name<< " has not been initialized yet.",((std::string) name)) ERS_DECLARE_ISSUE(appfwk
	ERS_DECLARE_ISSUE (appfwk, DAQModuleManagerNotInitialized, "Command "<< cmdid<< " received before initialization",((std::string) cmdid)) ERS_DECLARE_ISSUE(appfwk
init Command received when already ERS_EMPTY	ERS_DECLARE_ISSUE (appfwk, CommandDispatchingFailed, "Command "<< cmdid<< " was not executed correctly by: "<< modules,((std::string) cmdid)((std::string) modules)) ERS_DECLARE_ISSUE(appfwk
	ERS_DECLARE_ISSUE (utilities, ServiceNotFound, "The service "<< service<< " was not found in DNS",((std::string) service)) ERS_DECLARE_ISSUE(utilities
	ERS_DECLARE_ISSUE (hermesmodules, LinkDoesNotExist, "Hermes Link "<< lid<< " does not exist",((int) lid))
	ERS_DECLARE_ISSUE (hermesmodules, InputBufferDoesNotExist, "Hermes Input Buffer "<< bid<< " does not exist",((int) bid))
	ERS_DECLARE_ISSUE (hermesmodules, MgtDoesNotExist, "Hermes MGT "<< mgtid<< " does not exist",((int) mgtid))
	ERS_DECLARE_ISSUE (hermesmodules, MagicNumberError, "Hermes Magic number failed "<< found<< " ("<< expected<< ")",((uint32_t) found)((uint32_t) expected))
	ERS_DECLARE_ISSUE (hermesmodules, LinkInError, "Hermes Link "<< link<< " is in error (err:"<< err<< ", eth_rdy:"<< eth_rdy<< ", src_rdy:"<< src_rdy<< ", udp_rdy:"<< udp_rdy<< " )",((uint16_t) link)((bool) err)((bool) eth_rdy)((bool) src_rdy)((bool) udp_rdy))
	ERS_DECLARE_ISSUE (hdf5libs, InvalidRecordName, "Record name "<< name<< " is unknown.",((std::string) name)) ERS_DECLARE_ISSUE(hdf5libs
	ERS_DECLARE_ISSUE (hdf5libs, DeprecatedUsage, func_name<< " is deprecated. "<< message,((std::string) func_name)((std::string) message)) ERS_DECLARE_ISSUE(hdf5libs
	ERS_DECLARE_ISSUE (opmonlib, OpmonServiceCreationFailed, "OpmonServiceCreationFailed: "<< error,((std::string) error))
	ERS_DECLARE_ISSUE (opmonlib, OpMonFacilityCreationFailed, "Facility "<< type<< ": creation failed",((std::string) type))
	ERS_DECLARE_ISSUE (opmonlib, NonUniqueNodeName, name<< " already present in the node list of "<< opmon_id,((std::string) name)((std::string) opmon_id)) ERS_DECLARE_ISSUE(opmonlib
	ERS_DECLARE_ISSUE (opmonlib, FailedInfoReconstruction, "Failure to create an object of type "<< type,((std::string) type)) ERS_DECLARE_ISSUE_BASE(opmonlib
	ERS_DECLARE_ISSUE (fdreadoutlibs, TPGAlgorithmInexistent, "The selected algorithm does not exist: "<< algorithm_selection<< " . Check your configuration file and seelect either SimpleThreshold or AbsRS.",((std::string) algorithm_selection)) ERS_DECLARE_ISSUE(fdreadoutlibs
Both frame_count_limit and tp_count_limit were set	to (disabled) in the TPCRawDataProcessor " "config. TPs will not send."
Both frame_count_limit and tp_count_limit were set	ERS_DECLARE_ISSUE (fdreadoutlibs, TPTooLong, "TP with SOT "<< width<< " for channel "<< channel,((uint64_t) width)((uint64_t) channel)) ERS_DECLARE_ISSUE(fdreadoutlibs
	ERS_DECLARE_ISSUE_BASE (wibmod, UnreachableError, appfwk::GeneralDAQModuleIssue, "An unreachable part of the code has been reached.",((std::string) name), ERS_EMPTY) ERS_DECLARE_ISSUE_BASE(wibmod
	ERS_DECLARE_ISSUE (confmodel, InvalidOpMonFile, file_name<< " is an invalid name for the opmon output",((std::string) file_name)) ERS_DECLARE_ISSUE(confmodel
	ERS_DECLARE_ISSUE_BASE (dfmodules, FileDataStoreImplBadConfiguration, appfwk::GeneralDAQModuleIssue, "Construction of the FileDataStoreImpl base class failed due to faulty configuration",((std::string) name),) ERS_DECLARE_ISSUE_BASE(dfmodules
	Various ERS Issues for exceptional data store situations.
	ERS_DECLARE_ISSUE_BASE (dfmodules, ProgressUpdate, appfwk::GeneralDAQModuleIssue, message,((std::string) name),((std::string) message)) ERS_DECLARE_ISSUE_BASE(dfmodules
	ERS_DECLARE_ISSUE (dfmodules, CantOpenFile, "Unable to open "<< file_name,((std::string) file_name)) ERS_DECLARE_ISSUE(dfmodules
	ERS_DECLARE_ISSUE (dfmodules, NoTPsInWindow, "No TriggerPrimitives were used from a TPSet with start_time="<< tpset_start_time<< ", end_time="<< tpset_end_time<< ", TSAccumulator begin and end times:"<< window_begin_time<< ", "<< window_end_time,((daqdataformats::timestamp_t) tpset_start_time)((daqdataformats::timestamp_t) tpset_end_time)((daqdataformats::timestamp_t) window_begin_time)((daqdataformats::timestamp_t) window_end_time)) ERS_DECLARE_ISSUE(dfmodules
Cannot add TPSet with because another TPSet with these values already size_t	tpset_source_id ((daqdataformats::timestamp_t) tpset_start_time)) ERS_DECLARE_ISSUE(dfmodules
	ERS_DECLARE_ISSUE (dfmodules, DFOThresholdsNotConsistent, "Busy threshold ("<< busy<< ") is smaller than free threshold ("<< free<< ')',((size_t) busy)((size_t) free)) ERS_DECLARE_ISSUE(dfmodules
	ERS_DECLARE_ISSUE (timing, DACChannelOutOfRange, " DAC channel out of range: "<< channel,((std::string) channel)) ERS_DECLARE_ISSUE(timing
	ERS_DECLARE_ISSUE (timing, SI534xConfigError, " SI534xConfigError: "<< message,((std::string) message)) ERS_DECLARE_ISSUE(timing
Missing configuration std::string tag	ERS_DECLARE_ISSUE (timing, SI534xRegWriteFailed, " Failed to write Si53xx reg: "<< reg<< "with data: "<< data,((std::string) reg)((std::string) data)) ERS_DECLARE_ISSUE(timing
	< Message parameters
	ERS_DECLARE_ISSUE (timing, TimestampNotReady, " Timestamp not ready in time; loaded: "<< loaded<< ", error: "<< error,((uint32_t) loaded)((uint32_t) error)) namespace timing
	ERS_DECLARE_ISSUE (timing, FileNotFound, file_path<< " does not exist!",((std::string) file_path)) ERS_DECLARE_ISSUE(timing
	ERS_DECLARE_ISSUE (trigger, InvalidConfiguration, "Invalid configuration error:"<< conferror,((std::string) conferror)) ERS_DECLARE_ISSUE(trigger
	ERS_DECLARE_ISSUE (trigger, DroppedTPSet, "Failed to send TPs from "<< s_ts<< " to "<< e_ts,((uint64_t) s_ts)((uint64_t) e_ts)) ERS_DECLARE_ISSUE(trigger
	ERS_DECLARE_ISSUE (datahandlinglibs, InternalError, "SourceID["<< sourceid<< "] Internal Error: "<< error,((daqdataformats::SourceID) sourceid)((std::string) error)) ERS_DECLARE_ISSUE(datahandlinglibs
SourceID[" << sourceid << "] Command daqdataformats::SourceID	sourceid ((std::string) commanderror)) ERS_DECLARE_ISSUE(datahandlinglibs
SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror	ERS_DECLARE_ISSUE (datahandlinglibs, ConfigurationError, "SourceID["<< sourceid<< "] Readout Configuration Error: "<< conferror,((daqdataformats::SourceID) sourceid)((std::string) conferror)) ERS_DECLARE_ISSUE(datahandlinglibs
SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror	ERS_DECLARE_ISSUE (datahandlinglibs, DataRecorderConfigurationError, "Configuration Error: "<< conferror,((std::string) conferror)) ERS_DECLARE_ISSUE(datahandlinglibs
SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror Configuration std::string conferror	ERS_DECLARE_ISSUE (datahandlinglibs, FileHasExtraData, "Binary file contains extra data, "<< numbytes<< " bytes beyond an exact integer number of super-chunks. "<< "This is not a problem and those bytes will be ignored, "<< "filesize is "<< filesize<< ", "<< "chunk_size is "<< chunksize<< ", "<< "filename is "<< filename,((int32_t) numbytes)((size_t) filesize)((int32_t) chunksize)((std::string) filename)) ERS_DECLARE_ISSUE(datahandlinglibs
	ERS_DECLARE_ISSUE (tdemodules, AMCCommandIssue, "AMC with ip:"+ip+" and port: "<< port<< " | "<< "send command failed, reason: "<< text,((std::string) ip)((uint16_t) port)((std::string) text))
	ERS_DECLARE_ISSUE (tdemodules, AMCProtocolIssue, prefix<< "AMCProtocolResponse: "<< text,((std::string) prefix)((std::string) text))
	ERS_DECLARE_ISSUE (tdemodules, AMCResponseErr, prefix<< "Received Error packet:"<< "\n"<< "Error code:"<< code<< "\nMessage: "<< text,((std::string) prefix)((uint16_t) code)((std::string) text))
	ERS_DECLARE_ISSUE (tdemodules, AMCUnknownOpCode, prefix<< "Unknown opcode recived: "<< opcode,((std::string) prefix)((uint16_t) opcode))
	ERS_DECLARE_ISSUE (appmodel, BadConf, what,((std::string) what)) ERS_DECLARE_ISSUE(appmodel
	ERS_DECLARE_ISSUE (ipm, UnexpectedNumberOfBytes, connection_name<< ": Expected "<< bytes1<< " bytes in message but received "<< bytes2,((std::string) connection_name)((int) bytes1)((int) bytes2)) ERS_DECLARE_ISSUE(ipm
	ERS_DECLARE_ISSUE (ipm, NullPointerPassedToSend, connection_name<< ": An null pointer to memory was passed to Sender::send",((std::string) connection_name)) ERS_DECLARE_ISSUE(ipm
	ERS_DECLARE_ISSUE_BASE (hsilibs, ProgressUpdate, appfwk::GeneralDAQModuleIssue, message,((std::string) name),((std::string) message)) ERS_DECLARE_ISSUE_BASE(hsilibs
	ERS_DECLARE_ISSUE (kafkaopmon, MissingParameter, "No "<< parameter<< " in "<< conf,((std::string) parameter)((std::string) conf)) ERS_DECLARE_ISSUE(kafkaopmon
	ERS_DECLARE_ISSUE (kafkaopmon, CannotPostToDb, "Cannot post to Influx DB : "<< error,((std::string) error)) ERS_DECLARE_ISSUE(kafkaopmon
Cannot create std::string fatal	ERS_DECLARE_ISSUE (kafkaopmon, CannotConsumeMessage, "Cannot consume message : "<< error,((std::string) error)) ERS_DECLARE_ISSUE(kafkaopmon
	ERS_DECLARE_ISSUE (dpdklibs, FailedToSetupInterface, "Interface ["<< ifaceid<< "] setup failed: "<< error,((int) ifaceid)((int) error))
	ERS_DECLARE_ISSUE (dpdklibs, InvalidEALPort, "Interface ["<< ifaceid<< "] is not a valid port: ",((int) ifaceid))
	ERS_DECLARE_ISSUE (dpdklibs, LinkOffline, "Link offline for interface ["<< ifaceid<< "]",((int) ifaceid))
	ERS_DECLARE_ISSUE (dpdklibs, MainCoreConflict, "The main core ["<< main_core<< "] conflicts with the worker cores list ",((int) main_core))
	ERS_DECLARE_ISSUE (dpdklibs, MissingSourceIDOutputs, "The following of source ids are available as SourceModels for interface "<< ifaceid<< ": "<< srcs_str,((int) ifaceid)((std::string) srcs_str))
	ERS_DECLARE_ISSUE (dpdklibs, FailedToRetrieveInterfaceInfo, "Failed to retrieve device info for interfce ["<< ifaceid<< "]: "<< error,((int) ifaceid)((int) error))
	ERS_DECLARE_ISSUE (dpdklibs, FailedToRetrieveLinkStatus, "Failed to retrieve link status for interfce ["<< ifaceid<< "]: "<< error,((int) ifaceid)((int) error))
	ERS_DECLARE_ISSUE (dpdklibs, FailedToResetInterface, "Failed to reset interfce ["<< ifaceid<< "]: "<< error,((int) ifaceid)((int) error))
	ERS_DECLARE_ISSUE (dpdklibs, FailedToConfigureInterface, "Failed to configure interface ["<< ifaceid<< "], stage "<< stage<< " : "<< error,((int) ifaceid)((std::string) stage)((int) error))
	ERS_DECLARE_ISSUE (dpdklibs, FailedToSendData, "Sink ID ["<< sink_id<< "] Number of packets that failed to send: "<< count,((std::string) sink_id)((int) count))
	ERS_DECLARE_ISSUE (dpdklibs, PacketErrors, "Interface ["<< id<< "] "<< error<< " packet error counts: "<< count,((std::string) id)((std::string) error)((int) count))
	ERS_DECLARE_ISSUE (dpdklibs, BadPacketHeaderIssue, "BadPacketHeaderIssue: \""<< ers_messg<< "\"",((std::string) ers_messg)) namespace dpdklibs
	ERS_DECLARE_ISSUE (dpdklibs, MetricPublishFailed, "Field "<< field<< " was not reported",((std::string) field)) ERS_DECLARE_ISSUE(dpdklibs
	ERS_DECLARE_ISSUE (iomanager, ConnectionInstanceNotFound, "Connection Instance not found for name "<< name,((std::string) name)) ERS_DECLARE_ISSUE(iomanager
static std::shared_ptr< iomanager::IOManager >	get_iomanager ()
template<typename Datatype>
static std::shared_ptr< iomanager::SenderConcept< Datatype > >	get_iom_sender (iomanager::ConnectionId const &id)
template<typename Datatype>
static std::shared_ptr< iomanager::ReceiverConcept< Datatype > >	get_iom_receiver (iomanager::ConnectionId const &id)
template<typename Datatype>
static std::shared_ptr< iomanager::SenderConcept< Datatype > >	get_iom_sender (std::string const &uid)
template<typename Datatype>
static std::shared_ptr< iomanager::ReceiverConcept< Datatype > >	get_iom_receiver (std::string const &uid)
	ERS_DECLARE_ISSUE (iomanager, NetworkMessageNotSerializable, "Object of type "<< type<< " is not serializable but configured for network transfer!",((std::string) type)) ERS_DECLARE_ISSUE(iomanager
	ERS_DECLARE_ISSUE (iomanager, QueueTypeUnknown, "Queue type \""<< queue_type<< "\" is unknown ",((std::string) queue_type)) ERS_DECLARE_ISSUE(iomanager
	QueueTypeUnknown ERS Issue.
	ERS_DECLARE_ISSUE (conffwk, DalPackageNameNotFound, "Failed to find the dal package name for class "<< class_name<< " in its schema path '"<< schema_path<< "'",((std::string) class_name)((std::string) schema_path)) ERS_DECLARE_ISSUE(conffwk
	ERS_DEFINE_ISSUE_BASE_CXX (conffwk, Generic, conffwk::Exception, what,,((const char *) what)) ERS_DEFINE_ISSUE_BASE_CXX(conffwk
static type<< " \""<< data<< "\" is not found",,((const char *) type)((const char *) data)) ERS_DEFINE_ISSUE_BASE_CXX(conffwk, DeletedObject, conffwk::Exception, "object \'"<< object_id<< '@'<< class_name<< "\' was deleted",,((const char *) class_name)((const char *) object_id)) namespace conffwk {template< typename T > T *	get_new (ConfigObject &co, const std::string &attrname)
static bool	check_prefetch_needs ()
static void	init_regex (std::unique_ptr< std::regex > &ptr, const std::string &str, const char *what)
template<class T>
static void	add_array_item (boost::property_tree::ptree &pt, const T &val)
template<class T>
static void	add_data (boost::property_tree::ptree &pt, const ConfigObject &obj, const dunedaq::conffwk::attribute_t &attribute, const std::string &empty_array_item)
static void	add_data (boost::property_tree::ptree &pt, const ConfigObject &obj, const dunedaq::conffwk::relationship_t &relationship, const std::string &empty_array_item)
static void	print_svect (std::ostream &s, const std::vector< std::string > &v, const char *name)
std::ostream &	operator<< (std::ostream &s, const ConfigurationChange &c)
std::ostream &	operator<< (std::ostream &s, const std::vector< ConfigurationChange * > &v)
std::ostream &	operator<< (std::ostream &s, const Configuration &c)
	ERS_DECLARE_ISSUE (oks, DeprecatedFormat, "the file "<< file<< " contains OKS time data stored in deprecated format \'"<< data<< "\'. Please refresh it using an oks application. Support for such format will be removed in a future release.",((const char *) file)((const char *) data)) namespace oks
	ERS_DECLARE_ISSUE (cmdlib, MalformedUri, "Malformed uri: "<< error<< " uri:"<< uri,((std::string) error)((std::string) uri)) ERS_DECLARE_ISSUE(cmdlib
	cmdlib specific issues
Unsupported std::string uri	ERS_DECLARE_ISSUE (cmdlib, CannotParseCommand, "Failed to parse command: "<< error,((std::string) error)) ERS_DECLARE_ISSUE(cmdlib
Unsupported std::string uri Execution of command std::string error	ERS_DECLARE_ISSUE (cmdlib, CommandFacilityInitialization, "Problem configuring the command facility: "<< error,((std::string) error)) ERS_DECLARE_ISSUE(cmdlib
Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility std::string uri	ERS_DECLARE_ISSUE (cmdlib, CompletionQueueIssue, "Problem with command completion queue: "<< error,((std::string) error)) ERS_DECLARE_ISSUE(cmdlib
	ERS_DECLARE_ISSUE (snbmodules, InvalidGroupTransferIDError, "InvalidGroupTransferIDError: Transfer ID "<< transfer_id<< " not found in "<< location,((std::string) transfer_id)((std::string) location)) ERS_DECLARE_ISSUE(snbmodules
	DUNE_DAQ_SERIALIZABLE (snbmodules::NotificationData, "notification_t")
	ERS_DECLARE_ISSUE_BASE (listrev, ProgressUpdate, appfwk::GeneralDAQModuleIssue, message,((std::string) name),((std::string) message)) ERS_DECLARE_ISSUE_BASE(listrev
	DUNE_DAQ_SERIALIZABLE (listrev::IntList, "IntList")
	DUNE_DAQ_SERIALIZABLE (listrev::ReversedList::Data, "ReversedListData")
	DUNE_DAQ_SERIALIZABLE (listrev::ReversedList, "ReversedList")
	DUNE_DAQ_SERIALIZABLE (listrev::CreateList, "CreateList")
	DUNE_DAQ_SERIALIZABLE (listrev::RequestList, "RequestList")
	ERS_DECLARE_ISSUE (serialization, UnknownSerializationTypeString, "Unknown serialization type "<< t,((std::string) t)) ERS_DECLARE_ISSUE(serialization
	Issue for when the serialization type cannot be determined from an input string.
return obj	as< T > ()
	catch (msgpack::type_error &e)
	catch (msgpack::unpack_error &e)
	ERS_DECLARE_ISSUE (ctbmodules, CTBCommunicationError, " CTB Hardware Communication Error: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(ctbmodules
CTB Buffer std::string descriptor	ERS_DECLARE_ISSUE (ctbmodules, CTBWordMatchWarning, " CTB Word Matching Issue: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(ctbmodules
CTB Buffer std::string descriptor CTB Repeated Word std::string descriptor	ERS_DECLARE_ISSUE (ctbmodules, CTBMessage, " Mesage from CTB: "<< descriptor,((std::string) descriptor)) ERS_DECLARE_ISSUE(ctbmodules
	ERS_DECLARE_ISSUE (detchannelmaps, PDSChannelMapCreationFailed, "Failed to create PDSChannelMap of type "<< plugin_name,((std::string) plugin_name)) ERS_DECLARE_ISSUE(detchannelmaps
	A ERS Issue for PDSChannelMap creation failure.
	ERS_DECLARE_ISSUE (detchannelmaps, ChannelMapCreationFailed, "Failed to create TPCChannelMap of type "<< plugin_name,((std::string) plugin_name)) ERS_DECLARE_ISSUE(detchannelmaps
	A ERS Issue for TPCChannelMap creation failure.

Variables
	CIBBufferWarning
CIB Buffer	Issue
CIB Buffer std::string descriptor	CIBMessage
CIB Buffer std::string descriptor Message from	CIB
CIB Buffer std::string descriptor Message from std::string descriptor	CIBProcError
CIB Buffer std::string descriptor Message from std::string descriptor CIB process	error
CIB Buffer std::string descriptor Message from std::string descriptor CIB process std::string descriptor	CIBConfigFailure
CIB Buffer std::string descriptor Message from std::string descriptor CIB process std::string descriptor	descriptor
	InvalidIPAddress
Invalid	address
Invalid std::string ip	TooManyChannels
Invalid std::string ip Too many full stream channels Total	requested
Invalid std::string ip Too many full stream channels Total size_t tot	MonitoringFailed
	FailedSocketInteraction
	FailedSend
	InitializationError
FELIX Initialization	Error
FELIX Initialization std::string initerror	QueueTimeoutError
FELIX Initialization std::string initerror FELIX queue timed	out
FELIX Initialization std::string initerror FELIX queue timed std::string queuename	UnexpectedChunk
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk	size
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int	ParserOperationQueuePushFailure
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed	chunk
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed std::string chunk	BlockSizeConfigurationInconsistency
	InvalidQueueFatalError
	DeviceInfoSendFailed
	MissingComponent
No such	component
	GeneralDAQModuleIssue
DAQModule	__pad0__
DAQModule std::string name	CommandIssue
	InvalidStateForCommand
	DAQModuleManagerAlreadyInitialized
init Command received when already	initialized
init Command received when already ERS_EMPTY	ConflictingCommandMatching
	NameNotFound
	InvalidSequenceDigits
	FileOpenFailed
	EntryWithNoData
	NameMismatch
	FailedInfoReconstruction
	FrameAndTPCountersDisabled
Both frame_count_limit and tp_count_limit were set	FailedToSendTPVector
	ConfigurationFailed
	LoadDalFailed
	InvalidOperationMode
	CantWriteToFile
	DuplicateTPWindow
Cannot add TPSet with	sourceid
Cannot add TPSet with	start_time
Cannot add TPSet with because another TPSet with these values already	exists
Cannot add TPSet with because another TPSet with these values already size_t	TardyTPSetReceived
	AssignedTriggerDecisionNotFound
	DACValueOutOfRange
	< Namespace
DAC value out of	range
	Message.
	SI534xMissingConfigSectionError
	< Namespace
Missing configuration	section
	Message.
Missing configuration std::string tag	SI534xRegWriteRetry
	< Namespace
	CorruptedFile
	< Namespace
	TriggerInhibited
	TPHandlerMsg
	infomsg
	CommandError
SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror	BufferedReaderWriterConfigurationError
SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror	GenericConfigurationError
SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror Configuration std::string conferror	TimeSyncTransmissionFailed
	BadStreamConf
	ReceiveTimeoutExpired
	SendTimeoutExpired
	FailedConfiguration
	CannotCreateConsumer
Cannot create	consumer
Cannot create std::string fatal	IncorrectParameters
Cannot create std::string fatal Incorrect	parameters
	UnexpectedStreamID
	TimeoutExpired
	ConnectionNotFound
	QueueTypeMismatch
	NotFound
	DeletedObject
	UnsupportedUri
Unsupported	URI
Unsupported std::string uri	CommandExecutionFailed
Unsupported std::string uri Execution of command	failed
Unsupported std::string uri Execution of command std::string error	CommandFacilityCreationFailed
Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility	uri
Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility std::string uri	RunLoopTerminated
Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility std::string uri The main run loop for command reception was	interrupted
	NotificationWrongDestinationError
	UnknownSerializationTypeByte
Unknown serialization type<< t,((char) t)) template< typename T > inline std::string datatype_to_string() { return "Unknown";} namespace serialization { template< typename T > struct is_serializable :std::false_type {};enum SerializationType { kMsgPack };inline SerializationType from_string(const std::string s) { if(s=="msgpack") return kMsgPack;throw UnknownSerializationTypeString(ERS_HERE, s);} constexpr uint8_t serialization_type_byte(SerializationType stype) { switch(stype) { case kMsgPack:return 'M';default:throw UnknownSerializationTypeEnum(ERS_HERE);} } constexpr SerializationType DEFAULT_SERIALIZATION_TYPE=kMsgPack;template< class T > std::vector< uint8_t > serialize(const T &obj, SerializationType stype=DEFAULT_SERIALIZATION_TYPE) { switch(stype) { case kMsgPack:{ msgpack::sbuffer buf;msgpack::pack(buf, obj);std::vector< uint8_t > ret(buf.size()+1);ret[0]=serialization_type_byte(stype);std::copy(buf.data(), buf.data()+buf.size(), ret.begin()+1);return ret;} default:throw UnknownSerializationTypeEnum(ERS_HERE);} } template< class T, typename CharType=unsigned char > T deserialize(const std::vector< CharType > &v) { switch(v[0]) { case serialization_type_byte(kMsgPack):{ try { msgpack::object_handle oh=msgpack::unpack(const_cast< char * >(reinterpret_cast< const char * >(v.data()+1)), v.size() - 1,[](msgpack::type::object_type, std::size_t, void *) ->	bool { return true
msgpack::object	obj = oh.get()
default char	v [0]
	CTBBufferWarning
CTB Buffer std::string descriptor	CTBRepeatedTimestampWarning
CTB Buffer std::string descriptor CTB Repeated Word std::string descriptor	CTBConfigFailure
	PDSInvalidStream
	< Namespace
	InvalidStreamID
	< Namespace

Detailed Description

The DUNE-DAQ namespace.

Including Qt.

Including Qt Headers.

This is part of the DUNE DAQ Software Suite, copyright 2020. Licensing/copyright details are in the COPYING file that you should have received with this code.

Including c++ Including Schema

This is part of the DUNE DAQ Application Framework, copyright 2020. Licensing/copyright details are in the COPYING file that you should have received with this code.

Function Documentation

add_array_item()

template<class T>

void dunedaq::add_array_item ( boost::property_tree::ptree & pt, const T & val )

static

Definition at line 872 of file Configuration.cpp.

{
  boost::property_tree::ptree child;
  child.put("", val);
  pt.push_back(std::make_pair("", child));
}

add_data() [1/2]

template<class T>

void dunedaq::add_data ( boost::property_tree::ptree & pt, const ConfigObject & obj, const dunedaq::conffwk::attribute_t & attribute, const std::string & empty_array_item )

static

Definition at line 963 of file Configuration.cpp.

{
  auto& o = const_cast<ConfigObject&>(obj);
  if (!attribute.p_is_multi_value) {
    T val;
    const_cast<ConfigObject&>(obj).get(attribute.p_name, val);
    pt.put(attribute.p_name, val);
  } else {
    std::vector<T> values;
    o.get(attribute.p_name, values);
 
    boost::property_tree::ptree children;
 
    if (!values.empty())
      for (const auto& v : values)
        add_array_item(children, v);
 
    else if (!empty_array_item.empty())
      add_array_item(children, empty_array_item);
 
    pt.add_child(attribute.p_name, children);
  }
}

add_data() [2/2]

void dunedaq::add_data ( boost::property_tree::ptree & pt, const ConfigObject & obj, const dunedaq::conffwk::relationship_t & relationship, const std::string & empty_array_item )

static

Definition at line 991 of file Configuration.cpp.

{
  if (relationship.p_cardinality == dunedaq::conffwk::zero_or_many ||
      relationship.p_cardinality == dunedaq::conffwk::one_or_many) {
    std::vector<ConfigObject> values;
    const_cast<ConfigObject&>(obj).get(relationship.p_name, values);
 
    boost::property_tree::ptree children;
 
    if (!values.empty())
      for (const auto& v : values)
        add_array_item(children, v.full_name());
 
    else if (!empty_array_item.empty())
      add_array_item(children, empty_array_item);
 
    pt.add_child(relationship.p_name, children);
  } else {
    ConfigObject val;
    const_cast<ConfigObject&>(obj).get(relationship.p_name, val);
    pt.put(relationship.p_name, !val.is_null() ? val.full_name() : "");
  }
}

as< T >()

return obj dunedaq::as< T >

(

)

catch() [1/2]

dunedaq::catch

(

msgpack::type_error &

e

)

Definition at line 254 of file Serialization.hpp.

                                     {
        throw CannotDeserializeMessage(ERS_HERE, e);
      } catch (msgpack::unpack_error& e) {

catch() [2/2]

dunedaq::catch

(

msgpack::unpack_error &

e

)

Definition at line 256 of file Serialization.hpp.

                                       {
        throw CannotDeserializeMessage(ERS_HERE, e);
      }

check_prefetch_needs()

bool dunedaq::check_prefetch_needs ( )

static

Definition at line 85 of file Configuration.cpp.

{
  return (getenv("TDAQ_DB_PREFETCH_ALL_DATA") != nullptr);
}

chunksize()

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int dunedaq::chunksize

(

(size_t)

expected

)

DUNE_DAQ_SERIALIZABLE() [1/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::DataRequest	,
		"DataRequest"	)

DUNE_DAQ_SERIALIZABLE() [2/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::HSIEvent	,
		"HSIEvent"	)

DUNE_DAQ_SERIALIZABLE() [3/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::TimeSync	,
		"TimeSync"	)

DUNE_DAQ_SERIALIZABLE() [4/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::TriggerDecision	,
		"TriggerDecision"	)

DUNE_DAQ_SERIALIZABLE() [5/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::TriggerDecisionToken	,
		"TriggerDecisionToken"	)

DUNE_DAQ_SERIALIZABLE() [6/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::TriggerInhibit	,
		"TriggerInhibit"	)

DUNE_DAQ_SERIALIZABLE() [7/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	dfmessages::TRMonRequest	,
		"TRMonRequest"	)

DUNE_DAQ_SERIALIZABLE() [8/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	listrev::CreateList	,
		"CreateList"	)

DUNE_DAQ_SERIALIZABLE() [9/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	listrev::IntList	,
		"IntList"	)

DUNE_DAQ_SERIALIZABLE() [10/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	listrev::RequestList	,
		"RequestList"	)

DUNE_DAQ_SERIALIZABLE() [11/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	listrev::ReversedList	,
		"ReversedList"	)

DUNE_DAQ_SERIALIZABLE() [12/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	listrev::ReversedList::Data	,
		"ReversedListData"	)

DUNE_DAQ_SERIALIZABLE() [13/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	nlohmann::json	,
		"JSON"	)

DUNE_DAQ_SERIALIZABLE() [14/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	snbmodules::NotificationData	,
		"notification_t"	)

DUNE_DAQ_SERIALIZABLE() [15/15]

dunedaq::DUNE_DAQ_SERIALIZABLE	(	timinglibs::timingcmd::TimingHwCmd	,
		"TimingHwCmd"	)

ERS_DECLARE_ISSUE() [1/89]

No such std::string what dunedaq::ERS_DECLARE_ISSUE	(	appfwk	,
		ActionPlanValidationFailed	,
		"Action plan validation failed: "<< cmd<< "	,
		module " << module << ":" <<	message,
		((std::string) cmd)((std::string) module)((std::string) message)	)

Definition at line 41 of file ConfigurationManager.hpp.

                                                : " << cmd << ", module " << module << ": " << message,
                  ((std::string)cmd)((std::string)module)((std::string)message))
// Re-enable coverage collection LCOV_EXCL_STOP
 
namespace appfwk {
 
class ConfigurationManager
{
public:
  ConfigurationManager(std::string const& config_spec, std::string const& app_name, std::string const& session_name);
  std::vector<ValidationReport> initialize(bool throw_on_fatal = true);
 
  const confmodel::Session* get_session() const { return m_session; }
  const confmodel::Application* get_application()
  {
    initialize();
    return m_application;
  }
 
  const std::vector<const confmodel::Queue*>& get_queues()
  {
    initialize();
    return m_queues;
  }
  const std::vector<const confmodel::NetworkConnection*>& get_networkconnections()
  {
    initialize();
    return m_networkconnections;
  }
  const std::vector<const confmodel::DaqModule*>& get_modules()
  {
    initialize();
    return m_modules;
  }
  const confmodel::ConnectivityService* get_connectivity_service()
  {
    initialize();
    return m_connsvc_config;
  }
 
  const std::unordered_map<std::string, const confmodel::ActionPlan*>& get_action_plans()
  {
    initialize();
    return m_action_plans;
  }
  const confmodel::ActionPlan* get_action_plan(std::string cmd) const;
 
  template<typename T>
  const T* get_dal(const std::string& name)
  {
    return m_confdb->get<T>(name);
  }
 
  std::string get_app_name() const { return m_app_name; }
 
private:
  std::shared_ptr<conffwk::Configuration> m_confdb;
  std::shared_ptr<appmodel::ConfigurationHelper> m_helper;
  std::string m_app_name;
  std::string m_session_name;
 
  const confmodel::Session* m_session;
  const confmodel::DaqApplication* m_application;
  std::unordered_map<std::string, const confmodel::ActionPlan*> m_action_plans;
  std::vector<const confmodel::DaqModule*> m_modules;
  std::vector<const confmodel::Queue*> m_queues;
  std::vector<const confmodel::NetworkConnection*> m_networkconnections;
  const confmodel::ConnectivityService* m_connsvc_config;
 
  bool m_initialized{ false };
};
 
} // namespace appfwk

ERS_DECLARE_ISSUE() [2/89]

dunedaq::ERS_DECLARE_ISSUE	(	appfwk	,
		ApplicationNotInitialized	,
		"Application "<< name<< " has not been initialized yet."	,
		((std::string) name)	)

ERS_DECLARE_ISSUE() [3/89]

init Command received when already ERS_EMPTY dunedaq::ERS_DECLARE_ISSUE	(	appfwk	,
		CommandDispatchingFailed	,
		"Command "<< cmdid<< " was not executed correctly by: "<<	modules,
		((std::string) cmdid)((std::string) modules)	)

ERS_DECLARE_ISSUE() [4/89]

dunedaq::ERS_DECLARE_ISSUE	(	appfwk	,
		DAQModuleCreationFailed	,
		"Failed to create DAQModule "<< instance_name<< " of type "<<	plugin_name,
		((std::string) plugin_name)((std::string) instance_name)	)

A ERS Issue for DAQModule creation failure.

A generic DAQModule ERS Issue

ERS_DECLARE_ISSUE() [5/89]

dunedaq::ERS_DECLARE_ISSUE	(	appfwk	,
		DAQModuleManagerNotInitialized	,
		"Command "<< cmdid<< " received before initialization"	,
		((std::string) cmdid)	)

ERS_DECLARE_ISSUE() [6/89]

dunedaq::ERS_DECLARE_ISSUE	(	appfwk	,
		NotADaqApplication	,
		"Application "<< app<< " is neither a DaqApplication nor a SmartDaqApplication "	,
		((std::string) app)	)

ERS_DECLARE_ISSUE() [7/89]

dunedaq::ERS_DECLARE_ISSUE	(	appmodel	,
		BadConf	,
		what	,
		((std::string) what)	)

ERS_DECLARE_ISSUE() [8/89]

dunedaq::ERS_DECLARE_ISSUE	(	cibmodules	,
		CIBCommunicationError	,
		" CIB Hardware Communication Error: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [9/89]

CIB Buffer std::string descriptor Message from std::string descriptor CIB process std::string descriptor dunedaq::ERS_DECLARE_ISSUE	(	cibmodules	,
		CIBModuleError	,
		" CIB Module error: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [10/89]

CIB Buffer std::string descriptor dunedaq::ERS_DECLARE_ISSUE	(	cibmodules	,
		CIBWordMatchError	,
		" CIB Word Matching Error: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [11/89]

CIB Buffer std::string descriptor Message from std::string descriptor dunedaq::ERS_DECLARE_ISSUE	(	cibmodules	,
		CIBWrongState	,
		" CIB in the wrong state: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [12/89]

Unsupported std::string uri dunedaq::ERS_DECLARE_ISSUE	(	cmdlib	,
		CannotParseCommand	,
		"Failed to parse command: "<<	error,
		((std::string) error)	)

ERS_DECLARE_ISSUE() [13/89]

Unsupported std::string uri Execution of command std::string error dunedaq::ERS_DECLARE_ISSUE	(	cmdlib	,
		CommandFacilityInitialization	,
		"Problem configuring the command facility: "<<	error,
		((std::string) error)	)

ERS_DECLARE_ISSUE() [14/89]

Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility std::string uri dunedaq::ERS_DECLARE_ISSUE	(	cmdlib	,
		CompletionQueueIssue	,
		"Problem with command completion queue: "<<	error,
		((std::string) error)	)

ERS_DECLARE_ISSUE() [15/89]

dunedaq::ERS_DECLARE_ISSUE	(	cmdlib	,
		MalformedUri	,
		"Malformed uri: "<< error<< " uri:"<<	uri,
		((std::string) error)((std::string) uri)	)

cmdlib specific issues

ERS_DECLARE_ISSUE() [16/89]

dunedaq::ERS_DECLARE_ISSUE	(	conffwk	,
		DalPackageNameNotFound	,
		"Failed to find the dal package name for class "<< class_name<< " in its schema path '"<< schema_path<< "'"	,
		((std::string) class_name)((std::string) schema_path)	)

ERS_DECLARE_ISSUE() [17/89]

dunedaq::ERS_DECLARE_ISSUE	(	confmodel	,
		InvalidOpMonFile	,
		file_name<< " is an invalid name for the opmon output"	,
		((std::string) file_name)	)

ERS_DECLARE_ISSUE() [18/89]

dunedaq::ERS_DECLARE_ISSUE	(	ctbmodules	,
		CTBCommunicationError	,
		" CTB Hardware Communication Error: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [19/89]

CTB Buffer std::string descriptor CTB Repeated Word std::string descriptor dunedaq::ERS_DECLARE_ISSUE	(	ctbmodules	,
		CTBMessage	,
		" Mesage from CTB: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [20/89]

CTB Buffer std::string descriptor dunedaq::ERS_DECLARE_ISSUE	(	ctbmodules	,
		CTBWordMatchWarning	,
		" CTB Word Matching Issue: "<<	descriptor,
		((std::string) descriptor)	)

ERS_DECLARE_ISSUE() [21/89]

dunedaq::ERS_DECLARE_ISSUE	(	daphnemodules	,
		ConfigurationFailed	,
		name<< " failed to retrieve its conf object"	,
		((std::string) name)	)

ERS_DECLARE_ISSUE() [22/89]

dunedaq::ERS_DECLARE_ISSUE	(	daphnemodules	,
		FailedPing	,
		"Failed to ping daphne board at "<< ip<< ':'<<	port,
		((std::string) ip)((int) port)	)

ERS_DECLARE_ISSUE() [23/89]

Invalid std::string ip dunedaq::ERS_DECLARE_ISSUE	(	daphnemodules	,
		InvalidChannelConfiguration	,
		"Channel "<< id<< " has invalid	configuration,
		trim:" << trim << "	,
		offset:" << offset << "	,
		gain:" <<	gain,
		((uint32_t) id)((uint32_t) trim)((uint32_t) offset)((uint32_t) gain)	)

ERS_DECLARE_ISSUE() [24/89]

Invalid std::string ip Too many full stream channels Total size_t tot dunedaq::ERS_DECLARE_ISSUE	(	daphnemodules	,
		UnsuccessfulConfiguration	,
		name<< ": board reports configuration failure. Message: "<<	message,
		((std::string) name)((std::string) message)	)

ERS_DECLARE_ISSUE() [25/89]

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror dunedaq::ERS_DECLARE_ISSUE	(	datahandlinglibs	,
		ConfigurationError	,
		"SourceID Readout Configuration Error: "<<	conferror[" << sourceid << "],
		((daqdataformats::SourceID) sourceid)((std::string) conferror)	)

ERS_DECLARE_ISSUE() [26/89]

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror dunedaq::ERS_DECLARE_ISSUE	(	datahandlinglibs	,
		DataRecorderConfigurationError	,
		"Configuration Error: "<<	conferror,
		((std::string) conferror)	)

ERS_DECLARE_ISSUE() [27/89]

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror Configuration std::string conferror dunedaq::ERS_DECLARE_ISSUE	(	datahandlinglibs	,
		FileHasExtraData	,
		"Binary file contains extra	data,
		" << numbytes << " bytes beyond an exact integer number of super-chunks. " << "This is not a problem and those bytes will be	ignored,
		" << "filesize is " << filesize << "	,
		" << "chunk_size is " << chunksize << "	,
		" << "filename is " <<	filename,
		((int32_t) numbytes)((size_t) filesize)((int32_t) chunksize)((std::string) filename)	)

ERS_DECLARE_ISSUE() [28/89]

dunedaq::ERS_DECLARE_ISSUE	(	datahandlinglibs	,
		InternalError	,
		"SourceID Internal Error: "<<	error[" << sourceid << "],
		((daqdataformats::SourceID) sourceid)((std::string) error)	)

ERS_DECLARE_ISSUE() [29/89]

dunedaq::ERS_DECLARE_ISSUE	(	detchannelmaps	,
		ChannelMapCreationFailed	,
		"Failed to create TPCChannelMap of type "<<	plugin_name,
		((std::string) plugin_name)	)

A ERS Issue for TPCChannelMap creation failure.

Parameters

-	Namespace
-	Type of the Issue
plugin_name	Log Message from the issue
-	Message parameters

ERS_DECLARE_ISSUE() [30/89]

dunedaq::ERS_DECLARE_ISSUE	(	detchannelmaps	,
		PDSChannelMapCreationFailed	,
		"Failed to create PDSChannelMap of type "<<	plugin_name,
		((std::string) plugin_name)	)

A ERS Issue for PDSChannelMap creation failure.

Parameters

-	Namespace
-	Type of the Issue
plugin_name	Log Message from the issue
-	Message parameters

ERS_DECLARE_ISSUE() [31/89]

dunedaq::ERS_DECLARE_ISSUE	(	dfmodules	,
		CantOpenFile	,
		"Unable to open "<<	file_name,
		((std::string) file_name)	)

ERS_DECLARE_ISSUE() [32/89]

dunedaq::ERS_DECLARE_ISSUE	(	dfmodules	,
		DFOThresholdsNotConsistent	,
		"Busy threshold ("<< busy<< ") is smaller than free threshold ("<< free<< ')'	,
		((size_t) busy)((size_t) free)	)

ERS_DECLARE_ISSUE() [33/89]

dunedaq::ERS_DECLARE_ISSUE	(	dfmodules	,
		NoTPsInWindow	,
		"No TriggerPrimitives were used from a TPSet with	start_time = " << tpset_start_time << ",
		end_time	= " << tpset_end_time << ",
		TSAccumulator begin and end times:" << window_begin_time << "	,
		" <<	window_end_time,
		((daqdataformats::timestamp_t) tpset_start_time)((daqdataformats::timestamp_t) tpset_end_time)((daqdataformats::timestamp_t) window_begin_time)((daqdataformats::timestamp_t) window_end_time)	)

ERS_DECLARE_ISSUE() [34/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		BadPacketHeaderIssue	,
		"BadPacketHeaderIssue: \""<< ers_messg<< "\""	,
		((std::string) ers_messg)	)

Definition at line 30 of file Utils.hpp.

                                       : \"" << ers_messg << "\"",
                  ((std::string)ers_messg))
 
namespace dpdklibs {
namespace udp {
 
uint16_t
get_payload_size_udp_hdr(struct rte_udp_hdr* udp_hdr);
uint16_t
get_payload_size(struct ipv4_udp_packet_hdr* ipv4_udp_hdr);
 
rte_be32_t
ip_address_dotdecimal_to_binary(uint8_t byte1, uint8_t byte2, uint8_t byte3, uint8_t byte4);
struct ipaddr
ip_address_binary_to_dotdecimal(rte_le32_t binary_ipv4_address);
 
std::string
get_ipv4_decimal_addr_str(struct ipaddr ipv4_address);
 
char*
get_udp_payload(const rte_mbuf* mbuf);
 
// void dump_udp_header(struct ipv4_udp_packet_hdr * pkt);
std::string
get_udp_header_str(struct rte_mbuf* mbuf);
 
std::string
get_udp_packet_str(struct rte_mbuf* mbuf);
 
void
add_file_contents_to_vector(const std::string& filename, std::vector<char>& buffervec);
 
std::vector<std::pair<const void*, int>>
get_ethernet_packets(const std::vector<char>& buffervec);
 
void
set_daqethheader_test_values(detdataformats::DAQEthHeader& daqethheader_obj) noexcept;
 
std::string
get_rte_mbuf_str(const rte_mbuf* mbuf) noexcept;
 
struct StreamUID
{
  uint64_t det_id : 6;
  uint64_t crate_id : 10;
  uint64_t slot_id : 4;
  uint64_t stream_id : 8;
 
  StreamUID() = default;
 
  StreamUID(const detdataformats::DAQEthHeader& daq_hdr)
    : det_id(daq_hdr.det_id)
    , crate_id(daq_hdr.crate_id)
    , slot_id(daq_hdr.slot_id)
    , stream_id(daq_hdr.stream_id) {};
 
  bool operator<(const StreamUID& rhs) const
  {
    return std::tie(det_id, crate_id, slot_id, stream_id) <
           std::tie(rhs.det_id, rhs.crate_id, rhs.slot_id, rhs.stream_id);
  }
 
  bool operator==(const StreamUID& rhs) const
  {
    return det_id == rhs.det_id && crate_id == rhs.crate_id && slot_id == rhs.slot_id && stream_id == rhs.stream_id;
  }
  operator std::string() const { return fmt::format("({}, {}, {}, {})", det_id, crate_id, slot_id, stream_id); }
};
 
} // namespace udp
} // namespace dpdklibs

ERS_DECLARE_ISSUE() [35/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		FailedToConfigureInterface	,
		"Failed to configure	interface["<< ifaceid<< "],
		stage "<< stage<< " :"<<	error,
		((int) ifaceid)((std::string) stage)((int) error)	)

ERS_DECLARE_ISSUE() [36/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		FailedToResetInterface	,
		"Failed to reset interfce : "<<	error["<< ifaceid<< "],
		((int) ifaceid)((int) error)	)

ERS_DECLARE_ISSUE() [37/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		FailedToRetrieveInterfaceInfo	,
		"Failed to retrieve device info for interfce : "<<	error["<< ifaceid<< "],
		((int) ifaceid)((int) error)	)

ERS_DECLARE_ISSUE() [38/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		FailedToRetrieveLinkStatus	,
		"Failed to retrieve link status for interfce : "<<	error["<< ifaceid<< "],
		((int) ifaceid)((int) error)	)

ERS_DECLARE_ISSUE() [39/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		FailedToSendData	,
		"Sink ID Number of packets that failed to send: "<<	count["<< sink_id<< "],
		((std::string) sink_id)((int) count)	)

ERS_DECLARE_ISSUE() [40/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		FailedToSetupInterface	,
		"Interface setup failed: "<<	error["<< ifaceid<< "],
		((int) ifaceid)((int) error)	)

ERS_DECLARE_ISSUE() [41/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		InvalidEALPort	,
		"Interface is not a valid port: "	["<< ifaceid<< "],
		((int) ifaceid)	)

ERS_DECLARE_ISSUE() [42/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		LinkOffline	,
		"Link offline for interface "	["<< ifaceid<< "],
		((int) ifaceid)	)

ERS_DECLARE_ISSUE() [43/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		MainCoreConflict	,
		"The main core conflicts with the worker cores list "	["<< main_core<< "],
		((int) main_core)	)

ERS_DECLARE_ISSUE() [44/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		MetricPublishFailed	,
		"Field "<< field<< " was not reported"	,
		((std::string) field)	)

ERS_DECLARE_ISSUE() [45/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		MissingSourceIDOutputs	,
		"The following of source ids are available as SourceModels for interface "<< ifaceid<< ": "<<	srcs_str,
		((int) ifaceid)((std::string) srcs_str)	)

ERS_DECLARE_ISSUE() [46/89]

dunedaq::ERS_DECLARE_ISSUE	(	dpdklibs	,
		PacketErrors	,
		"Interface "<< error<< " packet error counts: "<<	count["<< id<< "],
		((std::string) id)((std::string) error)((int) count)	)

ERS_DECLARE_ISSUE() [47/89]

dunedaq::ERS_DECLARE_ISSUE	(	fdreadoutlibs	,
		TPGAlgorithmInexistent	,
		"The selected algorithm does not exist: "<< algorithm_selection<< " . Check your configuration file and seelect either SimpleThreshold or AbsRS."	,
		((std::string) algorithm_selection)	)

ERS_DECLARE_ISSUE() [48/89]

Both frame_count_limit and tp_count_limit were set dunedaq::ERS_DECLARE_ISSUE	(	fdreadoutlibs	,
		TPTooLong	,
		"TP with SOT "<< width<< " for channel "<<	channel,
		((uint64_t) width)((uint64_t) channel)	)

ERS_DECLARE_ISSUE() [49/89]

dunedaq::ERS_DECLARE_ISSUE	(	flxlibs	,
		CardError	,
		" FELIX Card Internal Error: "<<	intererror,
		((std::string) intererror)	)

ERS_DECLARE_ISSUE() [50/89]

FELIX Initialization std::string initerror FELIX queue timed std::string queuename dunedaq::ERS_DECLARE_ISSUE	(	flxlibs	,
		ChannelAlignment	,
		" Channel not aligned: "<<	channel,
		((int) channel)	)

ERS_DECLARE_ISSUE() [51/89]

FELIX Initialization std::string initerror dunedaq::ERS_DECLARE_ISSUE	(	flxlibs	,
		ConfigurationError	,
		" FELIX Configuration Error: "<<	conferror,
		((std::string) conferror)	)

ERS_DECLARE_ISSUE() [52/89]

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed std::string chunk dunedaq::ERS_DECLARE_ISSUE	(	flxlibs	,
		ElinkConfigurationInconsistency	,
		" Inconsistent number of ELinks requested. Num links: "<<	num_links,
		((int) num_links)	)

ERS_DECLARE_ISSUE() [53/89]

dunedaq::ERS_DECLARE_ISSUE	(	hdf5libs	,
		DeprecatedUsage	,
		func_name<< " is deprecated. "<<	message,
		((std::string) func_name)((std::string) message)	)

ERS_DECLARE_ISSUE() [54/89]

dunedaq::ERS_DECLARE_ISSUE	(	hdf5libs	,
		InvalidRecordName	,
		"Record name "<< name<< " is unknown."	,
		((std::string) name)	)

ERS_DECLARE_ISSUE() [55/89]

dunedaq::ERS_DECLARE_ISSUE	(	hermesmodules	,
		InputBufferDoesNotExist	,
		"Hermes Input Buffer "<< bid<< " does not exist"	,
		((int) bid)	)

ERS_DECLARE_ISSUE() [56/89]

dunedaq::ERS_DECLARE_ISSUE	(	hermesmodules	,
		LinkDoesNotExist	,
		"Hermes Link "<< lid<< " does not exist"	,
		((int) lid)	)

ERS_DECLARE_ISSUE() [57/89]

dunedaq::ERS_DECLARE_ISSUE	(	hermesmodules	,
		LinkInError	,
		"Hermes Link "<< link<< " is in error (err:"<< err<< ", eth_rdy:"<< eth_rdy<< ", src_rdy:"<< src_rdy<< ", udp_rdy:"<< udp_rdy<< " )"	,
		((uint16_t) link)((bool) err)((bool) eth_rdy)((bool) src_rdy)((bool) udp_rdy)	)

ERS_DECLARE_ISSUE() [58/89]

dunedaq::ERS_DECLARE_ISSUE	(	hermesmodules	,
		MagicNumberError	,
		"Hermes Magic number failed "<< found<< " ("<< expected<< ")"	,
		((uint32_t) found)((uint32_t) expected)	)

ERS_DECLARE_ISSUE() [59/89]

dunedaq::ERS_DECLARE_ISSUE	(	hermesmodules	,
		MgtDoesNotExist	,
		"Hermes MGT "<< mgtid<< " does not exist"	,
		((int) mgtid)	)

ERS_DECLARE_ISSUE() [60/89]

dunedaq::ERS_DECLARE_ISSUE	(	iomanager	,
		ConnectionInstanceNotFound	,
		"Connection Instance not found for name "<<	name,
		((std::string) name)	)

ERS_DECLARE_ISSUE() [61/89]

dunedaq::ERS_DECLARE_ISSUE	(	iomanager	,
		NetworkMessageNotSerializable	,
		"Object of type "<< type<< " is not serializable but configured for network transfer!"	,
		((std::string) type)	)

ERS_DECLARE_ISSUE() [62/89]

dunedaq::ERS_DECLARE_ISSUE	(	iomanager	,
		QueueTypeUnknown	,
		"Queue type \""<< queue_type<< "\" is unknown "	,
		((std::string) queue_type)	)

QueueTypeUnknown ERS Issue.

QueueTypeMismatch ERS Issue

ERS_DECLARE_ISSUE() [63/89]

dunedaq::ERS_DECLARE_ISSUE	(	ipm	,
		NullPointerPassedToSend	,
		connection_name<< ": An null pointer to memory was passed to Sender::send"	,
		((std::string) connection_name)	)

ERS_DECLARE_ISSUE() [64/89]

dunedaq::ERS_DECLARE_ISSUE	(	ipm	,
		UnexpectedNumberOfBytes	,
		connection_name<< ": Expected "<< bytes1<< " bytes in message but received "<<	bytes2,
		((std::string) connection_name)((int) bytes1)((int) bytes2)	)

ERS_DECLARE_ISSUE() [65/89]

Cannot create std::string fatal dunedaq::ERS_DECLARE_ISSUE	(	kafkaopmon	,
		CannotConsumeMessage	,
		"Cannot consume message : "<<	error,
		((std::string) error)	)

ERS_DECLARE_ISSUE() [66/89]

dunedaq::ERS_DECLARE_ISSUE	(	kafkaopmon	,
		CannotPostToDb	,
		"Cannot post to Influx DB : "<<	error,
		((std::string) error)	)

ERS_DECLARE_ISSUE() [67/89]

dunedaq::ERS_DECLARE_ISSUE	(	kafkaopmon	,
		MissingParameter	,
		"No "<< parameter<< " in "<<	conf,
		((std::string) parameter)((std::string) conf)	)

ERS_DECLARE_ISSUE() [68/89]

dunedaq::ERS_DECLARE_ISSUE	(	oks	,
		DeprecatedFormat	,
		"the file "<< file<< " contains OKS time data stored in deprecated format \'"<< data<< "\'. Please refresh it using an oks application. Support for such format will be removed in a future release."	,
		((const char *	) file)((const char *) data) )

Definition at line 33 of file data.cpp.

              {
// ugly reinterpret staff to convert date and time to integers
 
void
OksData::SetFast(boost::gregorian::date d)
{
  data.DATE = d.day_number();
}
 
void
OksData::SetFast(boost::posix_time::ptime t)
{
  data.TIME = *reinterpret_cast<uint64_t*>(&t);
}
 
boost::gregorian::date
OksData::date() const noexcept
{
  return boost::gregorian::date(boost::gregorian::gregorian_calendar::from_day_number(data.DATE));
}
 
boost::posix_time::ptime
OksData::time() const noexcept
{
  return *reinterpret_cast<boost::posix_time::ptime*>(const_cast<uint64_t*>(&data.TIME));
}
 
inline void
free_list(OksData::List& dlist)
{
  for (OksData::List::const_iterator i = dlist.begin(); i != dlist.end(); ++i) {
    delete *i;
  }
  dlist.clear();
}
 
static bool
operator==(const OksData::List& l1, const OksData::List& l2)
{
  if (&l1 == &l2)
    return true;
 
  size_t l1Lenght = l1.size();
  size_t l2Lenght = l2.size();
 
  if (!l1Lenght && !l2Lenght)
    return true;
  if (l1Lenght != l2Lenght)
    return false;
 
  size_t pos = 0;
 
  auto i1 = l1.begin();
  auto i2 = l2.begin();
 
  for (; i1 != l1.end(); ++i1, ++i2) {
    OksData* d1 = *i1;
    OksData* d2 = *i2;
 
    if (!d1 && !d2)
      return true;
    if (!d1 || !d2)
      return false;
 
    if (((d1->type == d2->type) && (d1->type == OksData::object_type) &&
         ((!d1->data.OBJECT && !d2->data.OBJECT) ||
          ((d1->data.OBJECT && d2->data.OBJECT) &&
           (d1->data.OBJECT->GetClass()->get_name() == d2->data.OBJECT->GetClass()->get_name()) &&
           (d1->data.OBJECT->GetId() == d2->data.OBJECT->GetId())))) ||
        ((*d1 == *d2))) {
      pos++;
      continue;
    }
 
    return false;
  }
 
  return true;
}
 
bool
OksData::operator==(const OksData& d) const
{
  return ((d.type == type) &&
          (((type == string_type) && (*d.data.STRING == *data.STRING)) ||
           ((type == u32_int_type) && (d.data.U32_INT == data.U32_INT)) ||
           ((type == s32_int_type) && (d.data.S32_INT == data.S32_INT)) ||
           ((type == u16_int_type) && (d.data.U16_INT == data.U16_INT)) ||
           ((type == s16_int_type) && (d.data.S16_INT == data.S16_INT)) ||
           ((type == s8_int_type) && (d.data.S8_INT == data.S8_INT)) ||
           ((type == u8_int_type) && (d.data.U8_INT == data.U8_INT)) ||
           ((type == s64_int_type) && (d.data.S64_INT == data.S64_INT)) ||
           ((type == u64_int_type) && (d.data.U64_INT == data.U64_INT)) ||
           ((type == float_type) && (d.data.FLOAT == data.FLOAT)) ||
           ((type == double_type) && (d.data.DOUBLE == data.DOUBLE)) ||
           ((type == bool_type) && (d.data.BOOL == data.BOOL)) || ((type == date_type) && (d.data.DATE == data.DATE)) ||
           ((type == time_type) && (d.data.TIME == data.TIME)) ||
           ((type == object_type) && OksObject::are_equal_fast(d.data.OBJECT, data.OBJECT)) ||
           ((type == list_type) && (*d.data.LIST == *data.LIST)) ||
           ((type == uid_type) && (d.data.UID.class_id->get_name() == data.UID.class_id->get_name() &&
                                   *d.data.UID.object_id == *data.UID.object_id)) ||
           ((type == uid2_type) &&
            (*d.data.UID2.class_id == *data.UID2.class_id && *d.data.UID2.object_id == *data.UID2.object_id)) ||
           ((type == enum_type) && (*d.data.ENUMERATION == *data.ENUMERATION)) ||
           ((type == class_type) && (d.data.CLASS->get_name() == data.CLASS->get_name()))));
}
 
bool
OksData::operator!=(const OksData& d) const
{
  return ((d == *this) ? false : true);
}
 
static bool
test_comparable(OksData::Type type1, OksData::Type type2)
{
  const char* fname = "OksData::operator[<|<=|>|>=](const OksData&) const";
  const char* h3 = "Can't compare ";
 
  if (type1 != type2 && !(OksData::is_object(type1) && OksData::is_object(type2))) {
    Oks::error_msg(fname) << h3 << "OKS data of different types\n";
    return false;
  } else if (type1 == OksData::list_type) {
    Oks::error_msg(fname) << h3 << "lists\n";
    return false;
  }
 
  return true;
}
 
const std::string&
OksData::__oid() const
{
  if (type == object_type)
    return data.OBJECT->uid.object_id;
  else if (type == uid_type)
    return *data.UID.object_id;
  else
    return *data.UID2.object_id;
}
 
const std::string&
OksData::__cn() const
{
  if (type == object_type)
    return data.OBJECT->uid.class_id->get_name();
  else if (type == uid_type)
    return data.UID.class_id->get_name();
  else
    return *data.UID2.class_id;
}
 
#define CMP_OBJ(OP, c1, c2, id1, id2) (c1 OP c2) || (!(c2 OP c1) && id1 OP id2)
 
#define CMP_DATA(OP)                                                                                                   \
  switch (type) {                                                                                                      \
    case string_type:                                                                                                  \
      return (*data.STRING OP * d.data.STRING);                                                                        \
    case u32_int_type:                                                                                                 \
      return (data.U32_INT OP d.data.U32_INT);                                                                         \
    case s32_int_type:                                                                                                 \
      return (data.S32_INT OP d.data.S32_INT);                                                                         \
    case u16_int_type:                                                                                                 \
      return (data.U16_INT OP d.data.U16_INT);                                                                         \
    case s16_int_type:                                                                                                 \
      return (data.S16_INT OP d.data.S16_INT);                                                                         \
    case s8_int_type:                                                                                                  \
      return (data.S8_INT OP d.data.S8_INT);                                                                           \
    case u8_int_type:                                                                                                  \
      return (data.U8_INT OP d.data.U8_INT);                                                                           \
    case s64_int_type:                                                                                                 \
      return (data.S64_INT OP d.data.S64_INT);                                                                         \
    case u64_int_type:                                                                                                 \
      return (data.U64_INT OP d.data.U64_INT);                                                                         \
    case float_type:                                                                                                   \
      return (data.FLOAT OP d.data.FLOAT);                                                                             \
    case double_type:                                                                                                  \
      return (data.DOUBLE OP d.data.DOUBLE);                                                                           \
    case bool_type:                                                                                                    \
      return (data.BOOL OP d.data.BOOL);                                                                               \
    case date_type:                                                                                                    \
      return (data.DATE OP d.data.DATE);                                                                               \
    case time_type:                                                                                                    \
      return (data.TIME OP d.data.TIME);                                                                               \
    case enum_type:                                                                                                    \
      return (*data.ENUMERATION OP * d.data.ENUMERATION);                                                              \
    case class_type:                                                                                                   \
      return (data.CLASS->get_name() OP d.data.CLASS->get_name());                                                     \
    case object_type:                                                                                                  \
    case uid_type:                                                                                                     \
    case uid2_type:                                                                                                    \
      return CMP_OBJ(OP, __cn(), d.__cn(), __oid(), d.__oid());                                                        \
    default:                                                                                                           \
      return false;                                                                                                    \
  }
 
bool
OksData::is_le(const OksData& d) const noexcept
{
  CMP_DATA(<=)
}
 
bool
OksData::is_ge(const OksData& d) const noexcept
{
  CMP_DATA(>=)
}
 
bool
OksData::is_l(const OksData& d) const noexcept
{
  CMP_DATA(<)
}
 
bool
OksData::is_g(const OksData& d) const noexcept
{
  CMP_DATA(>)
}
 
bool
OksData::operator<=(const OksData& d) const
{
  if (test_comparable(type, d.type) == false)
    return false;
  return is_le(d);
}
 
bool
OksData::operator>=(const OksData& d) const
{
  if (test_comparable(type, d.type) == false)
    return false;
  return is_ge(d);
}
 
bool
OksData::operator>(const OksData& d) const
{
  if (test_comparable(type, d.type) == false)
    return false;
  return is_g(d);
}
 
bool
OksData::operator<(const OksData& d) const
{
  if (test_comparable(type, d.type) == false)
    return false;
  return is_l(d);
}
 
void
OksData::copy(const OksData& d)
{
  type = d.type;
 
  if (type == list_type) {
    data.LIST = new List();
 
    for (List::iterator i = d.data.LIST->begin(); i != d.data.LIST->end(); ++i) {
      OksData* d2 = new OksData();
      *d2 = *(*i);
      data.LIST->push_back(d2);
    }
  } else if (type == string_type)
    data.STRING = new OksString(*d.data.STRING);
  else if (type == object_type)
    data.OBJECT = d.data.OBJECT; // Don't allow deep copy for objects
  else if (type == u32_int_type)
    data.U32_INT = d.data.U32_INT;
  else if (type == s32_int_type)
    data.S32_INT = d.data.S32_INT;
  else if (type == u16_int_type)
    data.U16_INT = d.data.U16_INT;
  else if (type == s16_int_type)
    data.S16_INT = d.data.S16_INT;
  else if (type == double_type)
    data.DOUBLE = d.data.DOUBLE;
  else if (type == float_type)
    data.FLOAT = d.data.FLOAT;
  else if (type == s8_int_type)
    data.S8_INT = d.data.S8_INT;
  else if (type == u8_int_type)
    data.U8_INT = d.data.U8_INT;
  else if (type == s64_int_type)
    data.S64_INT = d.data.S64_INT;
  else if (type == u64_int_type)
    data.U64_INT = d.data.U64_INT;
  else if (type == class_type)
    data.CLASS = d.data.CLASS;
  else if (type == uid2_type) {
    data.UID2.class_id = new OksString(*d.data.UID2.class_id);
    data.UID2.object_id = new OksString(*d.data.UID2.object_id);
  } else if (type == uid_type) {
    data.UID.class_id = d.data.UID.class_id;
    data.UID.object_id = new OksString(*d.data.UID.object_id);
  } else if (type == bool_type)
    data.BOOL = d.data.BOOL;
  else if (type == date_type)
    data.DATE = d.data.DATE;
  else if (type == time_type)
    data.TIME = d.data.TIME;
  else if (type == enum_type)
    data.ENUMERATION = d.data.ENUMERATION;
}
 
std::ostream&
operator<<(std::ostream& s, const OksData& d)
{
  switch (d.type) {
    case OksData::list_type: {
      s << '(';
      for (OksData::List::iterator i = d.data.LIST->begin(); i != d.data.LIST->end(); ++i) {
        s << *(*i);
        if ((*i) != d.data.LIST->back())
          s << ", ";
      }
      s << ')';
      break;
    }
 
    case OksData::string_type:
      s << '\"' << *(d.data.STRING) << '\"';
      break;
 
    case OksData::object_type:
      if (d.data.OBJECT)
        s << '[' << d.data.OBJECT->GetId() << '@' << d.data.OBJECT->GetClass()->get_name() << ']';
      else
        s << "[NIL]";
 
      break;
 
    case OksData::uid2_type:
      s << '#' << '[' << *d.data.UID2.object_id << '@' << *d.data.UID2.class_id << ']';
      break;
 
    case OksData::uid_type:
      s << '#' << '[' << *d.data.UID.object_id << '@' << d.data.UID.class_id->get_name() << ']';
      break;
 
    case OksData::s32_int_type:
      s << d.data.S32_INT;
      break;
 
    case OksData::u32_int_type:
      s << d.data.U32_INT;
      break;
 
    case OksData::s16_int_type:
      s << d.data.S16_INT;
      break;
 
    case OksData::u16_int_type:
      s << d.data.U16_INT;
      break;
 
    case OksData::float_type: {
      std::streamsize p = s.precision();
      s.precision(std::numeric_limits<float>::digits10);
      s << d.data.FLOAT;
      s.precision(p);
      break;
    }
 
    case OksData::double_type: {
      std::streamsize p = s.precision();
      s.precision(std::numeric_limits<double>::digits10);
      s << d.data.DOUBLE;
      s.precision(p);
      break;
    }
 
    case OksData::s8_int_type:
      s << static_cast<int16_t>(d.data.S8_INT);
      break;
 
    case OksData::u8_int_type:
      s << static_cast<uint16_t>(d.data.U8_INT);
      break;
 
    case OksData::s64_int_type:
      s << d.data.S64_INT;
      break;
 
    case OksData::u64_int_type:
      s << d.data.U64_INT;
      break;
 
    case OksData::bool_type:
      s << ((d.data.BOOL == true) ? "true" : "false");
      break;
 
    case OksData::date_type:
      s << boost::gregorian::to_simple_string(d.date());
      break;
 
    case OksData::time_type:
      s << boost::posix_time::to_simple_string(d.time());
      break;
 
    case OksData::enum_type:
      s << '\"' << *(d.data.ENUMERATION) << '\"';
      break;
 
    case OksData::class_type:
      s << '[' << d.data.CLASS->get_name() << ']';
      break;
 
    case OksData::unknown_type:
      Oks::error_msg("operator<<(ostream&, const OksData&)") << "Can't put to stream \'OksData::unknown_type\'";
      break;
  }
 
  return s;
}
 
void
OksData::Clear()
{
  if (type >= string_type) {
    switch (type) {
      case list_type:
        if (List* dlist = data.LIST) {
          if (!dlist->empty()) {
            free_list(*dlist);
          }
          delete dlist;
        }
        break;
 
      case string_type:
        if (data.STRING) {
          delete data.STRING;
        }
        break;
 
      case uid2_type:
        if (data.UID2.object_id) {
          delete data.UID2.object_id;
        }
        if (data.UID2.class_id) {
          delete data.UID2.class_id;
        }
        break;
 
      case uid_type:
        if (data.UID.object_id) {
          delete data.UID.object_id;
        }
        break;
 
      default:
        /* Make compiler happy */
        break;
    }
  }
 
  type = unknown_type;
}
 
std::string
AttributeRangeError::fill(const OksData* d, const std::string& range)
{
  std::ostringstream s;
  s << "value ";
  if (d->type == OksData::string_type || d->type == OksData::enum_type)
    s << *d;
  else
    s << '\'' << *d << '\'';
  s << " is out of range \'" << range << '\'';
  return s.str();
}
 
std::string
AttributeReadError::fill(const char* value, const char* type, const std::string& reason)
{
  std::ostringstream s;
 
  if (value) {
    s << "string \'" << value << '\'';
  } else {
    s << "empty string";
  }
 
  s << " is not a valid value for \'" << type << "\' type";
 
  if (!reason.empty())
    s << ":\n" << reason;
 
  return s.str();
}
 
std::string
AttributeReadError::fill(const char* type, const std::string& reason)
{
  std::ostringstream s;
 
  s << "the string is not a valid value for \'" << type << "\' type";
 
  if (!reason.empty())
    s << ":\n" << reason;
 
  return s.str();
}
 
void
OksData::check_range(const OksAttribute* a) const
{
  if (a->p_range_obj == nullptr)
    return;
 
  if (type == list_type) {
    if (data.LIST) {
      for (const auto& i : *data.LIST) {
        i->check_range(a);
      }
    }
  } else {
    if (a->p_range_obj->validate(*this) == false) {
      throw AttributeRangeError(this, a->get_range());
    }
  }
}
 
void
OksData::SetNullValue(const OksAttribute* a)
{
  switch (type) {
    case s8_int_type:
      data.S8_INT = 0;
      return;
    case u8_int_type:
      data.U8_INT = 0;
      return;
    case bool_type:
      data.BOOL = false;
      return;
    case u32_int_type:
      data.U32_INT = 0L;
      return;
    case s32_int_type:
      data.S32_INT = 0L;
      return;
    case s16_int_type:
      data.S16_INT = 0;
      return;
    case u16_int_type:
      data.U16_INT = 0;
      return;
    case s64_int_type:
      data.S64_INT = (int64_t)(0);
      return;
    case u64_int_type:
      data.U64_INT = (uint64_t)(0);
      return;
    case float_type:
      data.FLOAT = (float)(.0);
      return;
    case double_type:
      data.DOUBLE = (double)(.0);
      return;
    case string_type:
      data.STRING = new OksString();
      return;
    case enum_type:
      data.ENUMERATION = &((*(a->p_enumerators))[0]);
      return; // first value
    case class_type:
      data.CLASS = a->p_class;
      return; // some class
    case date_type:
      SetFast(boost::gregorian::day_clock::universal_day());
      return;
    case time_type:
      SetFast(boost::posix_time::second_clock::universal_time());
      return;
    default:
      Clear2();
      throw AttributeReadError("", "non-attribute-type", "internal OKS error");
  }
}
 
void
OksData::SetValue(const char* s, const OksAttribute* a)
{
  if (*s == '\0') {
    SetNullValue(a);
  } else {
    switch (type) {
      case s8_int_type:
        data.S8_INT = static_cast<int8_t>(strtol(s, 0, 0));
        return;
      case u8_int_type:
        data.U8_INT = static_cast<uint8_t>(strtoul(s, 0, 0));
        return;
      case bool_type:
        switch (strlen(s)) {
          case 4:
            data.BOOL = (cmp_str4n(s, "true") || cmp_str4n(s, "TRUE") || cmp_str4n(s, "True"));
            return;
          case 1:
            data.BOOL = (*s == 't' || *s == 'T' || *s == '1');
            return;
          default:
            data.BOOL = false;
            return;
        }
      case u32_int_type:
        data.U32_INT = static_cast<uint32_t>(strtoul(s, 0, 0));
        return;
      case s32_int_type:
        data.S32_INT = static_cast<int32_t>(strtol(s, 0, 0));
        return;
      case s16_int_type:
        data.S16_INT = static_cast<int16_t>(strtol(s, 0, 0));
        return;
      case u16_int_type:
        data.U16_INT = static_cast<uint16_t>(strtoul(s, 0, 0));
        return;
      case s64_int_type:
        data.S64_INT = static_cast<int64_t>(strtoll(s, 0, 0));
        return;
      case u64_int_type:
        data.U64_INT = static_cast<uint64_t>(strtoull(s, 0, 0));
        return;
      case float_type:
        data.FLOAT = strtof(s, 0);
        return;
      case double_type:
        data.DOUBLE = strtod(s, 0);
        return;
 
      case string_type:
        data.STRING = new OksString(s);
        return;
      case enum_type:
        try {
          data.ENUMERATION = a->get_enum_value(s, strlen(s));
          return;
        } catch (std::exception& ex) {
          throw AttributeReadError(s, "enum", ex.what());
        }
      case date_type:
        try {
          if (strchr(s, '-') || strchr(s, '/')) {
            SetFast(boost::gregorian::from_simple_string(s));
            return;
          } else {
            SetFast(boost::gregorian::from_undelimited_string(s));
            return;
          }
        } catch (std::exception& ex) {
          throw AttributeReadError(s, "date", ex.what());
        }
      case time_type:
        try {
          if (strlen(s) == 15 && s[8] == 'T') {
            SetFast(boost::posix_time::from_iso_string(s));
            return;
          } else {
            SetFast(boost::posix_time::time_from_string(s));
            return;
          }
        } catch (std::exception& ex) {
          throw AttributeReadError(s, "time", ex.what());
        }
      case class_type:
        if (OksClass* c = a->p_class->get_kernel()->find_class(s)) {
          data.CLASS = c;
          return;
        } else {
          Clear2();
          throw AttributeReadError(s, "class", "the value is not a name of valid OKS class");
        }
      default:
        Clear2();
        throw AttributeReadError(s, "non-attribute-type", "internal OKS error");
    }
  }
}
 
std::list<std::string>
OksAttribute::get_init_values() const
{
  std::list<std::string> val;
 
  // check, if the attribute is multi-value
  if (get_is_multi_values() == true) {
    OksData d;
    d.SetValues(get_init_value().c_str(), this);
 
    for (OksData::List::const_iterator i = d.data.LIST->begin(); i != d.data.LIST->end(); ++i) {
      val.push_back((*i)->str());
    }
  }
 
  return val;
}
 
void
OksData::SetValues(const char* s, const OksAttribute* a)
{
  if (!a->get_is_multi_values()) {
    ReadFrom(s, a->get_data_type(), a);
    return;
  }
 
  if (type != list_type) {
    Set(new List());
  } else if (!data.LIST->empty()) {
    free_list(*data.LIST);
  }
 
  if (!s)
    return;
  while (*s == ' ')
    s++;
  if (*s == '\0')
    return;
 
  std::string str(s);
 
  while (str.length()) {
    while (str.length() && str[0] == ' ')
      str.erase(0, 1);
    if (!str.length())
      return;
    char delimeter = (str[0] == '\"' ? '\"' : str[0] == '\'' ? '\'' : str[0] == '`' ? '`' : ',');
 
    if (delimeter != ',')
      str.erase(0, 1);
    std::string::size_type p = str.find(delimeter);
 
    OksData* d = new OksData();
    d->type = a->get_data_type();
 
    if (d->type == OksData::string_type) {
      d->data.STRING = new OksString(str, p);
    } else if (d->type == OksData::enum_type) {
      std::string token(str, 0, p);
      d->data.ENUMERATION = a->get_enum_value(token); // FIXME, create more efficient using compare(idx, len ,str)
    } else {
      std::string token(str, 0, p);
      d->SetValue(token.c_str(), a);
    }
 
    data.LIST->push_back(d);
 
    str.erase(0, p);
    if (str.length()) {
      if (delimeter != ',') {
        p = str.find(',');
        if (p == std::string::npos)
          p = str.length();
        else
          p++;
        str.erase(0, p);
      } else
        str.erase(0, 1);
    }
  }
}
 
void
OksData::ReadFrom(const OksRelationship* r) noexcept
{
  if (r->get_high_cardinality_constraint() != OksRelationship::Many) {
    Set((OksObject*)0);
  } else {
    Set(new List());
  }
}
 
void
OksXmlInputStream::get_num_token(char __last)
{
  size_t pos(1);
 
  try {
    char c = get_first_non_empty();
 
    if (c == __last) {
      m_cvt_char->m_buf[0] = 0;
      throw std::runtime_error("empty numeric value");
    }
 
    m_cvt_char->m_buf[0] = c;
 
    while (true) {
      c = get();
 
      if (c == __last) {
        m_cvt_char->m_buf[pos] = '\0';
        f->unget();
        return;
      } else if (c == ' ' || c == '\n' || c == '\r' || c == '\t') {
        m_cvt_char->m_buf[pos] = '\0';
        return;
      }
 
      m_cvt_char->realloc(pos);
      m_cvt_char->m_buf[pos++] = c;
    }
  } catch (std::exception& ex) {
    m_cvt_char->m_buf[pos] = '\0';
    throw BadFileData(std::string("failed to read numeric value: ") + ex.what(), line_no, line_pos);
  }
}
 
void
OksData::read(const ReadFileParams& read_params, const OksAttribute* a, /*atype,*/ int32_t num)
{
  if (type != list_type) {
    Set(new List());
  } else if (!data.LIST->empty()) {
    free_list(*data.LIST);
  }
 
  while (num-- > 0) {
    data.LIST->push_back(new OksData(read_params, a));
  }
}
 
void
OksData::read(const ReadFileParams& read_params, const OksAttribute* a)
{
  const char* read_value = ""; // is used for report in case of exception
  char* __sanity;
  OksXmlInputStream& fxs(read_params.s);
 
  try {
    switch (a->get_data_type()) {
      case string_type:
        read_value = "quoted string";
        {
          size_t len = fxs.get_quoted();
          if (type == string_type && data.STRING) {
            data.STRING->assign(fxs.get_xml_token().m_buf, len);
          } else {
            Clear();
            type = string_type;
            data.STRING = new OksString(fxs.get_xml_token().m_buf, len);
          }
        }
        break;
 
      case s32_int_type:
        read_value = "signed 32 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<int32_t>(strtol(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case u32_int_type:
        read_value = "unsigned 32 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<uint32_t>(strtoul(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoul", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case s16_int_type:
        read_value = "signed 16 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<int16_t>(strtol(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case u16_int_type:
        read_value = "unsigned 16 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<uint16_t>(strtoul(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoul", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case s8_int_type:
        read_value = "signed 8 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<int8_t>(strtol(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case u8_int_type:
        read_value = "unsigned 8 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<uint8_t>(strtoul(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoul", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case s64_int_type:
        read_value = "signed 64 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<int64_t>(strtoll(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoll", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case u64_int_type:
        read_value = "unsigned 64 bits integer";
        fxs.get_num_token('<');
        Set(static_cast<uint64_t>(strtoull(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoull", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case float_type:
        read_value = "float";
        fxs.get_num_token('<');
        Set(strtof(fxs.m_cvt_char->m_buf, &__sanity));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtof", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case double_type:
        read_value = "double";
        fxs.get_num_token('<');
        Set(strtod(fxs.m_cvt_char->m_buf, &__sanity));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtod", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case bool_type:
        read_value = "boolean";
        fxs.get_num_token('<');
        Set(static_cast<bool>(strtol(fxs.m_cvt_char->m_buf, &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, fxs.m_cvt_char->m_buf, fxs.line_no, fxs.line_pos);
        break;
 
      case date_type:
        read_value = "quoted date string";
        {
          size_t len = fxs.get_quoted();
          Set(str2date(fxs.get_xml_token().m_buf, len));
        }
        break;
 
      case time_type:
        read_value = "quoted time string";
        {
          size_t len = fxs.get_quoted();
          Set(str2time(fxs.get_xml_token().m_buf, len));
        }
        break;
 
      case enum_type:
        read_value = "quoted enum string";
        {
          size_t len = fxs.get_quoted();
          SetE(fxs.get_xml_token().m_buf, len, a);
        }
        break;
 
      case uid2_type:
        read_value = "two quoted class-name / object-id strings";
        Set(new OksString(), new OksString());
        {
          size_t len = fxs.get_quoted();
          data.UID2.class_id->assign(fxs.get_xml_token().m_buf, len);
          len = fxs.get_quoted();
          data.UID2.object_id->assign(fxs.get_xml_token().m_buf, len);
        }
        break;
 
      case class_type:
        read_value = "quoted class-type string";
        type = class_type;
        fxs.get_quoted();
        SetValue(fxs.get_xml_token().m_buf, a);
        break;
 
      default:
        type = unknown_type;
        {
          std::ostringstream s;
          s << "Unknown attribute type \"" << (int)a->get_data_type() << "\" (line " << fxs.get_line_no() << ", char "
            << fxs.get_line_pos() << ')';
          throw std::runtime_error(s.str().c_str());
        }
    }
  } catch (exception& e) {
    throw FailedRead(read_value, e);
  } catch (std::exception& e) {
    throw FailedRead(read_value, e.what());
  }
}
 
void
OksData::read(const OksAttribute* a, const OksXmlValue& value)
{
  const char* read_value = ""; // is used for report in case of exception
  char* __sanity;
 
  try {
    switch (a->get_data_type()) {
      case string_type: {
        if (type == string_type && data.STRING) {
          data.STRING->assign(value.buf(), value.len());
        } else {
          Clear();
          type = string_type;
          data.STRING = new OksString(value.buf(), value.len());
        }
      } break;
 
      case s32_int_type:
        read_value = "signed 32 bits integer";
        Set(static_cast<int32_t>(strtol(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case u32_int_type:
        read_value = "unsigned 32 bits integer";
        Set(static_cast<uint32_t>(strtoul(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoul", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case s16_int_type:
        read_value = "signed 16 bits integer";
        Set(static_cast<int16_t>(strtol(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case u16_int_type:
        read_value = "unsigned 16 bits integer";
        Set(static_cast<uint16_t>(strtoul(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoul", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case s8_int_type:
        read_value = "signed 8 bits integer";
        Set(static_cast<int8_t>(strtol(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case u8_int_type:
        read_value = "unsigned 8 bits integer";
        Set(static_cast<uint8_t>(strtoul(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoul", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case s64_int_type:
        read_value = "signed 64 bits integer";
        Set(static_cast<int64_t>(strtoll(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoll", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case u64_int_type:
        read_value = "unsigned 64 bits integer";
        Set(static_cast<uint64_t>(strtoull(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtoull", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case float_type:
        read_value = "float";
        Set(strtof(value.buf(), &__sanity));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtof", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case double_type:
        read_value = "double";
        Set(strtod(value.buf(), &__sanity));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtod", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case bool_type:
        read_value = "boolean";
        Set(static_cast<bool>(strtol(value.buf(), &__sanity, 0)));
        if (__builtin_expect((*__sanity != 0 || errno == ERANGE), 0))
          OksXmlInputStream::__throw_strto("strtol", __sanity, value.buf(), value.line_no(), value.line_pos());
        break;
 
      case date_type:
        read_value = "quoted date string";
        Set(str2date(value.buf(), value.len()));
        break;
 
      case time_type:
        read_value = "quoted time string";
        Set(str2time(value.buf(), value.len()));
        break;
 
      case enum_type:
        read_value = "quoted enum string";
        SetE(value.buf(), value.len(), a);
        break;
 
      case uid2_type:
        read_value = "two quoted class-name / object-id strings";
        {
          std::ostringstream s;
          s << "Unexpected uid2 type at (line " << value.line_no() << ", char " << value.line_pos() << ')';
          throw std::runtime_error(s.str().c_str());
        }
        break;
 
      case class_type:
        read_value = "quoted class-type string";
        type = class_type;
        SetValue(value.buf(), a);
        break;
 
      default:
        type = unknown_type;
        {
          std::ostringstream s;
          s << "Unknown attribute type \"" << (int)a->get_data_type() << "\" (line " << value.line_no() << ", char "
            << value.line_pos() << ')';
          throw std::runtime_error(s.str().c_str());
        }
    }
  } catch (exception& e) {
    throw FailedRead(read_value, e);
  } catch (std::exception& e) {
    throw FailedRead(read_value, e.what());
  }
}
 
void
OksData::read(const OksAttribute* a, const ReadFileParams& read_params)
{
  if (type != list_type)
    Set(new List());
  else if (!data.LIST->empty())
    free_list(*data.LIST);
 
  while (true)
    try {
      const char* tag_start = read_params.s.get_tag_start();
 
      // check for closing tag
      if (*tag_start == '/' && cmp_str5n(tag_start + 1, OksObject::attribute_xml_tag))
        break;
 
      if (cmp_str4(tag_start, OksObject::data_xml_tag)) {
        {
          OksXmlAttribute attr(read_params.s);
 
          if (cmp_str3(attr.name(), OksObject::value_xml_attribute)) {
            OksXmlValue value(read_params.s.get_value(attr.p_value_len));
            data.LIST->push_back(new OksData(a, value));
          } else {
            std::ostringstream s;
            s << "Unexpected attribute \"" << attr.name() << "\" instead of \"" << OksObject::value_xml_attribute
              << "\" (line " << read_params.s.get_line_no() << ", char " << read_params.s.get_line_pos() << ')';
            throw std::runtime_error(s.str().c_str());
          }
        }
        {
          OksXmlAttribute attr(read_params.s);
 
          if (cmp_str1(attr.name(), "/") == false) {
            std::ostringstream s;
            s << "Unexpected tag \"" << attr.name() << "\" instead of close tag (line " << read_params.s.get_line_no()
              << ", char " << read_params.s.get_line_pos() << ')';
            throw std::runtime_error(s.str().c_str());
          }
        }
      } else {
        std::ostringstream s;
        s << "Unexpected tag \"" << tag_start << "\" (line " << read_params.s.get_line_no() << ", char "
          << read_params.s.get_line_pos() << ')';
        throw std::runtime_error(s.str().c_str());
      }
    } catch (exception& e) {
      throw FailedRead("multi-value", e);
    } catch (std::exception& e) {
      throw FailedRead("multi-value", e.what());
    }
}
 
void
OksData::read(const ReadFileParams& read_params, const OksRelationship* r, int32_t num)
{
  if (__builtin_expect((type != list_type), 0)) {
    Set(new List());
  } else if (__builtin_expect((!data.LIST->empty()), 0)) {
    free_list(*data.LIST);
  }
 
  while (num-- > 0) {
    OksData* d = new OksData(read_params, r);
 
    // ignore dangling objects saved previously
    if (__builtin_expect((d->type == OksData::uid2_type && d->data.UID2.class_id->empty()), 0))
      continue;
 
    // add real object
    data.LIST->push_back(d);
  }
}
 
void
OksData::read(const ReadFileParams& read_params, const OksRelationship* r)
{
  const OksClass* rel_class(r->p_class_type); // class of relationship
  OksString* class_id(0);                     // class-name of read object
  const OksClass* c(0);                       // class of read object
  OksXmlInputStream& fxs(read_params.s);
 
  try {
 
    // read class name from stream and store it either on 'c' (pointer-to-class) or new OksString
 
    size_t len = fxs.get_quoted();
 
    if (__builtin_expect((len > 0), 1)) {
      if (__builtin_expect((!read_params.alias_table), 1)) {
        if (__builtin_expect((rel_class != 0), 1)) {
          c = rel_class->get_kernel()->find_class(fxs.get_xml_token().m_buf);
        }
 
        if (__builtin_expect((c == 0), 0)) {
          class_id = new OksString(fxs.get_xml_token().m_buf, len);
        }
      } else {
        const char* class_name_str(fxs.get_xml_token().m_buf);
 
        if (class_name_str[0] == '@') {
          class_name_str++;
          len--;
 
          c = (rel_class ? rel_class->get_kernel()->find_class(class_name_str) : 0);
 
          if (c) {
            read_params.alias_table->add_value(0, c);
          } else {
            read_params.alias_table->add_value(new OksString(class_name_str, len), 0);
          }
        } else {
          if (rel_class) {
            if (const OksAliasTable::Value* value = read_params.alias_table->get(class_name_str)) {
              c = (value->class_ptr ? value->class_ptr : rel_class->get_kernel()->find_class(*value->class_name));
            } else {
              Oks::warning_msg("OksData::read(const ReadFileParams&, const OksRelationship*")
                << "  Can't find alias for class \'" << class_name_str
                << "\'\n"
                   "  Possibly data file has been saved in old format\n";
 
              c = rel_class->get_kernel()->find_class(class_name_str);
            }
          }
        }
 
        if (!c) {
          class_id = new OksString(class_name_str, len);
        }
      }
    }
 
    // read object id from stream and try to find OksObject
 
    len = fxs.get_quoted();
 
    if (__builtin_expect((c == 0), 0)) {
      if (class_id) {
        Set(class_id, new OksString(fxs.get_xml_token().m_buf, len));
        class_id = 0;
      } else {
        Set((OksObject*)0);
      }
 
      goto final;
    }
 
    std::string& obj_id((const_cast<ReadFileParams&>(read_params)).tmp); // use temporal string for fast assignment
    obj_id.assign(fxs.get_xml_token().m_buf, len);
    OksObject* obj = c->get_object(obj_id);
 
    if (!obj) {
      Set(c, new OksString(obj_id));
      goto final;
    }
 
    // final checks
 
    read_params.owner->OksObject::check_class_type(r, c);
    Set(obj);
    obj->add_RCR(read_params.owner, r);
  } catch (exception& ex) {
    if (class_id)
      delete class_id;
    throw FailedRead("relationship value", ex);
  } catch (std::exception& ex) {
    if (class_id)
      delete class_id;
    throw FailedRead("relationship value", ex.what());
  }
 
final:
 
  IsConsistent(r, read_params.owner, "WARNING");
}
 
void
OksData::read(const OksRelationship* r, const OksXmlRelValue& value)
{
  try {
    if (__builtin_expect((value.m_class == nullptr), 0)) {
      if (value.m_class_id) {
        Set(value.m_class_id, new OksString(value.m_value.buf(), value.m_value.len()));
        value.m_class_id = nullptr;
      } else {
        Set((OksObject*)nullptr);
      }
 
      goto final;
    }
 
    OksObject* obj = value.m_class->get_object(value.m_value.buf());
 
    if (!obj) {
      Set(value.m_class, new OksString(value.m_value.buf(), value.m_value.len()));
      goto final;
    }
 
    // final checks
 
    value.m_file_params.owner->OksObject::check_class_type(r, value.m_class);
    Set(obj);
    obj->add_RCR(value.m_file_params.owner, r);
  } catch (exception& ex) {
    if (value.m_class_id)
      delete value.m_class_id;
    throw FailedRead("relationship value", ex);
  } catch (std::exception& ex) {
    if (value.m_class_id)
      delete value.m_class_id;
    throw FailedRead("relationship value", ex.what());
  }
 
final:
 
  IsConsistent(r, value.m_file_params.owner, "WARNING");
}
 
void
OksData::read(const OksRelationship* r, const ReadFileParams& read_params)
{
  if (type != list_type)
    Set(new List());
  else if (!data.LIST->empty())
    free_list(*data.LIST);
 
  while (true)
    try {
      const char* tag_start = read_params.s.get_tag_start();
 
      // check for closing tag
      if (*tag_start == '/' && cmp_str4n(tag_start + 1, OksObject::relationship_xml_tag))
        break;
 
      if (cmp_str3(tag_start, OksObject::ref_xml_tag)) {
        OksXmlRelValue value(read_params);
 
        try {
          while (true) {
            OksXmlAttribute attr(read_params.s);
 
            // check for close of tag
 
            if (cmp_str1(attr.name(), ">") || cmp_str1(attr.name(), "/")) {
              break;
            }
 
            // check for known oks-relationship' attributes
 
            else if (cmp_str5(attr.name(), OksObject::class_xml_attribute)) {
              value.m_class = read_params.owner->uid.class_id->get_kernel()->find_class(attr.value());
              if (__builtin_expect((value.m_class == nullptr && attr.value_len() > 0), 0)) {
                value.m_class_id = new OksString(attr.value(), attr.value_len());
              }
            } else if (cmp_str2(attr.name(), OksObject::id_xml_attribute)) {
              value.m_value = read_params.s.get_value(attr.p_value_len);
            } else
              read_params.s.throw_unexpected_attribute(attr.name());
          }
 
          if (value.is_empty() == false) {
            OksData* d = new OksData(r, value);
 
            // ignore dangling objects saved previously
            if (__builtin_expect((d->type == OksData::uid2_type && d->data.UID2.class_id->empty()), 0))
              continue;
 
            // add real object
            data.LIST->push_back(d);
          }
        } catch (exception& e) {
          throw FailedRead("multi-value relationship", e);
        } catch (std::exception& e) {
          throw FailedRead("multi-value relationship", e.what());
        }
      } else {
        std::ostringstream s;
        s << "Unexpected tag \"" << tag_start << "\" (line " << read_params.s.get_line_no() << ", char "
          << read_params.s.get_line_pos() << ')';
        throw std::runtime_error(s.str().c_str());
      }
    } catch (exception& e) {
      throw FailedRead("multi-value", e);
    } catch (std::exception& e) {
      throw FailedRead("multi-value", e.what());
    }
}
 
//
// Writes to stream any OKS data except relationship types
// (i.e. object, uid, uid2)
//
 
void
OksData::WriteTo(OksXmlOutputStream& xmls, bool put_number) const
{
  switch (type) {
    case list_type: {
      if (!data.LIST->empty()) {
        if (put_number)
          xmls.put_value((unsigned long)data.LIST->size());
        for (List::iterator i = data.LIST->begin(); i != data.LIST->end(); ++i) {
          if (!put_number) {
            xmls.put_raw('\n');
            xmls.put_raw(' ');
          }
 
          xmls.put_raw(' ');
 
          (*i)->WriteTo(xmls, put_number);
        }
 
        if (!put_number) {
          xmls.put_raw('\n');
          xmls.put_raw(' ');
        }
      } else {
        if (put_number)
          xmls.put_raw('0');
      }
 
      break;
    }
 
    case string_type:
      xmls.put_quoted(data.STRING->c_str());
      break;
 
    case s32_int_type:
      xmls.put_value(data.S32_INT);
      break;
 
    case u32_int_type:
      xmls.put_value(data.U32_INT);
      break;
 
    case s16_int_type:
      xmls.put_value(data.S16_INT);
      break;
 
    case u16_int_type:
      xmls.put_value(data.U16_INT);
      break;
 
    case float_type: {
      std::ostream& s = xmls.get_stream();
      std::streamsize p = s.precision();
      s.precision(std::numeric_limits<float>::digits10);
      xmls.put_value(data.FLOAT);
      s.precision(p);
      break;
    }
 
    case double_type: {
      std::ostream& s = xmls.get_stream();
      std::streamsize p = s.precision();
      s.precision(std::numeric_limits<double>::digits10);
      xmls.put_value(data.DOUBLE);
      s.precision(p);
      break;
    }
 
    case s8_int_type:
      xmls.put_value(static_cast<int16_t>(data.S8_INT));
      break;
 
    case u8_int_type:
      xmls.put_value(static_cast<uint16_t>(data.U8_INT));
      break;
 
    case s64_int_type:
      xmls.put_value(data.S64_INT);
      break;
 
    case u64_int_type:
      xmls.put_value(data.U64_INT);
      break;
 
    case bool_type:
      xmls.put_value((short)(data.BOOL));
      break;
 
    case date_type:
      xmls.put_quoted(boost::gregorian::to_iso_string(date()).c_str());
      break;
 
    case time_type:
      xmls.put_quoted(boost::posix_time::to_iso_string(time()).c_str());
      break;
 
    case enum_type:
      xmls.put_quoted(data.ENUMERATION->c_str());
      break;
 
    case class_type:
      xmls.put_quoted(data.CLASS->get_name().c_str());
      break;
 
    case uid2_type:
    case uid_type:
    case object_type:
    case unknown_type:
      Oks::error_msg("OksData::WriteTo(OksXmlOutputStream&, bool)")
        << "Can't write \'" << (type == unknown_type ? "unknown" : "relationship") << "_type\'\n";
      break;
  }
}
 
void
OksData::WriteTo(OksXmlOutputStream& xmls) const
{
  switch (type) {
    case string_type:
      xmls.put(data.STRING->c_str());
      break;
 
    case s32_int_type:
      xmls.put_value(data.S32_INT);
      break;
 
    case u32_int_type:
      xmls.put_value(data.U32_INT);
      break;
 
    case s16_int_type:
      xmls.put_value(data.S16_INT);
      break;
 
    case u16_int_type:
      xmls.put_value(data.U16_INT);
      break;
 
    case float_type: {
      std::ostream& s = xmls.get_stream();
      std::streamsize p = s.precision();
      s.precision(std::numeric_limits<float>::digits10);
      xmls.put_value(data.FLOAT);
      s.precision(p);
      break;
    }
 
    case double_type: {
      std::ostream& s = xmls.get_stream();
      std::streamsize p = s.precision();
      s.precision(std::numeric_limits<double>::digits10);
      xmls.put_value(data.DOUBLE);
      s.precision(p);
      break;
    }
 
    case s8_int_type:
      xmls.put_value(static_cast<int16_t>(data.S8_INT));
      break;
 
    case u8_int_type:
      xmls.put_value(static_cast<uint16_t>(data.U8_INT));
      break;
 
    case s64_int_type:
      xmls.put_value(data.S64_INT);
      break;
 
    case u64_int_type:
      xmls.put_value(data.U64_INT);
      break;
 
    case bool_type:
      xmls.put_value((short)(data.BOOL));
      break;
 
    case date_type:
      xmls.put(boost::gregorian::to_iso_string(date()).c_str());
      break;
 
    case time_type:
      xmls.put(boost::posix_time::to_iso_string(time()).c_str());
      break;
 
    case enum_type:
      xmls.put(data.ENUMERATION->c_str());
      break;
 
    case class_type:
      xmls.put(data.CLASS->get_name().c_str());
      break;
 
    case list_type:
      throw std::runtime_error("internal error: call OksData::WriteTo() on list");
 
    case uid2_type:
    case uid_type:
    case object_type:
    case unknown_type:
      Oks::error_msg("OksData::WriteTo(OksXmlOutputStream&, bool)")
        << "Can't write \'" << (type == unknown_type ? "unknown" : "relationship") << "_type\'\n";
      break;
  }
}
 
//
// Writes to XML stream OKS data relationship types
//
 
void
OksData::WriteTo(OksXmlOutputStream& xmls,
                 OksKernel* k,
                 OksAliasTable* alias_table,
                 bool /*test_existance*/,
                 bool put_number) const
{
  const char* fname = "WriteTo(OksXmlOutputStream&, ...)";
 
  static std::string emptyName(""); // to save NIL name
 
  const std::string* class_name = 0;
  const std::string* object_id = 0;
 
  switch (type) {
    case object_type:
      if (data.OBJECT) {
        class_name = &data.OBJECT->GetClass()->get_name();
        object_id = &data.OBJECT->GetId();
      } else
        class_name = object_id = &emptyName;
 
      break;
 
    case list_type: {
      if (!data.LIST->empty()) {
        if (put_number)
          xmls.put_value((unsigned long)data.LIST->size());
 
        for (List::iterator i = data.LIST->begin(); i != data.LIST->end(); ++i) {
          if (!put_number) {
            xmls.put_raw('\n');
            xmls.put_raw(' ');
          }
 
          xmls.put_raw(' ');
 
          (*i)->WriteTo(xmls, k, alias_table, false, put_number);
        }
 
        if (!put_number) {
          xmls.put_raw('\n');
          xmls.put_raw(' ');
        }
      } else {
        if (put_number)
          xmls.put_raw('0');
      }
 
      return;
    }
 
    case uid2_type:
      class_name = data.UID2.class_id;
      object_id = data.UID2.object_id;
      break;
 
    case uid_type:
      class_name = &data.UID.class_id->get_name();
      object_id = data.UID.object_id;
      break;
 
    default:
      Oks::error_msg(fname) << "Can't write \'" << (type == unknown_type ? "unknown" : "attribute") << "_type\'\n";
      return;
  }
 
  if (!class_name->empty()) {
 
    // if alias table is not defined, store object in extended format
 
    if (!alias_table) {
      xmls.put_quoted(class_name->c_str());
    }
 
    // otherwise store object in compact format
 
    else {
      const OksAliasTable::Value* value = alias_table->get(static_cast<const OksString*>(class_name));
 
      // class' alias was already defined
      if (value)
        xmls.put_quoted(value->class_name->c_str());
 
      // makes new class' alias
      else {
        alias_table->add_key(static_cast<OksString*>(const_cast<std::string*>(class_name)));
 
        std::string s(*class_name);
        s.insert(0, "@"); // add '@' to distinguish alias from class name when load
        xmls.put_quoted(s.c_str());
      }
    }
 
  } else {
    xmls.put_quoted("");
  }
 
  xmls.put_raw(' ');
  xmls.put_quoted(object_id->c_str());
}
 
void
OksData::ConvertTo(OksData* to, const OksRelationship* r) const
{
  if (r->get_high_cardinality_constraint() == OksRelationship::Many) {
    to->Set(new List());
 
    if (type != list_type) {
      OksData* item = new OksData();
 
      if (type == OksData::object_type)
        item->Set(data.OBJECT);
      else if (type == OksData::uid_type)
        item->Set(data.UID.class_id, *data.UID.object_id);
      else if (type == OksData::uid2_type)
        item->Set(*data.UID2.class_id, *data.UID2.object_id);
 
      to->data.LIST->push_back(item);
 
      return;
    } else if (data.LIST && !data.LIST->empty()) {
      for (List::iterator i = data.LIST->begin(); i != data.LIST->end(); ++i) {
        OksData* item = new OksData();
        OksData* dd = *i;
 
        if (dd->type == OksData::object_type)
          item->Set(dd->data.OBJECT);
        else if (dd->type == OksData::uid_type)
          item->Set(dd->data.UID.class_id, *dd->data.UID.object_id);
        else if (dd->type == OksData::uid2_type)
          item->Set(*dd->data.UID2.class_id, *dd->data.UID2.object_id);
 
        to->data.LIST->push_back(item);
      }
 
      return;
    }
 
  } else {
    const OksData* from = ((type == list_type) ? data.LIST->front() : this);
 
    if (from->type == OksData::object_type)
      to->Set(from->data.OBJECT);
    else if (from->type == OksData::uid_type)
      to->Set(from->data.UID.class_id, *from->data.UID.object_id);
    else if (from->type == OksData::uid2_type)
      to->Set(*from->data.UID2.class_id, *from->data.UID2.object_id);
  }
}
 
void
OksData::cvt(OksData* to, const OksAttribute* a) const
{
  if (a->get_is_multi_values()) {
    to->Set(new List());
 
    if (type != list_type) {
      OksData* item = new OksData();
 
      std::string cvts = str();
      item->ReadFrom(cvts.c_str(), a->get_data_type(), a);
 
      to->data.LIST->push_back(item);
 
      return;
    } else if (data.LIST && !data.LIST->empty()) {
      for (List::iterator i = data.LIST->begin(); i != data.LIST->end(); ++i) {
        OksData* item = new OksData();
        OksData* dd = *i;
 
        std::string cvts = dd->str();
        item->ReadFrom(cvts.c_str(), a->get_data_type(), a);
 
        to->data.LIST->push_back(item);
      }
 
      return;
    }
  } else {
    const OksData* from = ((type == list_type) ? (data.LIST->empty() ? 0 : data.LIST->front()) : this);
    std::string cvts;
    if (from)
      cvts = from->str();
    to->ReadFrom(cvts.c_str(), a->get_data_type(), a);
  }
}
 
static std::string
list2str(const OksData::List* l, const OksKernel* k, int base)
{
  std::ostringstream s;
 
  s << '(';
 
  if (l) {
    bool is_first = true;
 
    for (OksData::List::const_iterator i = l->begin(); i != l->end(); ++i) {
      std::string s2 = (k ? (*i)->str(k) : (*i)->str(base));
 
      if (!s2.empty()) {
        if (is_first == false) {
          s << ", ";
        } else {
          is_first = false;
        }
        s << s2;
      }
    }
  }
 
  s << ')';
 
  return s.str();
}
 
// only is used for OksData pointing to objects
 
std::string
OksData::str(const OksKernel* kernel) const
{
  if (type == list_type) {
    return list2str(data.LIST, kernel, 0);
  }
 
  std::ostringstream s;
 
  switch (type) {
    case uid2_type:
      s << "#[" << *data.UID2.object_id << '@' << *data.UID2.class_id << ']';
      break;
 
    case uid_type:
      s << "#[" << *data.UID.object_id << '@' << data.UID.class_id->get_name() << ']';
      break;
 
    case object_type:
      if (data.OBJECT && !kernel->is_dangling(data.OBJECT) && data.OBJECT->GetClass()->get_name().length()) {
        s << '[' << data.OBJECT->GetId() << '@' << data.OBJECT->GetClass()->get_name() << ']';
      }
      break;
 
    default:
      std::cerr << "ERROR [OksData::str(const OksKernel *)]: wrong use for such data: " << *this << std::endl;
      return "";
  }
 
  return s.str();
}
 
// is only used for primitive data types
 
std::string
OksData::str(int base) const
{
  if (type == string_type) {
    return *data.STRING;
  } else if (type == enum_type) {
    return *data.ENUMERATION;
  } else if (type == bool_type) {
    return (data.BOOL ? "true" : "false");
  } else if (type == list_type) {
    return list2str(data.LIST, 0, base);
  } else if (type == date_type) {
    return boost::gregorian::to_simple_string(date());
  } else if (type == time_type) {
    return boost::posix_time::to_simple_string(time());
  } else if (type == class_type) {
    return data.CLASS->get_name();
  }
 
  std::ostringstream s;
 
  if (base) {
    s.setf((base == 10 ? std::ios::dec : base == 16 ? std::ios::hex : std::ios::oct), std::ios::basefield);
    s.setf(std::ios::showbase);
  }
 
  switch (type) {
    case s8_int_type:
      s << static_cast<int16_t>(data.S8_INT);
      break;
 
    case u8_int_type:
      s << static_cast<uint16_t>(data.U8_INT);
      break;
 
    case s16_int_type:
      s << data.S16_INT;
      break;
 
    case u16_int_type:
      s << data.U16_INT;
      break;
 
    case s32_int_type:
      s << data.S32_INT;
      break;
 
    case u32_int_type:
      s << data.U32_INT;
      break;
 
    case s64_int_type:
      s << data.S64_INT;
      break;
 
    case u64_int_type:
      s << data.U64_INT;
      break;
 
    case float_type:
      s.precision(std::numeric_limits<float>::digits10);
      s << data.FLOAT;
      break;
 
    case double_type:
      s.precision(std::numeric_limits<double>::digits10);
      s << data.DOUBLE;
      break;
 
    default:
      std::cerr << "ERROR [OksData::str(int)]: wrong use for such data: " << *this << std::endl;
      return "";
  }
 
  return s.str();
}
 
bool
OksData::IsConsistent(const OksRelationship* r, const OksObject* o, const char* msg)
{
  if (r->get_low_cardinality_constraint() != OksRelationship::Zero) {
    if ((type == OksData::object_type && data.OBJECT == 0) ||
        (type == OksData::uid_type && (!data.UID.object_id || data.UID.object_id->empty() || !data.UID.class_id)) ||
        (type == OksData::uid2_type && (!data.UID2.object_id || !data.UID2.class_id || data.UID2.object_id->empty() ||
                                        data.UID2.class_id->empty()))) {
      if (o->GetClass()->get_kernel()->get_silence_mode() != true) {
        std::cerr << msg << ": value of \"" << r->get_name() << "\" relationship in object " << o
                  << " must be non-null\n";
      }
      return false;
    } else if (type == OksData::list_type && data.LIST->empty()) {
      if (o->GetClass()->get_kernel()->get_silence_mode() != true) {
        std::cerr << msg << ": \"" << r->get_name() << "\" relationship in object " << o
                  << " must contain at least one object\n";
      }
      return false;
    }
  }
 
  return true;
}
 
void
OksData::sort(bool ascending)
{
  if (type != list_type || data.LIST->size() < 2)
    return;
 
  if (ascending)
    data.LIST->sort([](const OksData* a, const OksData* b) { return *a < *b; });
  else
    data.LIST->sort([](const OksData* a, const OksData* b) { return *a > *b; });
}
 
boost::posix_time::ptime
str2time(const char* value, size_t len, const char* file_name)
{
  if (len == 15 && value[8] == 'T') {
    try {
      return boost::posix_time::from_iso_string(value);
    } catch (std::exception& ex) {
      // throw TimeCvtFailed(value, ex.what());
      throw AttributeReadError(value, "time", ex.what());
    }
  } else {
    try {
      Time t(value);
      std::ostringstream text;
      text << std::setfill('0') << std::setw(4) << t.year() << std::setw(2) << (t.month() + 1) << std::setw(2)
           << t.day() << 'T' << std::setw(2) << t.hour() << std::setw(2) << t.min() << std::setw(2) << t.sec();
      TLOG_DEBUG(1) << "parse OKS time: " << t << " => " << text.str();
 
      if (file_name)
        ers::warning(DeprecatedFormat(ERS_HERE, file_name, value));
      else
        Oks::warning_msg("oks str2time") << "The file is using deprecated OKS time format \"" << value
                                         << "\"\nPlease refresh it using an oks application\nSupport for such format "
                                            "will be removed in a future release.\n";
 
      return boost::posix_time::from_iso_string(text.str());
    } catch (exception& ex) {
      // throw TimeCvtFailed(value, ex);
      throw AttributeReadError(value, "time", ex);
    } catch (std::exception& ex) {
      // throw TimeCvtFailed(value, ex.what());
      throw AttributeReadError(value, "time", ex.what());
    }
  }
}
 
boost::gregorian::date
str2date(const char* value, size_t len)
{
  if (len == 8 && value[2] != '/' && value[3] != '/') {
    try {
      return boost::gregorian::from_undelimited_string(value);
    } catch (std::exception& ex) {
      throw AttributeReadError(value, "date", ex.what());
    }
  } else {
    try {
      Date t(value);
      std::ostringstream text;
      text << std::setfill('0') << std::setw(4) << t.year() << std::setw(2) << (t.month() + 1) << std::setw(2)
           << t.day();
      TLOG_DEBUG(1) << "parse OKS date: " << t << " => " << text.str();
 
      Oks::warning_msg("oks str2date") << "The file is using deprecated OKS date format \"" << value
                                       << "\"\nPlease refresh it using an oks application.\nSupport for such format "
                                          "will be removed in a future release.\n";
 
      return boost::gregorian::from_undelimited_string(text.str());
    } catch (exception& ex) {
      throw AttributeReadError(value, "date", ex);
    } catch (std::exception& ex) {
      throw AttributeReadError(value, "date", ex.what());
    }
  }
}
 
} // namespace oks

ERS_DECLARE_ISSUE() [69/89]

dunedaq::ERS_DECLARE_ISSUE	(	opmonlib	,
		FailedInfoReconstruction	,
		"Failure to create an object of type "<<	type,
		((std::string) type)	)

ERS_DECLARE_ISSUE() [70/89]

dunedaq::ERS_DECLARE_ISSUE	(	opmonlib	,
		NonUniqueNodeName	,
		name<< " already present in the node list of "<<	opmon_id,
		((std::string) name)((std::string) opmon_id)	)

ERS_DECLARE_ISSUE() [71/89]

dunedaq::ERS_DECLARE_ISSUE	(	opmonlib	,
		OpMonFacilityCreationFailed	,
		"Facility "<< type<< ": creation failed"	,
		((std::string) type)	)

ERS_DECLARE_ISSUE() [72/89]

dunedaq::ERS_DECLARE_ISSUE	(	opmonlib	,
		OpmonServiceCreationFailed	,
		"OpmonServiceCreationFailed: "<<	error,
		((std::string) error)	)

ERS_DECLARE_ISSUE() [73/89]

dunedaq::ERS_DECLARE_ISSUE	(	serialization	,
		UnknownSerializationTypeString	,
		"Unknown serialization type "<<	t,
		((std::string) t)	)

Issue for when the serialization type cannot be determined from an input string.

Issue for when the serialization type byte cannot be determined from the SerializationType enum Issue for when the serialization type cannot be determined from the given type byte

ERS_DECLARE_ISSUE() [74/89]

dunedaq::ERS_DECLARE_ISSUE	(	snbmodules	,
		InvalidGroupTransferIDError	,
		"InvalidGroupTransferIDError: Transfer ID "<< transfer_id<< " not found in "<<	location,
		((std::string) transfer_id)((std::string) location)	)

ERS_DECLARE_ISSUE() [75/89]

dunedaq::ERS_DECLARE_ISSUE	(	tdemodules	,
		AMCCommandIssue	,
		"AMC with ip:"+ip+" and port: "<< port<< " | "<< "send command	failed,
		reason:"<<	text,
		((std::string) ip)((uint16_t) port)((std::string) text)	)

ERS_DECLARE_ISSUE() [76/89]

dunedaq::ERS_DECLARE_ISSUE	(	tdemodules	,
		AMCProtocolIssue	,
		prefix<< "AMCProtocolResponse: "<<	text,
		((std::string) prefix)((std::string) text)	)

ERS_DECLARE_ISSUE() [77/89]

dunedaq::ERS_DECLARE_ISSUE	(	tdemodules	,
		AMCResponseErr	,
		prefix<< "Received Error packet:"<< "\n"<< "Error code:"<< code<< "\nMessage: "<<	text,
		((std::string) prefix)((uint16_t) code)((std::string) text)	)

ERS_DECLARE_ISSUE() [78/89]

dunedaq::ERS_DECLARE_ISSUE	(	tdemodules	,
		AMCUnknownOpCode	,
		prefix<< "Unknown opcode recived: "<<	opcode,
		((std::string) prefix)((uint16_t) opcode)	)

ERS_DECLARE_ISSUE() [79/89]

dunedaq::ERS_DECLARE_ISSUE	(	timing	,
		DACChannelOutOfRange	,
		" DAC channel out of range: "<<	channel,
		((std::string) channel)	)

Parameters

-	Namespace
-	Issue class name
channel	Message
-	Message parameters

ERS_DECLARE_ISSUE() [80/89]

dunedaq::ERS_DECLARE_ISSUE	(	timing	,
		FileNotFound	,
		file_path<< " does not exist!"	,
		((std::string) file_path)	)

Parameters

-	Namespace
-	Issue class name
-	Message
-	Message parameters

ERS_DECLARE_ISSUE() [81/89]

dunedaq::ERS_DECLARE_ISSUE	(	timing	,
		SI534xConfigError	,
		" SI534xConfigError: "<<	message,
		((std::string) message)	)

Parameters

-	Namespace
-	Issue class name
message	Message
-	Message parameters

ERS_DECLARE_ISSUE() [82/89]

Missing configuration std::string tag dunedaq::ERS_DECLARE_ISSUE	(	timing	,
		SI534xRegWriteFailed	,
		" Failed to write Si53xx reg: "<< reg<< "with data: "<<	data,
		((std::string) reg)((std::string) data)	)

< Message parameters

Parameters

-	Namespace
-	Issue class name
data	Message
-	Message parameters

ERS_DECLARE_ISSUE() [83/89]

dunedaq::ERS_DECLARE_ISSUE	(	timing	,
		TimestampNotReady	,
		" Timestamp not ready in time; loaded: "<< loaded<< "	,
		error:" <<	error,
		((uint32_t) loaded)((uint32_t) error)	)

Class for timestamp generator node.

Print the status of the timing node.

Read the current timestamp words.

Returns

{ description_of_the_return_value }

Read the current timestamp words.

Returns

{ description_of_the_return_value }

Read the starting timestamp words.

Returns

{ description_of_the_return_value }

Read the software init timestamp words.

Returns

{ description_of_the_return_value }

Initialise timestamp.

Parameters

-	Namespace
-	Issue class name
error	Message
-	Message parameters // NOLINT

Definition at line 29 of file TimestampGeneratorNode.hpp.

                                                       : " << loaded << ", error: " << error, ///< Message
                  ((uint32_t)loaded)((uint32_t)error)                                         ///< Message parameters // NOLINT
)
namespace timing {

class TimestampGeneratorNode : public TimingNode
{
  UHAL_DERIVEDNODE(TimestampGeneratorNode)
public:
  explicit TimestampGeneratorNode(const uhal::Node& node);
  virtual ~TimestampGeneratorNode();

  std::string get_status(bool print_out = false) const override;

  uhal::ValVector<uint32_t> read_raw_timestamp(bool dispatch = true) const; // NOLINT(build/unsigned)

  uint64_t read_timestamp() const; // NOLINT(build/unsigned)

  uint64_t read_start_timestamp() const; // NOLINT(build/unsigned)

  uint64_t read_sw_init_timestamp() const; // NOLINT(build/unsigned)

  void set_timestamp(TimestampSource source) const; // NOLINT(build/unsigned)
};
 
} // namespace timing

ERS_DECLARE_ISSUE() [84/89]

dunedaq::ERS_DECLARE_ISSUE	(	timinglibs	,
		GatherThreadingIssue	,
		"Gather Threading Issue detected: "<<	err,
		((std::string) err)	)

An ERS Issue raised when a threading state error occurs.

ERS_DECLARE_ISSUE() [85/89]

dunedaq::ERS_DECLARE_ISSUE	(	timinglibs	,
		TimingEndpointNotReady	,
		endpoint<< " timing endpoint did not become ready in time. State 0x"<< std::hex<<	state,
		((std::string) endpoint)((uint) state)	)

TimingController is a DAQModule implementation that provides a base class for timing controller modules.

TimingController Constructor

Parameters

name	Instance name for this TimingController instance

< TimingController is not copy-constructible

< TimingController is not copy-assignable

< TimingController is not move-constructible

< TimingController is not move-assignable

Parameters

-	Namespace
-	Issue class name
state	Message
-	Message parameters

Definition at line 36 of file TimingController.hpp.

                     {
 
template<typename T>
struct MobileAtomic
{
  std::atomic<T> atomic;
 
  MobileAtomic()
    : atomic(T())
  {
  }
 
  explicit MobileAtomic(T const& v)
    : atomic(v)
  {
  }
  explicit MobileAtomic(std::atomic<T> const& a)
    : atomic(a.load())
  {
  }
 
  virtual ~MobileAtomic() = default;
 
  MobileAtomic(MobileAtomic const& other)
    : atomic(other.atomic.load())
  {
  }
 
  MobileAtomic& operator=(MobileAtomic const& other)
  {
    atomic.store(other.atomic.load());
    return *this;
  }
 
  MobileAtomic(MobileAtomic&&) = default;
  MobileAtomic& operator=(MobileAtomic&&) = default;
};
 
typedef MobileAtomic<uint64_t> AtomicUInt64; // NOLINT(build/unsigned)

class TimingController : public dunedaq::appfwk::DAQModule
{
public:
  explicit TimingController(const std::string& name, uint number_hw_commands);
 
  TimingController(const TimingController&) = delete;            
  TimingController& operator=(const TimingController&) = delete; 
  TimingController(TimingController&&) = delete;                 
  TimingController& operator=(TimingController&&) = delete;      
 
  void init(std::shared_ptr<appfwk::ConfigurationManager> mcfg) override;
 
protected:
  // DAQModule commands
  virtual void do_configure(const CommandData_t&);
  virtual void do_start(const CommandData_t&) {}
  virtual void do_stop(const CommandData_t&) {}
  virtual void do_scrap(const CommandData_t&);
 
  template<class T, class... Vs>
  void configure_hardware_or_recover_state(const nlohmann::json& data,
                                           std::string timing_entity_description,
                                           const Vs&... args);
 
  // Configuration
  std::string m_hw_command_out_connection;
  std::chrono::milliseconds m_hw_cmd_out_timeout;
  using sink_t = dunedaq::iomanager::SenderConcept<timingcmd::TimingHwCmd>;
  std::shared_ptr<sink_t> m_hw_command_sender;
  std::string m_timing_device;
  std::string m_timing_session_name;
  using source_t = dunedaq::iomanager::ReceiverConcept<nlohmann::json>;
  std::shared_ptr<source_t> m_device_info_receiver;
 
  virtual void send_hw_cmd(timingcmd::TimingHwCmd&& hw_cmd);
  virtual void send_configure_hardware_commands(const CommandData_t& data) = 0;
 
  // opmon
  uint m_number_hw_commands;
  std::vector<AtomicUInt64> m_sent_hw_command_counters;
 
  // Interpert device opmon info
  virtual void process_device_info(nlohmann::json /*message*/) = 0;
  std::chrono::milliseconds m_device_ready_timeout;
  std::atomic<bool> m_device_ready;
  std::atomic<uint> m_device_infos_received_count;
  std::atomic<bool> m_hardware_state_recovery_enabled;
 
  // common commands
  timingcmd::TimingHwCmd construct_hw_cmd(const std::string& cmd_id);
  timingcmd::TimingHwCmd construct_hw_cmd(const std::string& cmd_id, const nlohmann::json& payload);
  virtual void do_io_reset(const CommandData_t& data);
  virtual void do_print_status(const CommandData_t& data);
  const dal::TimingControllerConf* m_params;
};
} // namespace timinglibs

ERS_DECLARE_ISSUE() [86/89]

dunedaq::ERS_DECLARE_ISSUE	(	timinglibs	,
		TimingMasterNotReady	,
		master<< " timing master did not become ready in time."	,
		((std::string) master)	)

TimingMasterControllerBase is a DAQModule implementation that provides a control interface for timing master hardware.

TimingMasterControllerBase Constructor

Parameters

name	Instance name for this TimingMasterControllerBase instance

< TimingMasterControllerBase is not copy-constructible

< TimingMasterControllerBase is not copy-assignable

< TimingMasterControllerBase is not move-constructible

< TimingMasterControllerBase is not move-assignable

Parameters

-	Namespace
-	Issue class name
-	Message
-	Message parameters

Definition at line 31 of file TimingMasterControllerBase.hpp.

                     {

class TimingMasterControllerBase : public dunedaq::timinglibs::TimingController
{
public:
  explicit TimingMasterControllerBase(const std::string& name);
 
  TimingMasterControllerBase(const TimingMasterControllerBase&) =
    delete; 
  TimingMasterControllerBase& operator=(const TimingMasterControllerBase&) =
    delete; 
  TimingMasterControllerBase(TimingMasterControllerBase&&) =
    delete; 
  TimingMasterControllerBase& operator=(TimingMasterControllerBase&&) =
    delete; 
  virtual ~TimingMasterControllerBase()
  {
    if (endpoint_scan_thread.thread_running())
      endpoint_scan_thread.stop_working_thread();
  }
 
protected:
  // Commands
  void do_configure(const CommandData_t&) override;
  void do_start(const CommandData_t& data) override;
  void do_stop(const CommandData_t& data) override;
  void send_configure_hardware_commands(const CommandData_t& data) override;
 
  // timing master commands
  void do_master_set_timestamp(const CommandData_t&);
  void do_master_set_endpoint_delay(const CommandData_t& data);
  void do_master_send_fl_command(const CommandData_t& data);
  void do_master_measure_endpoint_rtt(const CommandData_t& data);
  void do_master_endpoint_scan(const CommandData_t& data);
 
  // pass op mon info
  //  void get_info(opmonlib::InfoCollector& ci, int level) override;
 
  timingcmd::TimingEndpointLocations m_monitored_endpoint_locations;
  uint m_endpoint_scan_period; // NOLINT(build/unsigned)
  dunedaq::utilities::WorkerThread endpoint_scan_thread;
  virtual void endpoint_scan(std::atomic<bool>&);
};
} // namespace timinglibs

ERS_DECLARE_ISSUE() [87/89]

dunedaq::ERS_DECLARE_ISSUE	(	trigger	,
		DroppedTPSet	,
		"Failed to send TPs from "<< s_ts<< " to "<<	e_ts,
		((uint64_t) s_ts)((uint64_t) e_ts)	)

ERS_DECLARE_ISSUE() [88/89]

dunedaq::ERS_DECLARE_ISSUE	(	trigger	,
		InvalidConfiguration	,
		"Invalid configuration error:"<<	conferror,
		((std::string) conferror)	)

ERS_DECLARE_ISSUE() [89/89]

dunedaq::ERS_DECLARE_ISSUE	(	utilities	,
		ServiceNotFound	,
		"The service "<< service<< " was not found in DNS"	,
		((std::string) service)	)

ERS_DECLARE_ISSUE_BASE() [1/7]

DAQModule std::string name dunedaq::ERS_DECLARE_ISSUE_BASE	(	appfwk	,
		DAQModuleInitFailed	,
		appfwk::GeneralDAQModuleIssue	,
		" init failed."	,
		((std::string) name)	,
		ERS_EMPTY	)

Initialization failed ERS Issue (used by DAQModuleManager).

Generic command ERS Issue

ERS_DECLARE_ISSUE_BASE() [2/7]

dunedaq::ERS_DECLARE_ISSUE_BASE	(	dfmodules	,
		FileDataStoreImplBadConfiguration	,
		appfwk::GeneralDAQModuleIssue	,
		"Construction of the FileDataStoreImpl base class failed due to faulty configuration"	,
		((std::string) name)	)

Various ERS Issues for exceptional data store situations.

ERS_DECLARE_ISSUE_BASE() [3/7]

dunedaq::ERS_DECLARE_ISSUE_BASE	(	dfmodules	,
		ProgressUpdate	,
		appfwk::GeneralDAQModuleIssue	,
		message	,
		((std::string) name)	,
		((std::string) message)	)

ERS_DECLARE_ISSUE_BASE() [4/7]

dunedaq::ERS_DECLARE_ISSUE_BASE	(	hsilibs	,
		ProgressUpdate	,
		appfwk::GeneralDAQModuleIssue	,
		message	,
		((std::string) name)	,
		((std::string) message)	)

ERS_DECLARE_ISSUE_BASE() [5/7]

dunedaq::ERS_DECLARE_ISSUE_BASE	(	listrev	,
		ProgressUpdate	,
		appfwk::GeneralDAQModuleIssue	,
		message	,
		((std::string) name)	,
		((std::string) message)	)

ERS_DECLARE_ISSUE_BASE() [6/7]

dunedaq::ERS_DECLARE_ISSUE_BASE	(	timinglibs	,
		ProgressUpdate	,
		appfwk::GeneralDAQModuleIssue	,
		message	,
		((std::string) name)	,
		((std::string) message)	)

ERS_DECLARE_ISSUE_BASE() [7/7]

dunedaq::ERS_DECLARE_ISSUE_BASE	(	wibmod	,
		UnreachableError	,
		appfwk::GeneralDAQModuleIssue	,
		"An unreachable part of the code has been reached."	,
		((std::string) name)	,
		ERS_EMPTY	)

ERS_DEFINE_ISSUE_BASE_CXX()

dunedaq::ERS_DEFINE_ISSUE_BASE_CXX	(	conffwk	,
		Generic	,
		conffwk::Exception	,
		what	,
		((const char *) what)	)

get_iom_receiver() [1/2]

template<typename Datatype>

std::shared_ptr< iomanager::ReceiverConcept< Datatype > > dunedaq::get_iom_receiver ( iomanager::ConnectionId const & id )

static

Definition at line 178 of file IOManager.hxx.

{
  return iomanager::IOManager::get()->get_receiver<Datatype>(id);
}

get_iom_receiver() [2/2]

template<typename Datatype>

std::shared_ptr< iomanager::ReceiverConcept< Datatype > > dunedaq::get_iom_receiver ( std::string const & uid )

static

Definition at line 192 of file IOManager.hxx.

{
  return iomanager::IOManager::get()->get_receiver<Datatype>(uid);
}

get_iom_sender() [1/2]

template<typename Datatype>

std::shared_ptr< iomanager::SenderConcept< Datatype > > dunedaq::get_iom_sender ( iomanager::ConnectionId const & id )

static

Definition at line 171 of file IOManager.hxx.

{
  return iomanager::IOManager::get()->get_sender<Datatype>(id);
}

get_iom_sender() [2/2]

template<typename Datatype>

std::shared_ptr< iomanager::SenderConcept< Datatype > > dunedaq::get_iom_sender ( std::string const & uid )

static

Definition at line 185 of file IOManager.hxx.

{
  return iomanager::IOManager::get()->get_sender<Datatype>(uid);
}

get_iomanager()

std::shared_ptr< iomanager::IOManager > dunedaq::get_iomanager ( )

static

Definition at line 164 of file IOManager.hxx.

{
  return iomanager::IOManager::get();
}

get_new()

type<< " \""<< data<< "\" is not found",,((const char *) type)((const char *) data)) ERS_DEFINE_ISSUE_BASE_CXX(conffwk, DeletedObject, conffwk::Exception, "object \'"<< object_id<< '@'<< class_name<< "\' was deleted",,((const char *) class_name)((const char *) object_id)) namespace conffwk {template< typename T > T * dunedaq::get_new ( ConfigObject & co, const std::string & attrname )

static

Definition at line 53 of file Configuration.cpp.

{
  T* retval = new T;
  co.get(attrname, *retval);
  return retval;
}

init_regex()

void dunedaq::init_regex ( std::unique_ptr< std::regex > & ptr, const std::string & str, const char * what )

static

Definition at line 858 of file Configuration.cpp.

{
  if (!str.empty())
    try {
      ptr = std::make_unique<std::regex>(str);
    } catch (const std::regex_error& ex) {
      std::ostringstream text;
      text << "failed to create " << what << " regex \"" << str << "\": " << ex.what();
      throw dunedaq::conffwk::Generic(ERS_HERE, text.str().c_str());
    }
}

operator<<() [1/3]

std::ostream & dunedaq::operator<<	(	std::ostream &	s,
		const Configuration &	c )

Definition at line 1752 of file Configuration.cpp.

{
  c.print(s);
  return s;
}

operator<<() [2/3]

std::ostream & dunedaq::operator<<	(	std::ostream &	s,
		const ConfigurationChange &	c )

Definition at line 1664 of file Configuration.cpp.

{
  s << " changes for class \'" << c.get_class_name() << "\' include:\n";
 
  print_svect(s, c.get_modified_objs(), " modified object(s)");
  print_svect(s, c.get_created_objs(), " created object(s)");
  print_svect(s, c.get_removed_objs(), " removed object(s)");
 
  return s;
}

operator<<() [3/3]

std::ostream & dunedaq::operator<<	(	std::ostream &	s,
		const std::vector< ConfigurationChange * > &	v )

Definition at line 1676 of file Configuration.cpp.

{
  s << "There are configuration changes in " << v.size() << " classes:\n";
 
  for (const auto& i : v)
    s << *i;
 
  return s;
}

print_svect()

void dunedaq::print_svect ( std::ostream & s, const std::vector< std::string > & v, const char * name )

static

Definition at line 1652 of file Configuration.cpp.

{
  s << "  * " << v.size() << name;
 
  for (auto i = v.begin(); i != v.end(); ++i) {
    s << ((i == v.begin()) ? ": " : ", ");
    s << '\"' << *i << '\"';
  }
 
  s << std::endl;
}

sourceid()

SourceID[" << sourceid << "] Command daqdataformats::SourceID dunedaq::sourceid

(

(std::string)

commanderror

)

to()

Both frame_count_limit and tp_count_limit were set dunedaq::to

(

disabled

)

tpset_source_id()

Cannot add TPSet with because another TPSet with these values already size_t dunedaq::tpset_source_id

(

(daqdataformats::timestamp_t)

tpset_start_time

)

Variable Documentation

__pad0__

default dunedaq::__pad0__

Definition at line 72 of file DAQModule.hpp.

address

Invalid dunedaq::address

Definition at line 26 of file CommonIssues.hpp.

AssignedTriggerDecisionNotFound

dunedaq::AssignedTriggerDecisionNotFound

Definition at line 41 of file TriggerRecordBuilderData.hpp.

BadStreamConf

dunedaq::BadStreamConf

Definition at line 11 of file appmodelIssues.hpp.

BlockSizeConfigurationInconsistency

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed std::string chunk dunedaq::BlockSizeConfigurationInconsistency

Definition at line 44 of file FelixIssues.hpp.

bool

Unknown serialization type<< t, ((char)t)) template<typename T> inline std::string datatype_to_string() { return "Unknown"; } namespace serialization { template<typename T> struct is_serializable : std::false_type {}; enum SerializationType { kMsgPack }; inline SerializationType from_string(const std::string s) { if (s == "msgpack") return kMsgPack; throw UnknownSerializationTypeString(ERS_HERE, s); } constexpr uint8_t serialization_type_byte(SerializationType stype) { switch (stype) { case kMsgPack: return 'M'; default: throw UnknownSerializationTypeEnum(ERS_HERE); } } constexpr SerializationType DEFAULT_SERIALIZATION_TYPE = kMsgPack; template<class T> std::vector<uint8_t> serialize(const T& obj, SerializationType stype = DEFAULT_SERIALIZATION_TYPE) { switch (stype) { case kMsgPack: { msgpack::sbuffer buf; msgpack::pack(buf, obj); std::vector<uint8_t> ret(buf.size() + 1); ret[0] = serialization_type_byte(stype); std::copy(buf.data(), buf.data() + buf.size(), ret.begin() + 1); return ret; } default: throw UnknownSerializationTypeEnum(ERS_HERE); } } template<class T, typename CharType = unsigned char> T deserialize(const std::vector<CharType>& v) { switch (v[0]) { case serialization_type_byte(kMsgPack): { try { msgpack::object_handle oh = msgpack::unpack( const_cast<char*>(reinterpret_cast<const char*>(v.data() + 1)), v.size() - 1, [](msgpack::type::object_type , std::size_t , void* ) -> dunedaq::bool { return true

Definition at line 251 of file Serialization.hpp.

BufferedReaderWriterConfigurationError

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror dunedaq::BufferedReaderWriterConfigurationError

Definition at line 41 of file DataHandlingIssues.hpp.

CannotCreateConsumer

dunedaq::CannotCreateConsumer

Definition at line 29 of file kafka_opmon_consumer.cxx.

CantWriteToFile

dunedaq::CantWriteToFile

Definition at line 26 of file SummaryTextDataWriter.hpp.

chunk

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed dunedaq::chunk

Definition at line 35 of file FelixIssues.hpp.

CIB

CIB Buffer std::string descriptor Message from dunedaq::CIB

Definition at line 27 of file CIBModuleIssues.hpp.

CIBBufferWarning

dunedaq::CIBBufferWarning

Definition at line 23 of file CIBModuleIssues.hpp.

CIBConfigFailure

CIB Buffer std::string descriptor Message from std::string descriptor CIB process std::string descriptor dunedaq::CIBConfigFailure

Definition at line 35 of file CIBModuleIssues.hpp.

CIBMessage

CIB Buffer std::string descriptor dunedaq::CIBMessage

Definition at line 27 of file CIBModuleIssues.hpp.

CIBProcError

CIB Buffer std::string descriptor Message from std::string descriptor dunedaq::CIBProcError

Definition at line 31 of file CIBModuleIssues.hpp.

CommandError

dunedaq::CommandError

Definition at line 26 of file DataHandlingIssues.hpp.

CommandExecutionFailed

Unsupported std::string uri dunedaq::CommandExecutionFailed

Definition at line 62 of file Issues.hpp.

CommandFacilityCreationFailed

Unsupported std::string uri Execution of command std::string error dunedaq::CommandFacilityCreationFailed

Definition at line 70 of file Issues.hpp.

CommandIssue

DAQModule std::string name dunedaq::CommandIssue

Definition at line 88 of file DAQModule.hpp.

component

No such dunedaq::component

Definition at line 39 of file ConfigurationManager.hpp.

ConfigurationFailed

dunedaq::ConfigurationFailed

Definition at line 36 of file Issues.hpp.

ConflictingCommandMatching

init Command received when already ERS_EMPTY dunedaq::ConflictingCommandMatching

Definition at line 49 of file DAQModuleManager.hpp.

ConnectionNotFound

dunedaq::ConnectionNotFound

Definition at line 28 of file NetworkIssues.hpp.

consumer

Cannot create dunedaq::consumer

Definition at line 29 of file kafka_opmon_consumer.cxx.

CorruptedFile

dunedaq::CorruptedFile

< Namespace

Issue class name

Definition at line 28 of file TimingIssues.hpp.

CTBBufferWarning

dunedaq::CTBBufferWarning

Definition at line 27 of file CTBModuleIssues.hpp.

CTBConfigFailure

CTB Buffer std::string descriptor CTB Repeated Word std::string descriptor dunedaq::CTBConfigFailure

Definition at line 41 of file CTBModuleIssues.hpp.

CTBRepeatedTimestampWarning

CTB Buffer std::string descriptor dunedaq::CTBRepeatedTimestampWarning

Definition at line 35 of file CTBModuleIssues.hpp.

DACValueOutOfRange

dunedaq::DACValueOutOfRange

< Namespace

Issue class name

Definition at line 31 of file DACNode.hpp.

DAQModuleManagerAlreadyInitialized

dunedaq::DAQModuleManagerAlreadyInitialized

Definition at line 39 of file DAQModuleManager.hpp.

DeletedObject

dunedaq::DeletedObject

Definition at line 67 of file Errors.hpp.

descriptor

CTB Buffer std::string descriptor CTB Repeated Word std::string descriptor dunedaq::descriptor

Definition at line 35 of file CIBModuleIssues.hpp.

DeviceInfoSendFailed

dunedaq::DeviceInfoSendFailed

Definition at line 44 of file InfoGatherer.hpp.

DuplicateTPWindow

dunedaq::DuplicateTPWindow

Definition at line 39 of file TPBundleHandler.hpp.

EntryWithNoData

dunedaq::EntryWithNoData

Definition at line 35 of file MonitorableObject.hpp.

Error

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror Configuration dunedaq::Error

Definition at line 20 of file FelixIssues.hpp.

error

CIB Buffer std::string descriptor Message from std::string descriptor CIB process dunedaq::error

Definition at line 31 of file CIBModuleIssues.hpp.

exists

Cannot add TPSet with because another TPSet with these values already dunedaq::exists

Definition at line 42 of file TPBundleHandler.hpp.

failed

Unsupported std::string uri Execution of command dunedaq::failed

Definition at line 62 of file Issues.hpp.

FailedConfiguration

dunedaq::FailedConfiguration

Definition at line 32 of file OpMonPublisher.hpp.

FailedInfoReconstruction

dunedaq::FailedInfoReconstruction

Definition at line 32 of file Utils.hpp.

FailedSend

dunedaq::FailedSend

Definition at line 37 of file DaphneV3Interface.hpp.

FailedSocketInteraction

dunedaq::FailedSocketInteraction

Definition at line 39 of file DaphneV2Interface.hpp.

FailedToSendTPVector

Both frame_count_limit and tp_count_limit were set dunedaq::FailedToSendTPVector

Definition at line 45 of file FDReadoutIssues.hpp.

FileOpenFailed

dunedaq::FileOpenFailed

Definition at line 52 of file HDF5RawDataFile.hpp.

FrameAndTPCountersDisabled

dunedaq::FrameAndTPCountersDisabled

Definition at line 35 of file FDReadoutIssues.hpp.

GeneralDAQModuleIssue

dunedaq::GeneralDAQModuleIssue

Definition at line 72 of file DAQModule.hpp.

GenericConfigurationError

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror dunedaq::GenericConfigurationError

Definition at line 51 of file DataHandlingIssues.hpp.

IncorrectParameters

Cannot create std::string fatal dunedaq::IncorrectParameters

Definition at line 33 of file kafka_opmon_consumer.cxx.

infomsg

dunedaq::infomsg

Definition at line 38 of file TPRequestHandler.hpp.

InitializationError

SourceID[" << sourceid << "] Command daqdataformats::SourceID dunedaq::InitializationError

Definition at line 20 of file FelixIssues.hpp.

initialized

init Command received when already dunedaq::initialized

Definition at line 40 of file DAQModuleManager.hpp.

interrupted

Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility std::string uri The main run loop for command reception was dunedaq::interrupted

Definition at line 81 of file Issues.hpp.

InvalidIPAddress

dunedaq::InvalidIPAddress

Definition at line 26 of file CommonIssues.hpp.

InvalidOperationMode

dunedaq::InvalidOperationMode

Definition at line 74 of file FileDataStoreImpl.hpp.

InvalidQueueFatalError

dunedaq::InvalidQueueFatalError

Definition at line 34 of file TimingIssues.hpp.

InvalidSequenceDigits

dunedaq::InvalidSequenceDigits

Definition at line 41 of file HDF5FileLayout.hpp.

InvalidStateForCommand

dunedaq::InvalidStateForCommand

Definition at line 45 of file Application.hpp.

InvalidStreamID

dunedaq::InvalidStreamID

< Namespace

Type of the Issue

Definition at line 42 of file TPCChannelMap.hpp.

Issue

CTB Buffer std::string descriptor CTB Repeated Word dunedaq::Issue

Definition at line 23 of file CIBModuleIssues.hpp.

LoadDalFailed

dunedaq::LoadDalFailed

Definition at line 12 of file confmodelIssues.hpp.

MissingComponent

dunedaq::MissingComponent

Definition at line 39 of file ConfigurationManager.hpp.

MonitoringFailed

Invalid std::string ip Too many full stream channels Total size_t tot dunedaq::MonitoringFailed

Definition at line 45 of file CommonIssues.hpp.

NameMismatch

dunedaq::NameMismatch

Definition at line 31 of file Utils.hpp.

NameNotFound

dunedaq::NameNotFound

Definition at line 24 of file Issues.hpp.

NotFound

dunedaq::NotFound

Definition at line 55 of file Errors.hpp.

NotificationWrongDestinationError

dunedaq::NotificationWrongDestinationError

Definition at line 23 of file errors_declaration.hpp.

obj

msgpack::object dunedaq::obj = oh.get()

Definition at line 252 of file Serialization.hpp.

out

FELIX Initialization std::string initerror FELIX queue timed dunedaq::out

Definition at line 24 of file FelixIssues.hpp.

parameters

Cannot create std::string fatal Incorrect dunedaq::parameters

Definition at line 33 of file kafka_opmon_consumer.cxx.

ParserOperationQueuePushFailure

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int dunedaq::ParserOperationQueuePushFailure

Definition at line 34 of file FelixIssues.hpp.

PDSInvalidStream

dunedaq::PDSInvalidStream

< Namespace

Type of the Issue

Definition at line 41 of file PDSChannelMap.hpp.

QueueTimeoutError

FELIX Initialization std::string initerror dunedaq::QueueTimeoutError

Definition at line 24 of file FelixIssues.hpp.

QueueTypeMismatch

dunedaq::QueueTypeMismatch

Definition at line 34 of file QueueIssues.hpp.

range

DAC value out of dunedaq::range

Message.

Definition at line 32 of file DACNode.hpp.

ReceiveTimeoutExpired

dunedaq::ReceiveTimeoutExpired

Definition at line 45 of file Receiver.hpp.

requested

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed std::string chunk Invalid FELIX block size and trailer configuration dunedaq::requested

Definition at line 36 of file CommonIssues.hpp.

RunLoopTerminated

Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility std::string uri dunedaq::RunLoopTerminated

Definition at line 80 of file Issues.hpp.

section

Missing configuration dunedaq::section

Message.

Definition at line 38 of file SI534xNode.hpp.

SendTimeoutExpired

dunedaq::SendTimeoutExpired

Definition at line 45 of file Sender.hpp.

SI534xMissingConfigSectionError

dunedaq::SI534xMissingConfigSectionError

< Namespace

Issue class name

Definition at line 37 of file SI534xNode.hpp.

SI534xRegWriteRetry

Missing configuration std::string tag dunedaq::SI534xRegWriteRetry

< Namespace

Issue class name

Definition at line 47 of file SI534xNode.hpp.

size

FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk dunedaq::size

Definition at line 30 of file FelixIssues.hpp.

sourceid

Cannot add TPSet with dunedaq::sourceid

Initial value:

                            ="
<< tpset_source_id << "

Definition at line 40 of file TPBundleHandler.hpp.

start_time

Cannot add TPSet with dunedaq::start_time

Initial value:

=" << tpset_start_time
         << " to bundle

Definition at line 41 of file TPBundleHandler.hpp.

TardyTPSetReceived

Cannot add TPSet with because another TPSet with these values already size_t dunedaq::TardyTPSetReceived

Definition at line 45 of file TPBundleHandler.hpp.

TimeoutExpired

dunedaq::TimeoutExpired

Definition at line 26 of file CommonIssues.hpp.

TimeSyncTransmissionFailed

SourceID[" << sourceid << "] Command daqdataformats::SourceID Readout Initialization std::string initerror Configuration std::string conferror Configuration std::string conferror dunedaq::TimeSyncTransmissionFailed

Definition at line 66 of file DataHandlingIssues.hpp.

TooManyChannels

Invalid std::string ip dunedaq::TooManyChannels

Definition at line 35 of file CommonIssues.hpp.

TPHandlerMsg

dunedaq::TPHandlerMsg

Definition at line 38 of file TPRequestHandler.hpp.

TriggerInhibited

dunedaq::TriggerInhibited

Definition at line 35 of file Issues.hpp.

UnexpectedChunk

FELIX Initialization std::string initerror FELIX queue timed std::string queuename dunedaq::UnexpectedChunk

Definition at line 29 of file FelixIssues.hpp.

UnexpectedStreamID

dunedaq::UnexpectedStreamID

Definition at line 45 of file IfaceWrapper.hpp.

UnknownSerializationTypeByte

dunedaq::UnknownSerializationTypeByte

Definition at line 149 of file Serialization.hpp.

UnsupportedUri

dunedaq::UnsupportedUri

Definition at line 28 of file Issues.hpp.

URI

Unsupported dunedaq::URI

Definition at line 28 of file Issues.hpp.

uri

Unsupported std::string uri Execution of command std::string error Failed to create CommandFacility dunedaq::uri

Definition at line 71 of file Issues.hpp.

v

default char dunedaq::v[0]

Definition at line 261 of file Serialization.hpp.