nils/ebusd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
611cb562e2379edb01db1b2318bfb226e98e08ba
ebusd/src/lib/ebus/data.cpp
T

1263 lines
40 KiB
C++
Raw Blame History

/*
* ebusd - daemon for communication with eBUS heating systems.
* Copyright (C) 2014-2017 John Baier <ebusd@ebusd.eu>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "lib/ebus/data.h"
#include <math.h>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <cstring>
#include <algorithm>
namespace ebusd {
using std::dec;
using std::hex;
using std::setw;
/** the week day names. */
static const char* dayNames[] = {"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"};
/** the default field map for field templates. */
static const char* defaultTemplateFieldMap[] = {
"name", "*type", "divisor/values", "unit", "comment",
"*name", "type", "divisor/values", "unit", "comment",
};
string getDataFieldName(const string name, bool& supportsLanguage) {
if (name.find("name") != string::npos || name.find("field") != string::npos) {
return "name";
}
if (name.find("part") != string::npos) {
return "part";
}
if (name.find("type") != string::npos) {
return "type";
}
if (name.find("divisor") != string::npos) {
if (name.find("values") != string::npos) {
supportsLanguage = true;
return "divisor/values";
}
return "divisor";
}
supportsLanguage = true;
if (name == "values" || name == "unit") {
return name;
}
if (name.find("comment") != string::npos) {
return "comment";
}
return "";
}
const string AttributedItem::formatInt(size_t value) {
ostringstream stream;
stream << dec << static_cast<unsigned>(value);
return stream.str();
}
const string AttributedItem::pluck(map<string, string>& row, string key) {
const auto it = row.find(key);
if (it == row.end()) {
return "";
}
const string ret = it->second;
row.erase(it);
return ret;
}
void AttributedItem::dumpString(ostream& output, const string str, const bool prependFieldSeparator) {
if (prependFieldSeparator) {
output << FIELD_SEPARATOR;
}
if (str.find_first_of(FIELD_SEPARATOR) == string::npos) {
output << str;
} else {
output << TEXT_SEPARATOR << str << TEXT_SEPARATOR;
}
}
void AttributedItem::appendJson(ostream& output, const string name, const string value,
const bool prependFieldSeparator, bool asString) {
bool plain;
if (asString) {
plain = false;
} else {
plain = value == "false" || value == "true";
if (!plain) {
const char* str = value.c_str();
char* strEnd = NULL;
strtod(str, &strEnd);
plain = strEnd && !*strEnd;
}
}
if (prependFieldSeparator) {
output << FIELD_SEPARATOR;
}
output << " \"" << name << "\": ";
if (plain) {
output << value;
} else {
output << '"' << value << '"';
}
}
void AttributedItem::mergeAttributes(map<string, string>& attributes) const {
for (const auto& entry : m_attributes) {
const auto it = attributes.find(entry.first);
if (it == attributes.end() || it->second.empty()) {
attributes[entry.first] = entry.second;
}
}
}
void AttributedItem::dumpAttribute(ostream& output, const string name, const bool prependFieldSeparator) const {
dumpString(output, getAttribute(name), prependFieldSeparator);
}
string AttributedItem::getAttribute(const string name) const {
const auto it = m_attributes.find(name);
return it == m_attributes.end() ? "" : it->second;
}
bool AttributedItem::appendAttribute(ostringstream& output, OutputFormat outputFormat, const string name,
const bool onlyIfNonEmpty, const string prefix, const string suffix) const {
const auto it = m_attributes.find(name);
string value = it == m_attributes.end() ? "" : it->second;
if (onlyIfNonEmpty && value.empty()) {
return false;
}
if (outputFormat & OF_JSON) {
appendJson(output, name, value, true);
} else {
output << " " << prefix << value << suffix;
}
return true;
}
bool AttributedItem::appendAttributes(ostringstream& output, OutputFormat outputFormat) const {
bool ret = false;
if ((outputFormat & OF_UNITS)) {
ret = appendAttribute(output, outputFormat, "unit") || ret;
}
if ((outputFormat & OF_COMMENTS)) {
ret = appendAttribute(output, outputFormat, "comment", true, "[", "]") || ret;
}
if (outputFormat & OF_ALL_ATTRS) {
for (const auto entry : m_attributes) {
ret = true;
if (!entry.second.empty() && entry.first != "unit" && entry.first != "comment") {
if (outputFormat & OF_JSON) {
appendJson(output, entry.first, entry.second);
} else {
output << " " << entry.first << "=" << entry.second;
}
}
}
}
return ret;
}
result_t DataField::create(vector< map<string, string> >& rows, string& errorDescription,
DataFieldTemplates* templates, const DataField*& returnField,
const bool isWriteMessage,
const bool isTemplate, const bool isBroadcastOrMasterDestination,
const size_t maxFieldLength) {
// template: name,[,part]basetype[:len]|template[:name][,[divisor|values][,[unit][,[comment]]]]
// std: name,part,basetype[:len]|template[:name][,[divisor|values][,[unit][,[comment]]]]
vector<const SingleDataField*> fields;
string firstName;
result_t result = RESULT_OK;
if (rows.empty()) {
errorDescription = "no fields";
return RESULT_ERR_EOF;
}
size_t fieldIndex = -1;
for (auto& row : rows) {
if (result != RESULT_OK) {
break;
}
fieldIndex++;
const string name = pluck(row, "name");
PartType partType;
bool hasPart = false;
string part = pluck(row, "part");
if (isTemplate) {
partType = pt_any;
} else {
hasPart = !part.empty();
if (hasPart) {
FileReader::tolower(part);
}
if (isBroadcastOrMasterDestination
|| (isWriteMessage && !hasPart)
|| part == "m") { // master data
partType = pt_masterData;
} else if ((!isWriteMessage && !hasPart)
|| part == "s") { // slave data
partType = pt_slaveData;
} else {
errorDescription = "part "+part+" in field "+formatInt(fieldIndex);
result = hasPart ? RESULT_ERR_INVALID_ARG : RESULT_ERR_MISSING_ARG;
break;
}
}
if (fields.empty()) {
firstName = name;
}
const string typeStr = pluck(row, "type"); // basetype[:len]|template[:name]
if (typeStr.empty()) {
errorDescription = "field type in field "+formatInt(fieldIndex);
result = RESULT_ERR_MISSING_ARG;
break;
}
string divisorStr = pluck(row, "divisor");
string valuesStr = pluck(row, "values");
if (divisorStr.empty() && valuesStr.empty()) {
divisorStr = pluck(row, "divisor/values"); // [divisor|values]
if (divisorStr.find('=') != string::npos) {
valuesStr = divisorStr;
divisorStr = "";
}
}
int divisor = 0;
if (!divisorStr.empty()) {
divisor = parseSignedInt(divisorStr.c_str(), 10, -MAX_DIVISOR, MAX_DIVISOR, result);
if (result != RESULT_OK) {
errorDescription = "divisor "+divisorStr+" in field "+formatInt(fieldIndex);
}
}
bool verifyValue = false;
map<unsigned int, string> values;
string constantValue;
if (!valuesStr.empty()) {
size_t equalPos = valuesStr.find('=');
if (equalPos == string::npos) {
errorDescription = "values "+valuesStr+" in field "+formatInt(fieldIndex);
result = RESULT_ERR_INVALID_LIST;
} else if (equalPos == 0 && valuesStr.length() > 1) {
verifyValue = valuesStr[1] == '='; // == forced verification of constant value
if (verifyValue && valuesStr.length() == 1) {
errorDescription = "values "+valuesStr+" in field "+formatInt(fieldIndex);
result = RESULT_ERR_INVALID_LIST;
break;
}
constantValue = valuesStr.substr(equalPos+(verifyValue?2:1));
} else {
string token;
istringstream stream(valuesStr);
while (getline(stream, token, VALUE_SEPARATOR)) {
FileReader::trim(token);
const char* str = token.c_str();
char* strEnd = NULL;
unsigned long id;
if (strncasecmp(str, "0x", 2) == 0) {
str += 2;
id = strtoul(str, &strEnd, 16); // hexadecimal
} else {
id = strtoul(str, &strEnd, 10); // decimal
}
if (strEnd == NULL || strEnd == str || id > MAX_VALUE) {
errorDescription = "value "+token+" in field "+formatInt(fieldIndex);
result = RESULT_ERR_INVALID_LIST;
break;
}
// remove blanks around '=' sign
while (*strEnd == ' ') strEnd++;
if (*strEnd != '=') {
errorDescription = "value "+token+" in field "+formatInt(fieldIndex);
result = RESULT_ERR_INVALID_LIST;
break;
}
token = string(strEnd + 1);
FileReader::trim(token);
values[(unsigned int)id] = token;
}
}
if (result != RESULT_OK) {
break;
}
}
bool firstType = true;
string token;
istringstream stream(typeStr);
while (result == RESULT_OK && getline(stream, token, VALUE_SEPARATOR)) {
bool lastType = stream.eof();
FileReader::trim(token);
const DataField* templ = templates->get(token);
size_t pos = token.find(LENGTH_SEPARATOR);
if (templ == NULL && pos != string::npos) {
templ = templates->get(token.substr(0, pos));
}
if (templ == NULL) { // basetype[:len]
size_t length;
string typeName;
if (pos == string::npos) {
length = 0; // no length specified
typeName = token;
} else {
if (pos+2 == token.length() && token[pos+1] == '*') {
length = REMAIN_LEN;
} else {
length = (size_t)parseInt(token.substr(pos+1).c_str(), 10, 1, (unsigned int)maxFieldLength, result);
if (result != RESULT_OK) {
errorDescription = "field type "+token+" in field "+formatInt(fieldIndex);
break;
}
}
typeName = token.substr(0, pos);
}
transform(typeName.begin(), typeName.end(), typeName.begin(), ::toupper);
const DataType* dataType = DataTypeList::getInstance()->get(typeName, length == REMAIN_LEN ? 0 : length);
if (!dataType) {
result = RESULT_ERR_NOTFOUND;
errorDescription = "field type "+typeName+" in field "+formatInt(fieldIndex);
} else {
SingleDataField* add = NULL;
result = SingleDataField::create(firstType ? name : "", row, dataType, partType, length, divisor, values,
constantValue, verifyValue, add);
if (add != NULL) {
fields.push_back(add);
} else {
if (result == RESULT_OK) {
errorDescription = "field type "+typeName+" in field "+formatInt(fieldIndex);
result = RESULT_ERR_NOTFOUND; // type not found
} else {
errorDescription = "create field in field "+formatInt(fieldIndex);
}
}
}
} else if (!constantValue.empty()) {
errorDescription = "constant value "+constantValue+" in field "+formatInt(fieldIndex);
result = RESULT_ERR_INVALID_ARG; // invalid value list
} else { // template[:name]
string fieldName;
if (pos != string::npos) { // replacement name specified
fieldName = token.substr(pos+1);
} else {
fieldName = (firstType && lastType) ? name : "";
}
result = templ->derive(fieldName, row, partType, divisor, values, fields);
if (result != RESULT_OK) {
errorDescription = "derive field "+fieldName+" in field "+formatInt(fieldIndex);
}
}
if (firstType && !lastType) {
pluck(row, "comment");
pluck(row, "unit");
}
firstType = false;
}
}
if (result != RESULT_OK) {
while (!fields.empty()) { // cleanup already created fields
delete fields.back();
fields.pop_back();
}
return result;
}
if (fields.size() == 1) {
returnField = fields[0];
} else {
returnField = new DataFieldSet(firstName, fields);
}
return RESULT_OK;
}
string DataField::getDayName(int day) {
if (day < 0 || day > 6) {
return "";
}
return dayNames[day];
}
result_t SingleDataField::create(const string name, const map<string, string>& attributes, const DataType* dataType,
const PartType partType, const size_t length, int divisor, map<unsigned int, string> values,
const string constantValue, const bool verifyValue, SingleDataField* &returnField) {
size_t bitCount = dataType->getBitCount();
size_t byteCount = (bitCount + 7) / 8;
if (dataType->isAdjustableLength()) {
// check length
if ((bitCount % 8) != 0) {
if (length == 0) {
bitCount = 1; // default bit count: 1 bit
} else if (length <= bitCount) {
bitCount = length;
} else {
return RESULT_ERR_OUT_OF_RANGE; // invalid length
}
byteCount = (bitCount + 7) / 8;
} else if (length == 0) {
byteCount = 1; // default byte count: 1 byte
} else if (length <= byteCount || length == REMAIN_LEN) {
byteCount = length;
} else {
return RESULT_ERR_OUT_OF_RANGE; // invalid length
}
}
if (!constantValue.empty()) {
returnField = new ConstantDataField(name, attributes, dataType, partType, byteCount, constantValue, verifyValue);
return RESULT_OK;
}
if (dataType->isNumeric()) {
const NumberDataType* numType = reinterpret_cast<const NumberDataType*>(dataType);
if (values.empty() && numType->hasFlag(DAY)) {
for (unsigned int i = 0; i < sizeof(dayNames) / sizeof(dayNames[0]); i++) {
values[numType->getMinValue() + i] = dayNames[i];
}
}
result_t result = numType->derive(divisor, bitCount, numType);
if (result != RESULT_OK) {
return result;
}
if (values.empty()) {
returnField = new SingleDataField(name, attributes, numType, partType, byteCount);
return RESULT_OK;
}
if (values.begin()->first < numType->getMinValue() || values.rbegin()->first > numType->getMaxValue()) {
return RESULT_ERR_OUT_OF_RANGE;
}
returnField = new ValueListDataField(name, attributes, numType, partType, byteCount, values);
return RESULT_OK;
}
if (divisor != 0 || !values.empty()) {
return RESULT_ERR_INVALID_ARG; // cannot set divisor or values for string field
}
returnField = new SingleDataField(name, attributes, dataType, partType, byteCount);
return RESULT_OK;
}
void SingleDataField::dump(ostream& output) const {
output << setw(0) << dec; // initialize formatting
dumpString(output, m_name, false);
output << FIELD_SEPARATOR;
if (m_partType == pt_masterData) {
output << "m";
} else if (m_partType == pt_slaveData) {
output << "s";
}
output << FIELD_SEPARATOR;
m_dataType->dump(output, m_length);
dumpAttribute(output, "unit");
dumpAttribute(output, "comment");
}
result_t SingleDataField::read(const SymbolString& data, size_t offset,
unsigned int& output, const char* fieldName, ssize_t fieldIndex) const {
if (m_partType == pt_any) {
return RESULT_ERR_INVALID_PART;
}
if ((data.isMaster() ? pt_masterData : pt_slaveData) != m_partType) {
return RESULT_EMPTY;
}
bool remainder = m_length == REMAIN_LEN && m_dataType->isAdjustableLength();
if (offset + (remainder?1:m_length) > data.getDataSize()) {
return RESULT_ERR_INVALID_POS;
}
if (isIgnored() || (fieldName != NULL && (m_name != fieldName || fieldIndex > 0))) {
return RESULT_EMPTY;
}
result_t res = m_dataType->readRawValue(data, offset, m_length, output);
return res;
}
result_t SingleDataField::read(const SymbolString& data, size_t offset,
ostringstream& output, OutputFormat outputFormat, ssize_t outputIndex,
bool leadingSeparator, const char* fieldName, ssize_t fieldIndex) const {
if (m_partType == pt_any) {
return RESULT_ERR_INVALID_PART;
}
if ((data.isMaster() ? pt_masterData : pt_slaveData) != m_partType) {
return RESULT_OK;
}
bool remainder = m_length == REMAIN_LEN && m_dataType->isAdjustableLength();
if (offset + (remainder?1:m_length) > data.getDataSize()) {
return RESULT_ERR_INVALID_POS;
}
if (isIgnored() || (fieldName != NULL && (m_name != fieldName || fieldIndex > 0))) {
return RESULT_EMPTY;
}
bool shortFormat = outputFormat & OF_SHORT;
if (outputFormat & OF_JSON) {
if (leadingSeparator) {
output << ",";
}
if (!shortFormat) {
output << "\n ";
}
if (outputIndex >= 0 || m_name.empty() || !(outputFormat & OF_NAMES)) {
output << "\"" << static_cast<signed int>(outputIndex < 0 ? 0 : outputIndex) << "\":";
if (!shortFormat) {
output << " {\"name\": \"" << m_name << "\"" << ", \"value\": ";
}
} else {
output << "\"" << m_name << "\":";
if (!shortFormat) {
output << " {\"value\": ";
}
}
} else {
if (leadingSeparator) {
output << UI_FIELD_SEPARATOR;
}
if (outputFormat & OF_NAMES) {
output << m_name << "=";
}
}
result_t result = readSymbols(data, offset, output, outputFormat);
if (result != RESULT_OK) {
return result;
}
if (!shortFormat) {
appendAttributes(output, outputFormat);
}
if (!shortFormat && (outputFormat & OF_JSON)) {
output << "}";
}
return RESULT_OK;
}
result_t SingleDataField::write(istringstream& input, SymbolString& data,
size_t offset, char separator, size_t* length) const {
if (m_partType == pt_any) {
return RESULT_ERR_INVALID_PART;
}
if ((data.isMaster() ? pt_masterData : pt_slaveData) != m_partType) {
return RESULT_OK;
}
return writeSymbols(input, (const size_t)offset, data, length);
}
result_t SingleDataField::readSymbols(const SymbolString& input,
const size_t offset,
ostringstream& output, OutputFormat outputFormat) const {
return m_dataType->readSymbols(input, offset, m_length, output, outputFormat);
}
result_t SingleDataField::writeSymbols(istringstream& input,
const size_t offset,
SymbolString& output, size_t* usedLength) const {
return m_dataType->writeSymbols(input, offset, m_length, output, usedLength);
}
const SingleDataField* SingleDataField::clone() const {
return new SingleDataField(*this);
}
result_t SingleDataField::derive(string name, map<string, string> attributes, const PartType partType,
int divisor, map<unsigned int, string> values, vector<const SingleDataField*>& fields) const {
if (m_partType != pt_any && partType == pt_any) {
return RESULT_ERR_INVALID_PART; // cannot create a template from a concrete instance
}
bool numeric = m_dataType->isNumeric();
if (!numeric && (divisor != 0 || !values.empty())) {
return RESULT_ERR_INVALID_ARG; // cannot set divisor or values for non-numeric field
}
if (name.empty()) {
name = m_name;
}
mergeAttributes(attributes);
const DataType* dataType = m_dataType;
if (numeric) {
const NumberDataType* numType = reinterpret_cast<const NumberDataType*>(dataType);
result_t result = numType->derive(divisor, 0, numType);
if (result != RESULT_OK) {
return result;
}
dataType = numType;
}
if (values.empty()) {
fields.push_back(new SingleDataField(name, attributes, dataType, partType, m_length));
} else if (numeric) {
fields.push_back(new ValueListDataField(name, attributes, reinterpret_cast<const NumberDataType*>(dataType),
partType, m_length, values));
} else {
return RESULT_ERR_INVALID_ARG;
}
return RESULT_OK;
}
bool SingleDataField::hasField(const char* fieldName, bool numeric) const {
bool numericType = m_dataType->isNumeric();
return numeric == numericType && (fieldName == NULL || fieldName == m_name);
}
size_t SingleDataField::getLength(PartType partType, size_t maxLength) const {
if (partType != m_partType) {
return 0;
}
bool remainder = m_length == REMAIN_LEN && m_dataType->isAdjustableLength();
return remainder ? maxLength : m_length;
}
bool SingleDataField::hasFullByteOffset(bool after) const {
if (m_length > 1) {
return true;
}
int16_t firstBit;
if (m_dataType->isNumeric()) {
const NumberDataType* num = reinterpret_cast<const NumberDataType*>(m_dataType);
firstBit = num->getFirstBit();
} else {
firstBit = 0;
}
return (m_dataType->getBitCount() % 8) == 0
|| (after && firstBit + (m_dataType->getBitCount() % 8) >= 8);
}
const ValueListDataField* ValueListDataField::clone() const {
return new ValueListDataField(*this);
}
result_t ValueListDataField::derive(const string name, map<string, string> attributes, const PartType partType,
int divisor, map<unsigned int, string> values, vector<const SingleDataField*>& fields) const {
if (m_partType != pt_any && partType == pt_any) {
return RESULT_ERR_INVALID_PART; // cannot create a template from a concrete instance
}
string useName = name.empty() ? m_name : name;
mergeAttributes(attributes);
if (divisor != 0 && divisor != 1) {
return RESULT_ERR_INVALID_ARG; // cannot use divisor != 1 for value list field
}
if (!m_dataType->isNumeric()) {
return RESULT_ERR_INVALID_ARG;
}
if (!values.empty()) {
const NumberDataType* num = reinterpret_cast<const NumberDataType*>(m_dataType);
if (values.begin()->first < num->getMinValue() || values.rbegin()->first > num->getMaxValue()) {
return RESULT_ERR_INVALID_ARG; // cannot use divisor != 1 for value list field
}
} else {
values = m_values;
}
fields.push_back(new ValueListDataField(useName, attributes, reinterpret_cast<const NumberDataType*>(m_dataType),
partType, m_length, values));
return RESULT_OK;
}
void ValueListDataField::dump(ostream& output) const {
output << setw(0) << dec; // initialize formatting
dumpString(output, m_name, false);
output << FIELD_SEPARATOR;
if (m_partType == pt_masterData) {
output << "m";
} else if (m_partType == pt_slaveData) {
output << "s";
}
output << FIELD_SEPARATOR;
if (!m_dataType->dump(output, m_length)) { // no divisor appended
bool first = true;
for (const auto it : m_values) {
if (first) {
first = false;
} else {
output << VALUE_SEPARATOR;
}
output << static_cast<unsigned>(it.first) << "=" << it.second;
}
} // else: impossible since divisor is not allowed for ValueListDataField
dumpAttribute(output, "unit");
dumpAttribute(output, "comment");
}
result_t ValueListDataField::readSymbols(const SymbolString& input,
const size_t offset,
ostringstream& output, OutputFormat outputFormat) const {
unsigned int value = 0;
result_t result = m_dataType->readRawValue(input, offset, m_length, value);
if (result != RESULT_OK) {
return result;
}
const auto it = m_values.find(value);
if (it == m_values.end() && value != m_dataType->getReplacement()) {
// fall back to raw value in input
output << setw(0) << dec << static_cast<unsigned>(value);
return RESULT_OK;
}
if (it == m_values.end()) {
if (outputFormat & OF_JSON) {
output << "null";
} else if (value == m_dataType->getReplacement()) {
output << NULL_VALUE;
}
} else if (outputFormat & OF_NUMERIC) {
output << setw(0) << dec << static_cast<unsigned>(value);
} else if (outputFormat & OF_JSON) {
if (outputFormat & OF_VALUENAME) {
output << "{\"value\":" << setw(0) << dec << static_cast<unsigned>(value);
output << ",\"name\":\"" << it->second << "\"}";
} else {
output << '"' << it->second << '"';
}
} else {
if (outputFormat & OF_VALUENAME) {
output << setw(0) << dec << static_cast<unsigned>(value) << '=';
}
output << it->second;
}
return RESULT_OK;
}
result_t ValueListDataField::writeSymbols(istringstream& input,
const size_t offset,
SymbolString& output, size_t* usedLength) const {
const NumberDataType* numType = reinterpret_cast<const NumberDataType*>(m_dataType);
if (isIgnored()) {
// replacement value
return numType->writeRawValue(numType->getReplacement(), offset, m_length, output, usedLength);
}
const char* str = input.str().c_str();
for (const auto it : m_values) {
if (it.second.compare(str) == 0) {
return numType->writeRawValue(it.first, offset, m_length, output, usedLength);
}
}
if (strcasecmp(str, NULL_VALUE) == 0) {
// replacement value
return numType->writeRawValue(numType->getReplacement(), offset, m_length, output, usedLength);
}
char* strEnd = NULL; // fall back to raw value in input
unsigned int value;
value = (unsigned int)strtoul(str, &strEnd, 10);
if (strEnd == NULL || strEnd == str || (*strEnd != 0 && *strEnd != '.')) {
return RESULT_ERR_INVALID_NUM; // invalid value
}
if (m_values.find(value) != m_values.end()) {
return numType->writeRawValue(value, offset, m_length, output, usedLength);
}
return RESULT_ERR_NOTFOUND; // value assignment not found
}
const ConstantDataField* ConstantDataField::clone() const {
return new ConstantDataField(*this);
}
result_t ConstantDataField::derive(const string name, map<string, string> attributes, const PartType partType,
int divisor, map<unsigned int, string> values, vector<const SingleDataField*>& fields) const {
if (m_partType != pt_any && partType == pt_any) {
return RESULT_ERR_INVALID_PART; // cannot create a template from a concrete instance
}
string useName = name.empty() ? m_name : name;
for (const auto entry : m_attributes) { // merge with this attributes
if (attributes[entry.first].empty()) {
attributes[entry.first] = entry.second;
}
}
if (divisor != 0) {
return RESULT_ERR_INVALID_ARG; // cannot use other than current divisor for constant value field
}
if (!values.empty()) {
return RESULT_ERR_INVALID_ARG; // cannot use value list for constant value field
}
fields.push_back(new ConstantDataField(useName, attributes, m_dataType, partType, m_length, m_value, m_verify));
return RESULT_OK;
}
void ConstantDataField::dump(ostream& output) const {
output << setw(0) << dec; // initialize formatting
dumpString(output, m_name, false);
output << FIELD_SEPARATOR;
if (m_partType == pt_masterData) {
output << "m";
} else if (m_partType == pt_slaveData) {
output << "s";
}
output << FIELD_SEPARATOR;
if (!m_dataType->dump(output, m_length)) { // no divisor appended
output << (m_verify?"==":"=") << m_value;
} // else: impossible since divisor is not allowed for ConstantDataField
dumpAttribute(output, "unit");
dumpAttribute(output, "comment");
}
result_t ConstantDataField::readSymbols(const SymbolString& input,
const size_t offset,
ostringstream& output, OutputFormat outputFormat) const {
ostringstream coutput;
result_t result = SingleDataField::readSymbols(input, offset, coutput, 0);
if (result != RESULT_OK) {
return result;
}
if (m_verify) {
string value = coutput.str();
FileReader::trim(value);
if (value != m_value) {
return RESULT_ERR_OUT_OF_RANGE;
}
}
return RESULT_OK;
}
result_t ConstantDataField::writeSymbols(istringstream& input,
const size_t offset,
SymbolString& output, size_t* usedLength) const {
istringstream cinput(m_value);
return SingleDataField::writeSymbols(cinput, offset, output, usedLength);
}
DataFieldSet* DataFieldSet::s_identFields = NULL;
DataFieldSet* DataFieldSet::getIdentFields() {
if (s_identFields == NULL) {
const NumberDataType* uchDataType = reinterpret_cast<const NumberDataType*>(
DataTypeList::getInstance()->get("UCH"));
const StringDataType* stringDataType = reinterpret_cast<const StringDataType*>(
DataTypeList::getInstance()->get("STR"));
const NumberDataType* pinDataType = reinterpret_cast<const NumberDataType*>(
DataTypeList::getInstance()->get("PIN"));
map<unsigned int, string> manufacturers;
manufacturers[0x06] = "Dungs";
manufacturers[0x0f] = "FH Ostfalia";
manufacturers[0x10] = "TEM";
manufacturers[0x11] = "Lamberti";
manufacturers[0x14] = "CEB";
manufacturers[0x15] = "Landis-Staefa";
manufacturers[0x16] = "FERRO";
manufacturers[0x17] = "MONDIAL";
manufacturers[0x18] = "Wikon";
manufacturers[0x19] = "Wolf";
manufacturers[0x20] = "RAWE";
manufacturers[0x30] = "Satronic";
manufacturers[0x40] = "ENCON";
manufacturers[0x50] = "Kromschroeder";
manufacturers[0x60] = "Eberle";
manufacturers[0x65] = "EBV";
manufacturers[0x75] = "Graesslin";
manufacturers[0x85] = "ebm-papst";
manufacturers[0x95] = "SIG";
manufacturers[0xa5] = "Theben";
manufacturers[0xa7] = "Thermowatt";
manufacturers[0xb5] = "Vaillant";
manufacturers[0xc0] = "Toby";
manufacturers[0xc5] = "Weishaupt";
manufacturers[0xfd] = "ebusd.eu";
vector<const SingleDataField*> fields;
map<string, string> attributes;
fields.push_back(new ValueListDataField("MF", attributes, uchDataType, pt_slaveData, 1, manufacturers));
fields.push_back(new SingleDataField("ID", attributes, stringDataType, pt_slaveData, 5));
fields.push_back(new SingleDataField("SW", attributes, pinDataType, pt_slaveData, 2));
fields.push_back(new SingleDataField("HW", attributes, pinDataType, pt_slaveData, 2));
s_identFields = new DataFieldSet("ident", fields);
}
return s_identFields;
}
DataFieldSet::~DataFieldSet() {
for (const auto field : m_fields) {
delete field;
}
}
const DataFieldSet* DataFieldSet::clone() const {
vector<const SingleDataField*> fields;
for (const auto field : m_fields) {
fields.push_back(field->clone());
}
return new DataFieldSet(m_name, fields);
}
size_t DataFieldSet::getLength(PartType partType, size_t maxLength) const {
size_t length = 0;
bool previousFullByteOffset[] = { true, true, true, true };
for (const auto field : m_fields) {
if (field->getPartType() == partType) {
if (!previousFullByteOffset[partType] && !field->hasFullByteOffset(false)) {
length--;
}
size_t fieldLength = field->getLength(partType, maxLength);
if (fieldLength >= maxLength) {
maxLength = 0;
} else {
maxLength = maxLength - fieldLength;
}
length = length + fieldLength;
previousFullByteOffset[partType] = field->hasFullByteOffset(true);
}
}
return length;
}
string DataFieldSet::getName(const ssize_t fieldIndex) const {
if (fieldIndex < 0) {
return m_name;
}
if ((size_t)fieldIndex >= m_fields.size()) {
return "";
}
if (m_uniqueNames) {
return m_fields[fieldIndex]->getName();
}
ostringstream ostream;
ostream << static_cast<signed>(fieldIndex);
return ostream.str();
}
result_t DataFieldSet::derive(const string name, map<string, string> attributes, const PartType partType,
int divisor, map<unsigned int, string> values, vector<const SingleDataField*>& fields) const {
if (!values.empty()) {
return RESULT_ERR_INVALID_ARG; // value list not allowed in set derive
}
for (const auto field : m_fields) {
result_t result = field->derive("", attributes, partType, divisor, values, fields);
if (result != RESULT_OK) {
return result;
}
pluck(attributes, "comment");
pluck(attributes, "unit");
}
return RESULT_OK;
}
bool DataFieldSet::hasField(const char* fieldName, bool numeric) const {
for (const auto field : m_fields) {
if (field->hasField(fieldName, numeric) == 0) {
return true;
}
}
return false;
}
void DataFieldSet::dump(ostream& output) const {
bool first = true;
for (const auto field : m_fields) {
if (first) {
first = false;
} else {
output << FIELD_SEPARATOR;
}
field->dump(output);
}
}
result_t DataFieldSet::read(const SymbolString& data, size_t offset,
unsigned int& output, const char* fieldName, ssize_t fieldIndex) const {
bool previousFullByteOffset = true, found = false, findFieldIndex = fieldName != NULL && fieldIndex >= 0;
PartType partType = data.isMaster() ? pt_masterData : pt_slaveData;
for (const auto field : m_fields) {
if (field->getPartType() != partType) {
continue;
}
if (!previousFullByteOffset && !field->hasFullByteOffset(false)) {
offset--;
}
result_t result = field->read(data, offset, output, fieldName, fieldIndex);
if (result < RESULT_OK) {
return result;
}
offset += field->getLength(partType, data.getDataSize()-offset);
previousFullByteOffset = field->hasFullByteOffset(true);
if (result != RESULT_EMPTY) {
found = true;
}
if (findFieldIndex && fieldName == field->getName()) {
if (fieldIndex == 0) {
if (!found) {
return RESULT_ERR_NOTFOUND;
}
break;
}
fieldIndex--;
}
}
if (!found) {
return RESULT_EMPTY;
}
return RESULT_OK;
}
result_t DataFieldSet::read(const SymbolString& data, size_t offset,
ostringstream& output, OutputFormat outputFormat, ssize_t outputIndex,
bool leadingSeparator, const char* fieldName, ssize_t fieldIndex) const {
bool previousFullByteOffset = true, found = false, findFieldIndex = fieldName != NULL && fieldIndex >= 0;
if (outputIndex < 0 && (!m_uniqueNames || ((outputFormat & OF_JSON) && !(outputFormat & OF_NAMES)))) {
outputIndex = 0;
}
PartType partType = data.isMaster() ? pt_masterData : pt_slaveData;
for (const auto field : m_fields) {
if (field->getPartType() != partType) {
if (outputIndex >= 0 && !field->isIgnored()) {
outputIndex++;
}
continue;
}
if (!previousFullByteOffset && !field->hasFullByteOffset(false)) {
offset--;
}
result_t result = field->read(data, offset, output, outputFormat, outputIndex, leadingSeparator,
fieldName, fieldIndex);
if (result < RESULT_OK) {
return result;
}
offset += field->getLength(partType, data.getDataSize()-offset);
previousFullByteOffset = field->hasFullByteOffset(true);
if (result != RESULT_EMPTY) {
found = true;
leadingSeparator = true;
}
if (findFieldIndex && fieldName == field->getName()) {
if (fieldIndex == 0) {
if (!found) {
return RESULT_ERR_NOTFOUND;
}
break;
}
fieldIndex--;
}
if (outputIndex >= 0 && !field->isIgnored()) {
outputIndex++;
}
}
if (!found) {
return RESULT_EMPTY;
}
return RESULT_OK;
}
result_t DataFieldSet::write(istringstream& input, SymbolString& data,
size_t offset, char separator, size_t* length) const {
string token;
PartType partType = data.isMaster() ? pt_masterData : pt_slaveData;
bool previousFullByteOffset = true;
size_t baseOffset = offset;
for (const auto field : m_fields) {
if (field->getPartType() != partType) {
continue;
}
if (!previousFullByteOffset && !field->hasFullByteOffset(false)) {
offset--;
}
result_t result;
size_t fieldLength;
if (m_fields.size() > 1) {
if (field->isIgnored()) {
token.clear();
} else if (!getline(input, token, separator)) {
token.clear();
}
istringstream single(token);
result = field->write(single, data, offset, separator, &fieldLength);
} else {
result = field->write(input, data, offset, separator, &fieldLength);
}
if (result != RESULT_OK) {
return result;
}
offset += fieldLength;
previousFullByteOffset = field->hasFullByteOffset(true);
}
if (length != NULL) {
*length = offset-baseOffset;
}
return RESULT_OK;
}
DataFieldTemplates::DataFieldTemplates(DataFieldTemplates& other)
: MappedFileReader::MappedFileReader(false) {
for (const auto it : other.m_fieldsByName) {
m_fieldsByName[it.first] = it.second->clone();
}
}
void DataFieldTemplates::clear() {
for (auto it : m_fieldsByName) {
delete it.second;
it.second = NULL;
}
m_fieldsByName.clear();
}
result_t DataFieldTemplates::add(const DataField* field, string name, bool replace) {
if (name.length() == 0) {
name = field->getName();
}
const auto it = m_fieldsByName.find(name);
if (it != m_fieldsByName.end()) {
if (!replace) {
return RESULT_ERR_DUPLICATE_NAME; // duplicate key
}
delete it->second;
it->second = field;
return RESULT_OK;
}
m_fieldsByName[name] = field;
return RESULT_OK;
}
result_t DataFieldTemplates::getFieldMap(vector<string>& row, string& errorDescription, const string preferLanguage)
const {
// name[:usename],basetype[:len]|template[:usename][,[divisor|values][,[unit][,[comment]]]]
if (row.empty()) {
// default map does not include separate field name
for (const auto& col : defaultTemplateFieldMap) {
row.push_back(col);
}
return RESULT_OK;
}
bool inDataFields = false;
map<string, size_t> seen;
for (size_t col = 0; col < row.size(); col++) {
string &name = row[col];
string lowerName = name;
tolower(lowerName);
trim(lowerName);
if (lowerName.empty()) {
errorDescription = "missing name in column " + AttributedItem::formatInt(col);
return RESULT_ERR_INVALID_ARG;
}
bool supportsLang = false;
string useName = getDataFieldName(lowerName, supportsLang);
bool unknown = useName.empty();
size_t langPos = supportsLang ? lowerName.find_last_of('.') : string::npos;
map<string, size_t>::iterator previous;
if (langPos == lowerName.length()-3) {
string lang = lowerName.substr(langPos+1);
if (unknown) {
useName = lowerName.substr(0, langPos);
}
previous = seen.find(useName);
if (previous != seen.end()) {
if (lang != preferLanguage) {
// skip this column
name = SKIP_COLUMN;
continue;
}
// replace previous
row[previous->second] = SKIP_COLUMN;
seen.erase(useName);
previous = seen.end();
}
} else {
if (unknown) {
useName = lowerName;
}
previous = seen.find(useName);
}
if (inDataFields) {
if (!unknown && previous != seen.end()) {
if (seen.find("type") == seen.end()) {
errorDescription = "missing field type";
return RESULT_ERR_EOF; // require at least type
}
seen.clear();
}
} else {
if (!unknown && useName == "name" && seen.find("name") == seen.end()) {
// keep first name for template
} else if (!unknown) {
if (seen.find("name") == seen.end()) {
errorDescription = "missing template name";
return RESULT_ERR_EOF; // require at least name
}
inDataFields = true;
seen.clear();
}
if (!inDataFields && seen.find(useName) != seen.end()) {
errorDescription = "duplicate template " + useName;
return RESULT_ERR_INVALID_ARG;
}
}
if (seen.empty() && inDataFields) {
name = "*" + useName; // data field repetition
} else {
name = useName;
}
seen[useName] = col;
}
if (!inDataFields) {
errorDescription = "missing template fields";
return RESULT_ERR_EOF; // require at least one field
}
if (seen.find("type") == seen.end()) {
errorDescription = "missing field type";
return RESULT_ERR_EOF; // require at least type
}
return RESULT_OK;
}
result_t DataFieldTemplates::addFromFile(map<string, string>& row, vector< map<string, string> >& subRows,
string& errorDescription, const string filename, unsigned int lineNo) {
string name = row["name"]; // required
string firstFieldName;
size_t colon = name.find(':');
if (colon == string::npos) {
firstFieldName = name;
} else {
firstFieldName = name.substr(colon+1);
name = name.substr(0, colon);
}
const DataField* field = NULL;
if (!subRows.empty() && subRows[0].find("name") == subRows[0].end()) {
subRows[0]["name"] = firstFieldName;
}
result_t result = DataField::create(subRows, errorDescription, this, field, false, true, false);
if (result != RESULT_OK) {
return result;
}
result = add(field, name, true);
if (result == RESULT_ERR_DUPLICATE_NAME) {
errorDescription = name;
}
if (result != RESULT_OK) {
delete field;
}
return result;
}
const DataField* DataFieldTemplates::get(const string name) const {
const auto ref = m_fieldsByName.find(name);
if (ref == m_fieldsByName.end()) {
return NULL;
}
return ref->second;
}
} // namespace ebusd
Reference in New Issue View Git Blame Copy Permalink