579 lines
16 KiB
C++
579 lines
16 KiB
C++
// ------------------------------------------------------------------------- //
|
|
/*
|
|
for reference of the tdm data model, see
|
|
|
|
https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_headerfile/
|
|
https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_datamodel/
|
|
*/
|
|
|
|
#ifndef TDM_DATAMODEL
|
|
#define TDM_DATAMODEL
|
|
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <vector>
|
|
#include <chrono>
|
|
#include <sstream>
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// format output of info strings for terminal and file table
|
|
|
|
class format
|
|
{
|
|
|
|
private:
|
|
|
|
unsigned int width_;
|
|
bool tabular_;
|
|
bool header_;
|
|
char sep_;
|
|
std::vector<std::pair<std::string,std::string>> columns_;
|
|
|
|
public:
|
|
|
|
format(int width = 25, bool tabular = false, bool header = false, char sep = ' '):
|
|
width_(width), tabular_(tabular), header_(header), sep_(sep)
|
|
{
|
|
|
|
}
|
|
|
|
void set_width(int width)
|
|
{
|
|
width_ = width;
|
|
}
|
|
|
|
void set_tabular(bool tabular)
|
|
{
|
|
tabular_ = tabular;
|
|
}
|
|
|
|
void set_header(bool header)
|
|
{
|
|
header_ = header;
|
|
}
|
|
|
|
void set_sep(char sep)
|
|
{
|
|
sep_ = sep;
|
|
}
|
|
|
|
void set_columns(std::vector<std::pair<std::string,std::string>> columns)
|
|
{
|
|
columns_ = columns;
|
|
}
|
|
|
|
std::string get_info()
|
|
{
|
|
std::stringstream ss;
|
|
|
|
for ( std::vector<std::pair<std::string,std::string>>::iterator it = columns_.begin();
|
|
it != columns_.end(); ++it )
|
|
{
|
|
if ( tabular_ )
|
|
{
|
|
// header or body of table
|
|
std::string entry = header_? it->first : it->second;
|
|
|
|
// make broad aligned columns for human reader
|
|
if ( sep_ == ' ' )
|
|
{
|
|
entry = entry.size() > width_-2 ? entry.substr(0,width_-2) : entry;
|
|
// if ( it == columns_.begin() && !header_ ) ss<<" ";
|
|
ss<<std::setw(width_)<<std::left<<entry;
|
|
}
|
|
// make compressed csv like columns
|
|
else
|
|
{
|
|
ss<<entry;
|
|
if ( std::next(it,1) != columns_.end() ) ss<<sep_;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ss<<std::setw(width_)<<std::left<<(it->first+std::string(":"))<<it->second<<"\n";
|
|
}
|
|
}
|
|
|
|
return ss.str();
|
|
}
|
|
};
|
|
|
|
// define default formatter
|
|
static format defformat(25,false,false,',');
|
|
|
|
// join a list of strings
|
|
static std::string join_strings(std::vector<std::string> &thestring, const char* sep = " ")
|
|
{
|
|
std::string joined;
|
|
for ( std::vector<std::string>::iterator it = thestring.begin();
|
|
it != thestring.end(); ++it )
|
|
{
|
|
joined += std::next(it,1) != thestring.end() ? ( *it + std::string(sep) ) : *it;
|
|
}
|
|
|
|
return joined;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// tdm datatypes
|
|
|
|
// https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_header_tdx_data/
|
|
|
|
// define mapping of C++ supported datatypes to tdm datatypes
|
|
|
|
// define mapping of locally supported datatypes to tdm datatypes
|
|
// typedef short int eInt16Usi;
|
|
// typedef int eInt32Usi;
|
|
// typedef unsigned char eUInt8Usi;
|
|
// typedef unsigned short int eUInt16Usi;
|
|
// typedef unsigned int eUInt32Usi;
|
|
// typedef float eFloat32Usi;
|
|
// typedef double eFloat64Usi;
|
|
|
|
// enum class tdmdatatype {
|
|
// eInt16Usi,
|
|
// eInt32Usi,
|
|
// eUInt8Usi,
|
|
// eUInt16Usi,
|
|
// eUInt32Usi,
|
|
// eFloat32Usi,
|
|
// eFloat64Usi
|
|
// };
|
|
|
|
// base class for all tdm datatypes
|
|
class tdmdatatype
|
|
{
|
|
protected:
|
|
short int sint16_;
|
|
int sint32_;
|
|
unsigned char uint8_;
|
|
unsigned short int uint16_;
|
|
unsigned int uint32_;
|
|
float float32_;
|
|
double float64_;
|
|
public:
|
|
tdmdatatype(): sint16_(0), sint32_(0),
|
|
uint8_(0), uint16_(0), uint32_(0),
|
|
float32_(0.0), float64_(0.0) {};
|
|
friend std::ostream& operator<<(std::ostream& out, const tdmdatatype& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
virtual std::ostream& print(std::ostream& out) const
|
|
{
|
|
out<<"tdmdatatype";
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eInt16Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eInt16Usi() { }
|
|
eInt16Usi(short int num) { sint16_ = num; }
|
|
// eInt16Usi& operator=(const eInt16Usi &num)
|
|
// {
|
|
// // self-assignment check
|
|
// if ( this != &num)
|
|
// {
|
|
// this->sint16_ = num.sint16_;
|
|
// }
|
|
// return *this;
|
|
// }
|
|
friend std::ostream& operator<<(std::ostream& out, const eInt16Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<sint16_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eInt32Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eInt32Usi() { }
|
|
eInt32Usi(int num) { sint32_ = num; }
|
|
friend std::ostream& operator<<(std::ostream& out, const eInt32Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<sint32_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eUInt8Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eUInt8Usi() { }
|
|
eUInt8Usi(int num) { uint8_ = num; }
|
|
friend std::ostream& operator<<(std::ostream& out, const eUInt8Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<uint8_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eUInt16Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eUInt16Usi() { }
|
|
eUInt16Usi(int num) { uint16_ = num; }
|
|
friend std::ostream& operator<<(std::ostream& out, const eUInt16Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<uint16_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eUInt32Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eUInt32Usi() { }
|
|
eUInt32Usi(int num) { uint32_ = num; }
|
|
friend std::ostream& operator<<(std::ostream& out, const eUInt32Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<uint32_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eFloat32Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eFloat32Usi() { }
|
|
eFloat32Usi(int num) { float32_ = num; }
|
|
friend std::ostream& operator<<(std::ostream& out, const eFloat32Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<float32_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
class eFloat64Usi: public tdmdatatype
|
|
{
|
|
public:
|
|
eFloat64Usi() { }
|
|
eFloat64Usi(int num) { float64_ = num; }
|
|
friend std::ostream& operator<<(std::ostream& out, const eFloat64Usi& num)
|
|
{
|
|
return num.print(out);
|
|
}
|
|
std::ostream& print(std::ostream& out) const override
|
|
{
|
|
out<<float64_;
|
|
return out;
|
|
}
|
|
};
|
|
|
|
struct tdm_datatype {
|
|
|
|
std::string name_;
|
|
std::string channel_datatype_;
|
|
int numeric_;
|
|
std::string value_sequence_;
|
|
int size_;
|
|
std::string description_;
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns( { std::make_pair("name",name_),
|
|
std::make_pair("channel_datatype",channel_datatype_),
|
|
std::make_pair("name",name_),
|
|
std::make_pair("value_sequence",value_sequence_),
|
|
std::make_pair("size",std::to_string(size_)),
|
|
std::make_pair("description",description_) } );
|
|
|
|
return formatter.get_info();
|
|
}
|
|
};
|
|
|
|
const std::vector<tdm_datatype> tdm_datatypes = {
|
|
|
|
{"eInt16Usi","DT_SHORT",2,"short_sequence",2,"signed 16 bit integer"},
|
|
{"eInt32Usi","DT_LONG",6,"long_sequence",4,"signed 32 bit integer"},
|
|
|
|
{"eUInt8Usi","DT_BYTE",5,"byte_sequence",1,"unsigned 8 bit integer"},
|
|
{"eUInt16Usi","DT_SHORT",2,"short_sequence",2,"unsigned 16 bit integer"},
|
|
{"eUInt32Usi","DT_LONG",6,"long_sequence",4,"unsigned 32 bit integer"},
|
|
|
|
{"eFloat32Usi","DT_FLOAT",3,"float_sequence",4,"32 bit float"},
|
|
{"eFloat64Usi","DT_DOUBLE",7,"double_sequence",8,"64 bit double"},
|
|
|
|
{"eStringUsi","DT_STRING",1,"string_sequence",0,"text"}
|
|
|
|
};
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// block of data
|
|
|
|
struct block {
|
|
|
|
std::string id_;
|
|
unsigned long int byte_offset_;
|
|
unsigned long int length_;
|
|
unsigned long int block_offset_, block_size_;
|
|
std::string value_type_;
|
|
|
|
block () {
|
|
id_ = std::string("");
|
|
byte_offset_ = 0;
|
|
length_ = 0;
|
|
block_offset_ = 0;
|
|
block_size_ = 0;
|
|
value_type_ = std::string("");
|
|
}
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns({ std::make_pair("block-id",id_),
|
|
std::make_pair("byteOffset",std::to_string(byte_offset_)),
|
|
std::make_pair("length",std::to_string(length_)),
|
|
std::make_pair("blockOffset",std::to_string(block_offset_)),
|
|
std::make_pair("blockSize",std::to_string(block_size_)),
|
|
std::make_pair("valueType",value_type_) });
|
|
|
|
return formatter.get_info();
|
|
}
|
|
|
|
};
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// tdm_root
|
|
|
|
struct tdm_root {
|
|
|
|
std::string id_;
|
|
std::string name_;
|
|
std::string description_;
|
|
std::string title_;
|
|
std::string author_;
|
|
|
|
std::string timestamp_;
|
|
// std::chrono::time_point timepoint_; // from string 2008-05-06T17:20:12.65074539184570313
|
|
|
|
// std::stringstream ss;
|
|
// ss<<"2008-05-06T17:20:12.65074539184570313";
|
|
// std::cout<<ss.str()<<"\n";
|
|
//
|
|
// std::chrono::time_point start = std::chrono::high_resolution_clock::now();
|
|
// std::time_t tt = std::chrono::system_clock::to_time_t(start);
|
|
// // https://en.cppreference.com/w/cpp/io/manip/put_time
|
|
// std::cout<<std::put_time(std::localtime(&tt),"%Y-%m-%dT%H:%M:%S")<<"\n";// "%F %T")<<"\n";
|
|
//
|
|
// // std::tm ts;
|
|
// // // https://en.cppreference.com/w/cpp/io/manip/get_time
|
|
// // std::get_time(&ts, "%Y-%m-%dT%H:%M:%S");
|
|
// // auto tp = std::chrono::system_clock::from_time_t(std::mktime(&ts));
|
|
// // std::time_t tt = std::chrono::system_clock::to_time_t(tp);
|
|
// // // std::cout<<tt.strftime("%Y")<<"\n";
|
|
// // std::cout<<ctime(&tt)<<"\n";
|
|
|
|
std::vector<std::string> channelgroups_;
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns({ std::make_pair("root-id",id_),
|
|
std::make_pair("name",name_),
|
|
std::make_pair("description",description_),
|
|
std::make_pair("title",title_),
|
|
std::make_pair("author",author_),
|
|
std::make_pair("timestamp",timestamp_),
|
|
std::make_pair("channelgroups",join_strings(channelgroups_)) });
|
|
|
|
return formatter.get_info();
|
|
}
|
|
|
|
};
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// tdm_channelgroup
|
|
|
|
// https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_metadata_chngroup/
|
|
|
|
struct tdm_channelgroup {
|
|
|
|
std::string id_;
|
|
std::string name_;
|
|
std::string description_;
|
|
std::string root_;
|
|
std::vector<std::string> channels_; // referenced by id
|
|
std::vector<std::string> submatrices_;
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns({ std::make_pair("group-id",id_),
|
|
std::make_pair("name",name_),
|
|
std::make_pair("description",description_),
|
|
std::make_pair("root",root_),
|
|
std::make_pair("channels",join_strings(channels_)),
|
|
std::make_pair("submatrices",join_strings(submatrices_)) });
|
|
|
|
return formatter.get_info();
|
|
}
|
|
|
|
};
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// tdm_channel
|
|
|
|
// https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_metadata_channel/
|
|
|
|
// waveform channel type
|
|
enum class wf_time_pref_type {
|
|
absolute,
|
|
relative
|
|
};
|
|
|
|
// additional elements for wave form channels (encoded as attributes in
|
|
// <instance_attributes> of <tdm_channel>)
|
|
// https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_tdxdata_waveform/
|
|
struct waveform_channel {
|
|
std::string wf_xname_;
|
|
std::string wf_xunit_string_;
|
|
std::string wf_start_time_;
|
|
double wf_start_offset_;
|
|
double wf_increment_;
|
|
unsigned long wf_samples_;
|
|
wf_time_pref_type wf_time_pref;
|
|
};
|
|
|
|
struct tdm_channel {
|
|
|
|
std::string id_;
|
|
std::string name_;
|
|
std::string description_;
|
|
std::string unit_string_;
|
|
std::string datatype_;
|
|
double minimum_, maximum_;
|
|
std::string group_;
|
|
std::vector<std::string> local_columns_;
|
|
|
|
// TODO
|
|
waveform_channel wf_channel_;
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns({ std::make_pair("channel-id",id_),
|
|
std::make_pair("name",name_),
|
|
std::make_pair("description",description_),
|
|
std::make_pair("unit_string",unit_string_),
|
|
std::make_pair("datatype",datatype_),
|
|
std::make_pair("minimum",std::to_string(minimum_)),
|
|
std::make_pair("maximum",std::to_string(maximum_)),
|
|
std::make_pair("group",group_),
|
|
std::make_pair("local_columns",join_strings(local_columns_)) });
|
|
|
|
return formatter.get_info();
|
|
}
|
|
|
|
};
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// submatrix
|
|
|
|
// https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_tdxdata_submatrix/
|
|
|
|
struct submatrix {
|
|
|
|
std::string id_;
|
|
std::string name_;
|
|
std::string description_;
|
|
std::string measurement_; // -> tdm_channelgroup id
|
|
std::vector<std::string> local_columns_; // -> list of type "localcolumn"
|
|
unsigned long int number_of_rows_; // -> number of values in channels
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns({ std::make_pair("submatrix-id",id_),
|
|
std::make_pair("name",name_),
|
|
std::make_pair("description",description_),
|
|
std::make_pair("measurement",measurement_),
|
|
std::make_pair("local_columns",join_strings(local_columns_)),
|
|
std::make_pair("number_of_rows",std::to_string(number_of_rows_)) });
|
|
|
|
return formatter.get_info();
|
|
}
|
|
|
|
};
|
|
|
|
// -------------------------------------------------------------------------- //
|
|
// localcolumn
|
|
|
|
enum class representation {
|
|
explicit_, // !! explicit is C++ keyword!!
|
|
implicit_linear_, // datatype is always DT_DOUBLE, no <value_sequence> for implicit_linear_!!
|
|
raw_linear_ // datatype is always DT_DOUBLE
|
|
};
|
|
|
|
// https://zone.ni.com/reference/de-XX/help/370858P-0113/tdmdatamodel/tdmdatamodel/tdm_tdxdata_localcolumn/
|
|
|
|
struct localcolumn {
|
|
|
|
std::string id_;
|
|
std::string name_;
|
|
std::string description_;
|
|
std::string measurement_quantity_; // -> tdm_channel
|
|
std::string submatrix_;
|
|
|
|
unsigned long int global_flag_;
|
|
unsigned long int independent_;
|
|
|
|
double minimum_, maximum_;
|
|
// representation sequence_representation_;
|
|
std::string sequence_representation_;
|
|
std::vector<double> generation_parameters_; // { offset, factor }
|
|
|
|
std::string values_; // -> refers to usi:data -> _sequence
|
|
std::string external_id_;
|
|
|
|
const std::string get_info() { return get_info(defformat); }
|
|
const std::string get_info(format& formatter)
|
|
{
|
|
formatter.set_columns({ std::make_pair("localcolumn-id",id_),
|
|
std::make_pair("name",name_),
|
|
std::make_pair("description",description_),
|
|
std::make_pair("measurement_quantity",measurement_quantity_),
|
|
std::make_pair("submatrix_",submatrix_),
|
|
std::make_pair("minimum",std::to_string(minimum_)),
|
|
std::make_pair("maximum",std::to_string(maximum_)),
|
|
std::make_pair("sequence_representation",sequence_representation_),
|
|
std::make_pair("values",values_),
|
|
std::make_pair("external",external_id_) });
|
|
|
|
return formatter.get_info();
|
|
}
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
// -------------------------------------------------------------------------- //
|