mirror of
https://github.com/cjcliffe/CubicSDR.git
synced 2025-09-11 19:27:47 -04:00
DataTree cleanup/refactor..
This commit is contained in:
Charles J. Cliffe
parent
cf2b11f496
commit
36ff762d3a
@ -37,6 +37,7 @@ DataElement::DataElement() {
|
||||
data_type = DATA_NULL;
|
||||
data_val = NULL;
|
||||
data_size = 0;
|
||||
unit_size = 0;
|
||||
}
|
||||
|
||||
DataElement::~DataElement() {
|
||||
@ -59,75 +60,30 @@ long DataElement::getDataSize() {
|
||||
return data_size;
|
||||
}
|
||||
|
||||
//void DataElement::set(const bool &bool_in)
|
||||
//{
|
||||
// data_type = DATA_BOOL;
|
||||
// data_init(sizeof(bool));
|
||||
// memcpy(data_val,&bool_in,data_size);
|
||||
//}
|
||||
|
||||
void DataElement::set(const char& char_in) {
|
||||
data_type = DATA_CHAR;
|
||||
data_init(sizeof(char));
|
||||
memcpy(data_val, &char_in, data_size);
|
||||
int DataElement::getUnitSize() {
|
||||
return unit_size;
|
||||
}
|
||||
|
||||
void DataElement::set(const unsigned char& uchar_in) {
|
||||
data_type = DATA_UCHAR;
|
||||
data_init(sizeof(unsigned char));
|
||||
memcpy(data_val, &uchar_in, data_size);
|
||||
#define DataElementSetNumericDef(enumtype, datatype) void DataElement::set(const datatype& val_in) { \
|
||||
data_type = enumtype; \
|
||||
unit_size = sizeof(char); \
|
||||
data_init(unit_size); \
|
||||
memcpy(data_val, &val_in, data_size); \
|
||||
}
|
||||
|
||||
void DataElement::set(const unsigned int& uint_in) {
|
||||
data_type = DATA_UINT;
|
||||
data_init(sizeof(unsigned int));
|
||||
memcpy(data_val, &uint_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const unsigned long & ulong_in) {
|
||||
data_type = DATA_ULONG;
|
||||
data_init(sizeof(unsigned long));
|
||||
memcpy(data_val, &ulong_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const long long & llong_in) {
|
||||
data_type = DATA_ULONG;
|
||||
data_init(sizeof(long long));
|
||||
memcpy(data_val, &llong_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const long double& ldouble_in) {
|
||||
data_type = DATA_LONGDOUBLE;
|
||||
data_init(sizeof(long double));
|
||||
memcpy(data_val, &ldouble_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const int &int_in) {
|
||||
data_type = DATA_INT;
|
||||
data_init(sizeof(int));
|
||||
memcpy(data_val, &int_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const long &long_in) {
|
||||
data_type = DATA_LONG;
|
||||
data_init(sizeof(long));
|
||||
memcpy(data_val, &long_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const float &float_in) {
|
||||
data_type = DATA_FLOAT;
|
||||
data_init(sizeof(float));
|
||||
memcpy(data_val, &float_in, data_size);
|
||||
}
|
||||
|
||||
void DataElement::set(const double &double_in) {
|
||||
data_type = DATA_DOUBLE;
|
||||
data_init(sizeof(double));
|
||||
memcpy(data_val, &double_in, data_size);
|
||||
}
|
||||
DataElementSetNumericDef(DATA_CHAR, char)
|
||||
DataElementSetNumericDef(DATA_UCHAR, unsigned char)
|
||||
DataElementSetNumericDef(DATA_INT, int)
|
||||
DataElementSetNumericDef(DATA_UINT, unsigned int)
|
||||
DataElementSetNumericDef(DATA_LONG, long)
|
||||
DataElementSetNumericDef(DATA_ULONG, unsigned long)
|
||||
DataElementSetNumericDef(DATA_LONGLONG, long long)
|
||||
DataElementSetNumericDef(DATA_FLOAT, float)
|
||||
DataElementSetNumericDef(DATA_DOUBLE, double)
|
||||
DataElementSetNumericDef(DATA_LONGDOUBLE, long double)
|
||||
|
||||
void DataElement::set(const char *data_in, long size_in) {
|
||||
data_type = DATA_FLOAT;
|
||||
data_type = DATA_VOID;
|
||||
data_init(size_in);
|
||||
memcpy(data_val, data_in, data_size);
|
||||
}
|
||||
@ -182,312 +138,62 @@ void DataElement::set(std::set<string> &strset_in) {
|
||||
set(tmp_vect);
|
||||
}
|
||||
|
||||
void DataElement::set(vector<char>& charvect_in) {
|
||||
long ptr;
|
||||
char temp_char;
|
||||
|
||||
data_type = DATA_CHAR_VECTOR;
|
||||
|
||||
data_init(sizeof(char) * charvect_in.size());
|
||||
|
||||
vector<char>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = charvect_in.begin(); i != charvect_in.end(); i++) {
|
||||
temp_char = *i;
|
||||
memcpy(data_val + ptr, &temp_char, sizeof(char));
|
||||
ptr += sizeof(char);
|
||||
}
|
||||
#define DataElementSetNumericVectorDef(enumtype, datatype) void DataElement::set(vector<datatype>& val_in) { \
|
||||
data_type = enumtype; \
|
||||
unit_size = sizeof(char); \
|
||||
data_init(unit_size * val_in.size()); \
|
||||
memcpy(data_val, &val_in[0], data_size); \
|
||||
}
|
||||
|
||||
void DataElement::set(vector<unsigned char>& ucharvect_in) {
|
||||
long ptr;
|
||||
unsigned char temp_uchar;
|
||||
DataElementSetNumericVectorDef(DATA_CHAR_VECTOR, char)
|
||||
DataElementSetNumericVectorDef(DATA_UCHAR_VECTOR, unsigned char)
|
||||
DataElementSetNumericVectorDef(DATA_INT_VECTOR, int)
|
||||
DataElementSetNumericVectorDef(DATA_UINT_VECTOR, unsigned int)
|
||||
DataElementSetNumericVectorDef(DATA_LONG_VECTOR, long)
|
||||
DataElementSetNumericVectorDef(DATA_ULONG_VECTOR, unsigned long)
|
||||
DataElementSetNumericVectorDef(DATA_LONGLONG_VECTOR, long long)
|
||||
DataElementSetNumericVectorDef(DATA_FLOAT_VECTOR, float)
|
||||
DataElementSetNumericVectorDef(DATA_DOUBLE_VECTOR, double)
|
||||
DataElementSetNumericVectorDef(DATA_LONGDOUBLE_VECTOR, long double)
|
||||
|
||||
data_type = DATA_UCHAR_VECTOR;
|
||||
|
||||
data_init(sizeof(unsigned char) * ucharvect_in.size());
|
||||
|
||||
vector<unsigned char>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = ucharvect_in.begin(); i != ucharvect_in.end(); i++) {
|
||||
temp_uchar = *i;
|
||||
memcpy(data_val + ptr, &temp_uchar, sizeof(unsigned char));
|
||||
ptr += sizeof(unsigned char);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<unsigned int>& uintvect_in) {
|
||||
long ptr;
|
||||
unsigned int temp_uint;
|
||||
|
||||
data_type = DATA_UCHAR_VECTOR;
|
||||
|
||||
data_init(sizeof(unsigned int) * uintvect_in.size());
|
||||
|
||||
vector<unsigned int>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = uintvect_in.begin(); i != uintvect_in.end(); i++) {
|
||||
temp_uint = *i;
|
||||
memcpy(data_val + ptr, &temp_uint, sizeof(unsigned int));
|
||||
ptr += sizeof(unsigned int);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<unsigned long>& ulongvect_in) {
|
||||
long ptr;
|
||||
unsigned long temp_ulong;
|
||||
|
||||
data_type = DATA_ULONG_VECTOR;
|
||||
|
||||
data_init(sizeof(unsigned long) * ulongvect_in.size());
|
||||
|
||||
vector<unsigned long>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = ulongvect_in.begin(); i != ulongvect_in.end(); i++) {
|
||||
temp_ulong = *i;
|
||||
memcpy(data_val + ptr, &temp_ulong, sizeof(unsigned long));
|
||||
ptr += sizeof(unsigned long);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<long long>& llongvect_in) {
|
||||
long ptr;
|
||||
long long temp_llong;
|
||||
|
||||
data_type = DATA_CHAR_VECTOR;
|
||||
|
||||
data_init(sizeof(long long) * llongvect_in.size());
|
||||
|
||||
vector<long long>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = llongvect_in.begin(); i != llongvect_in.end(); i++) {
|
||||
temp_llong = *i;
|
||||
memcpy(data_val + ptr, &temp_llong, sizeof(long long));
|
||||
ptr += sizeof(long long);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<long double>& ldoublevect_in) {
|
||||
long ptr;
|
||||
long double temp_ldouble;
|
||||
|
||||
data_type = DATA_CHAR_VECTOR;
|
||||
|
||||
data_init(sizeof(long double) * ldoublevect_in.size());
|
||||
|
||||
vector<long double>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = ldoublevect_in.begin(); i != ldoublevect_in.end(); i++) {
|
||||
temp_ldouble = *i;
|
||||
memcpy(data_val + ptr, &temp_ldouble, sizeof(long double));
|
||||
ptr += sizeof(long double);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<int> &intvect_in) {
|
||||
long ptr;
|
||||
int temp_int;
|
||||
|
||||
data_type = DATA_INT_VECTOR;
|
||||
|
||||
data_init(sizeof(int) * intvect_in.size());
|
||||
|
||||
vector<int>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = intvect_in.begin(); i != intvect_in.end(); i++) {
|
||||
temp_int = *i;
|
||||
memcpy(data_val + ptr, &temp_int, sizeof(int));
|
||||
ptr += sizeof(int);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<long> &longvect_in) {
|
||||
long ptr;
|
||||
long temp_long;
|
||||
|
||||
data_type = DATA_LONG_VECTOR;
|
||||
|
||||
data_init(sizeof(long) * longvect_in.size());
|
||||
|
||||
vector<long>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = longvect_in.begin(); i != longvect_in.end(); i++) {
|
||||
temp_long = *i;
|
||||
memcpy(data_val + ptr, &temp_long, sizeof(long));
|
||||
ptr += sizeof(long);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::set(vector<float> &floatvect_in) {
|
||||
long ptr;
|
||||
float temp_float;
|
||||
|
||||
data_type = DATA_FLOAT_VECTOR;
|
||||
|
||||
data_init(sizeof(float) * floatvect_in.size());
|
||||
|
||||
// vector<float>::iterator i;
|
||||
//
|
||||
// ptr = 0;
|
||||
//
|
||||
// for (i = floatvect_in.begin(); i != floatvect_in.end(); i++)
|
||||
// {
|
||||
// temp_float = *i;
|
||||
// memcpy(data_val+ptr, &temp_float, sizeof(float));
|
||||
// ptr += sizeof(float);
|
||||
// }
|
||||
|
||||
memcpy(data_val, &floatvect_in[0], sizeof(float) * floatvect_in.size());
|
||||
}
|
||||
|
||||
void DataElement::set(vector<double> &doublevect_in) {
|
||||
long ptr;
|
||||
double temp_double;
|
||||
|
||||
data_type = DATA_DOUBLE_VECTOR;
|
||||
|
||||
data_init(sizeof(double) * doublevect_in.size());
|
||||
|
||||
vector<double>::iterator i;
|
||||
|
||||
ptr = 0;
|
||||
|
||||
for (i = doublevect_in.begin(); i != doublevect_in.end(); i++) {
|
||||
temp_double = *i;
|
||||
memcpy(data_val + ptr, &temp_double, sizeof(double));
|
||||
ptr += sizeof(double);
|
||||
}
|
||||
}
|
||||
|
||||
#define DataElementGetNumericDef(enumtype, datatype) void DataElement::get(datatype& val_out) throw (DataTypeMismatchException) { \
|
||||
#define DataElementGetNumericDef(enumtype, datatype, ...) void DataElement::get(datatype& val_out) throw (DataTypeMismatchException) { \
|
||||
if (!data_type) \
|
||||
return; \
|
||||
int _compat[] = {__VA_ARGS__}; \
|
||||
if (data_type != enumtype) { \
|
||||
bool compat = false; \
|
||||
for (int i = 0; i < sizeof(_compat)/sizeof(int); i++) { \
|
||||
if (_compat[i] == data_type) { \
|
||||
compat = true; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
if (!compat) { \
|
||||
throw(new DataTypeMismatchException("Type mismatch, element type " #enumtype " is not compatible with a " #datatype)); \
|
||||
} \
|
||||
if (sizeof(datatype) < data_size) { \
|
||||
std::cout << "Warning, data type mismatch requested size for '" << #datatype << "(" << sizeof(datatype) << ")' < data size '" << data_size << "'; possible loss of data."; \
|
||||
} \
|
||||
memset(&val_out, 0, sizeof(datatype)); \
|
||||
memcpy(&val_out, data_val, (sizeof(datatype) < data_size) ? sizeof(datatype) : data_size); \
|
||||
return; \
|
||||
} \
|
||||
memcpy(&val_out, data_val, data_size); \
|
||||
}
|
||||
|
||||
DataElementGetNumericDef(DATA_CHAR, char)
|
||||
DataElementGetNumericDef(DATA_UCHAR, unsigned char)
|
||||
DataElementGetNumericDef(DATA_UINT, unsigned int)
|
||||
DataElementGetNumericDef(DATA_ULONG, unsigned long)
|
||||
DataElementGetNumericDef(DATA_LONGLONG, long long)
|
||||
DataElementGetNumericDef(DATA_LONGDOUBLE, long double)
|
||||
DataElementGetNumericDef(DATA_INT, int)
|
||||
DataElementGetNumericDef(DATA_LONG, long)
|
||||
DataElementGetNumericDef(DATA_FLOAT, float)
|
||||
DataElementGetNumericDef(DATA_DOUBLE, double)
|
||||
|
||||
////void DataElement::get(char& char_in) throw (DataTypeMismatchException) {
|
||||
////if (!data_type)
|
||||
//// return;
|
||||
////if (data_type != DATA_CHAR)
|
||||
//// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
////
|
||||
////memcpy(&char_in, data_val, data_size);
|
||||
////}
|
||||
//
|
||||
////void DataElement::get(unsigned char& uchar_in) throw (DataTypeMismatchException) {
|
||||
////if (!data_type)
|
||||
//// return;
|
||||
////if (data_type != DATA_UCHAR)
|
||||
//// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
////
|
||||
////memcpy(&uchar_in, data_val, data_size);
|
||||
////}
|
||||
//
|
||||
////void DataElement::get(unsigned int& uint_in) throw (DataTypeMismatchException) {
|
||||
////if (!data_type)
|
||||
//// return;
|
||||
////if (data_type != DATA_UINT)
|
||||
//// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
////
|
||||
////memcpy(&uint_in, data_val, data_size);
|
||||
////}
|
||||
//
|
||||
////void DataElement::get(unsigned long & ulong_in) throw (DataTypeMismatchException) {
|
||||
////if (!data_type)
|
||||
//// return;
|
||||
////if (data_type != DATA_ULONG)
|
||||
//// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
////
|
||||
////memcpy(&ulong_in, data_val, data_size);
|
||||
////}
|
||||
//
|
||||
////void DataElement::get(long long & long_in) throw (DataTypeMismatchException) {
|
||||
////if (!data_type)
|
||||
//// return;
|
||||
////if (data_type != DATA_LONG)
|
||||
//// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
////
|
||||
////memcpy(&long_in, data_val, data_size);
|
||||
////}
|
||||
//
|
||||
////void DataElement::get(long double& ldouble_in) throw (DataTypeMismatchException) {
|
||||
////if (!data_type)
|
||||
//// return;
|
||||
////if (data_type != DATA_LONGDOUBLE)
|
||||
//// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
////
|
||||
////memcpy(&ldouble_in, data_val, data_size);
|
||||
////}
|
||||
//
|
||||
//void DataElement::get(int &int_in) throw (DataTypeMismatchException) {
|
||||
//if (!data_type)
|
||||
// return;
|
||||
//if (data_type != DATA_INT)
|
||||
// throw(new DataTypeMismatchException("Type mismatch, not a INT"));
|
||||
//
|
||||
//memcpy(&int_in, data_val, data_size);
|
||||
//}
|
||||
//
|
||||
//void DataElement::get(long &long_in) throw (DataTypeMismatchException) {
|
||||
//if (!data_type)
|
||||
// return;
|
||||
//if (data_type != DATA_LONG)
|
||||
// throw(new DataTypeMismatchException("Type mismatch, not a LONG"));
|
||||
//
|
||||
//memcpy(&long_in, data_val, data_size);
|
||||
//}
|
||||
//
|
||||
//void DataElement::get(float &float_in) throw (DataTypeMismatchException) {
|
||||
//if (!data_type)
|
||||
// return;
|
||||
//if (data_type != DATA_FLOAT)
|
||||
// throw(new DataTypeMismatchException("Type mismatch, not a FLOAT"));
|
||||
//
|
||||
//memcpy(&float_in, data_val, data_size);
|
||||
//}
|
||||
//
|
||||
//void DataElement::get(double &double_in) throw (DataTypeMismatchException) {
|
||||
//if (!data_type)
|
||||
// return;
|
||||
//if (data_type != DATA_DOUBLE)
|
||||
// throw(new DataTypeMismatchException("Type mismatch, not a DOUBLE"));
|
||||
//
|
||||
//memcpy(&double_in, data_val, data_size);
|
||||
//}
|
||||
DataElementGetNumericDef(DATA_CHAR, char, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_UCHAR, unsigned char, DATA_CHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_UINT, unsigned int, DATA_CHAR, DATA_UCHAR, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_ULONG, unsigned long, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_LONGLONG, long long, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGDOUBLE, DATA_INT, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_LONGDOUBLE, long double, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_INT, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_INT, int, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_LONG, long, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT)
|
||||
DataElementGetNumericDef(DATA_FLOAT, float, DATA_DOUBLE, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT,
|
||||
DATA_LONG)
|
||||
DataElementGetNumericDef(DATA_DOUBLE, double, DATA_FLOAT, DATA_CHAR, DATA_UCHAR, DATA_UINT, DATA_ULONG, DATA_LONGLONG, DATA_LONGDOUBLE, DATA_INT,
|
||||
DATA_LONG)
|
||||
|
||||
void DataElement::get(char **data_in) throw (DataTypeMismatchException) {
|
||||
if (data_type != DATA_VOID)
|
||||
@ -545,196 +251,54 @@ for (i = tmp_vect.begin(); i != tmp_vect.end(); i++) {
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<char>& charvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_CHAR_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
char temp_char;
|
||||
while (ptr < data_size) {
|
||||
temp_char = 0;
|
||||
memcpy(&temp_char, data_val + ptr, sizeof(char));
|
||||
charvect_in.push_back(temp_char);
|
||||
ptr += sizeof(char);
|
||||
}
|
||||
#define DataElementGetNumericVectorDef(enumtype, datatype, ...) void DataElement::get(vector<datatype>& val_out) throw (DataTypeMismatchException) { \
|
||||
if (!data_type || !unit_size) return; \
|
||||
if (data_type != enumtype) { \
|
||||
int _compat[] = {__VA_ARGS__}; \
|
||||
bool compat = false; \
|
||||
for (int i = 0; i < sizeof(_compat)/sizeof(int); i++) { \
|
||||
if (_compat[i] == data_type) { \
|
||||
compat = true; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
if (!compat) { \
|
||||
throw(new DataTypeMismatchException("Type mismatch, element type is not compatible with a " #datatype)); \
|
||||
} \
|
||||
if (sizeof(datatype) < unit_size) { \
|
||||
std::cout << "Warning, data type mismatch for vector<" #datatype ">; " #datatype " size " << sizeof(datatype) << " is less than unit size " << unit_size << "; possible loss of data."; \
|
||||
} \
|
||||
datatype temp_val; \
|
||||
long ptr = 0; \
|
||||
while (ptr < data_size) { \
|
||||
temp_val = 0; \
|
||||
memcpy(&temp_val, data_val + ptr, (unit_size > sizeof(datatype))?sizeof(datatype):unit_size); \
|
||||
val_out.push_back(temp_val); \
|
||||
ptr += unit_size; \
|
||||
} \
|
||||
return; \
|
||||
} \
|
||||
val_out.assign(data_val, data_val + (data_size / sizeof(datatype))); \
|
||||
}
|
||||
|
||||
void DataElement::get(vector<unsigned char>& ucharvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
DataElementGetNumericVectorDef(DATA_CHAR_VECTOR, char, DATA_UCHAR_VECTOR, DATA_INT_VECTOR, DATA_UINT_VECTOR, DATA_LONG_VECTOR, DATA_ULONG_VECTOR,
|
||||
DATA_LONGLONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_UCHAR_VECTOR, unsigned char, DATA_CHAR_VECTOR, DATA_INT_VECTOR, DATA_UINT_VECTOR, DATA_LONG_VECTOR,
|
||||
DATA_ULONG_VECTOR, DATA_LONGLONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_INT_VECTOR, int, DATA_CHAR_VECTOR, DATA_UCHAR_VECTOR, DATA_UINT_VECTOR, DATA_LONG_VECTOR, DATA_ULONG_VECTOR,
|
||||
DATA_LONGLONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_UINT_VECTOR, unsigned int, DATA_CHAR_VECTOR, DATA_UCHAR_VECTOR, DATA_INT_VECTOR, DATA_LONG_VECTOR,
|
||||
DATA_ULONG_VECTOR, DATA_LONGLONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_LONG_VECTOR, long, DATA_CHAR_VECTOR, DATA_UCHAR_VECTOR, DATA_INT_VECTOR, DATA_UINT_VECTOR, DATA_ULONG_VECTOR,
|
||||
DATA_LONGLONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_ULONG_VECTOR, unsigned long, DATA_CHAR_VECTOR, DATA_UCHAR_VECTOR, DATA_INT_VECTOR, DATA_UINT_VECTOR,
|
||||
DATA_LONG_VECTOR, DATA_LONGLONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_LONGLONG_VECTOR, long long, DATA_CHAR_VECTOR, DATA_UCHAR_VECTOR, DATA_INT_VECTOR, DATA_UINT_VECTOR,
|
||||
DATA_LONG_VECTOR, DATA_ULONG_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_FLOAT_VECTOR, float, DATA_DOUBLE_VECTOR, DATA_LONGDOUBLE_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_DOUBLE_VECTOR, double, DATA_FLOAT_VECTOR, DATA_LONGDOUBLE_VECTOR);
|
||||
DataElementGetNumericVectorDef(DATA_LONGDOUBLE_VECTOR, long double, DATA_DOUBLE_VECTOR, DATA_FLOAT_VECTOR);
|
||||
|
||||
if (data_type != DATA_UCHAR_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
unsigned char temp_char;
|
||||
while (ptr < data_size) {
|
||||
temp_char = 0;
|
||||
memcpy(&temp_char, data_val + ptr, sizeof(unsigned char));
|
||||
ucharvect_in.push_back(temp_char);
|
||||
ptr += sizeof(unsigned char);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<unsigned int>& uintvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_UINT_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
unsigned int temp_char;
|
||||
while (ptr < data_size) {
|
||||
temp_char = 0;
|
||||
memcpy(&temp_char, data_val + ptr, sizeof(unsigned int));
|
||||
uintvect_in.push_back(temp_char);
|
||||
ptr += sizeof(unsigned int);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<unsigned long>& ulongvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_ULONG_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
unsigned long temp_char;
|
||||
while (ptr < data_size) {
|
||||
temp_char = 0;
|
||||
memcpy(&temp_char, data_val + ptr, sizeof(unsigned long));
|
||||
ulongvect_in.push_back(temp_char);
|
||||
ptr += sizeof(unsigned long);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<long long>& llongvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_LONGLONG_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
long long temp_char;
|
||||
while (ptr < data_size) {
|
||||
temp_char = 0;
|
||||
memcpy(&temp_char, data_val + ptr, sizeof(long long));
|
||||
llongvect_in.push_back(temp_char);
|
||||
ptr += sizeof(long long);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<long double>& ldoublevect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_LONGDOUBLE_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
long double temp_char;
|
||||
while (ptr < data_size) {
|
||||
temp_char = 0;
|
||||
memcpy(&temp_char, data_val + ptr, sizeof(long double));
|
||||
ldoublevect_in.push_back(temp_char);
|
||||
ptr += sizeof(long double);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<int> &intvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_INT_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a INT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
int temp_int;
|
||||
while (ptr < data_size) {
|
||||
temp_int = 0;
|
||||
memcpy(&temp_int, data_val + ptr, sizeof(int));
|
||||
intvect_in.push_back(temp_int);
|
||||
ptr += sizeof(int);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<long> &longvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_LONG_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a LONG VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
long temp_long;
|
||||
while (ptr < data_size) {
|
||||
temp_long = 0;
|
||||
memcpy(&temp_long, data_val + ptr, sizeof(long));
|
||||
longvect_in.push_back(temp_long);
|
||||
ptr += sizeof(long);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<float> &floatvect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_FLOAT_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a FLOAT VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
float temp_float;
|
||||
while (ptr < data_size) {
|
||||
temp_float = 0;
|
||||
memcpy(&temp_float, data_val + ptr, sizeof(float));
|
||||
floatvect_in.push_back(temp_float);
|
||||
ptr += sizeof(float);
|
||||
}
|
||||
}
|
||||
|
||||
void DataElement::get(vector<double> &doublevect_in) throw (DataTypeMismatchException) {
|
||||
long ptr;
|
||||
if (!data_type)
|
||||
return;
|
||||
|
||||
if (data_type != DATA_DOUBLE_VECTOR)
|
||||
throw(new DataTypeMismatchException("Type mismatch, not a DOUBLE VECTOR"));
|
||||
|
||||
ptr = 0;
|
||||
|
||||
double temp_double;
|
||||
|
||||
while (ptr < data_size) {
|
||||
temp_double = 0;
|
||||
memcpy(&temp_double, data_val + ptr, sizeof(double));
|
||||
doublevect_in.push_back(temp_double);
|
||||
ptr += sizeof(double);
|
||||
}
|
||||
}
|
||||
|
||||
long DataElement::getSerializedSize() {
|
||||
return sizeof(unsigned char) + sizeof(unsigned int) + data_size;
|
||||
|
||||
@ -64,11 +64,10 @@ using namespace std;
|
||||
#define DATA_LONG_VECTOR 18
|
||||
#define DATA_ULONG_VECTOR 19
|
||||
#define DATA_LONGLONG_VECTOR 20
|
||||
#define DATA_ULONGLONG_VECTOR 21
|
||||
#define DATA_FLOAT_VECTOR 22
|
||||
#define DATA_DOUBLE_VECTOR 23
|
||||
#define DATA_LONGDOUBLE_VECTOR 24
|
||||
#define DATA_VOID 25
|
||||
#define DATA_FLOAT_VECTOR 21
|
||||
#define DATA_DOUBLE_VECTOR 22
|
||||
#define DATA_LONGDOUBLE_VECTOR 23
|
||||
#define DATA_VOID 24
|
||||
|
||||
|
||||
/* map comparison function */
|
||||
@ -122,6 +121,7 @@ class DataElement
|
||||
private:
|
||||
unsigned char data_type;
|
||||
unsigned int data_size;
|
||||
unsigned int unit_size;
|
||||
|
||||
char *data_val;
|
||||
|
||||
@ -133,9 +133,9 @@ public:
|
||||
|
||||
int getDataType();
|
||||
long getDataSize();
|
||||
int getUnitSize();
|
||||
|
||||
/* set overloads */
|
||||
// void set(const bool &bool_in);
|
||||
void set(const char &char_in);
|
||||
void set(const unsigned char &uchar_in);
|
||||
void set(const int &int_in);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user