# HG changeset patch # User František Kučera # Date 1531603462 -7200 # Node ID 489e521387711fae1c4a06a85b6f202a853920b6 # Parent e4543a40a85f16195d04b24025a46132f459de8c add data type and catalog classes from the prototype diff -r e4543a40a85f -r 489e52138771 src/BooleanDataType.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/BooleanDataType.h Sat Jul 14 23:24:22 2018 +0200 @@ -0,0 +1,45 @@ +#pragma once + +#include +#include + +#include "DataType.h" +#include "RelpipeException.h" + +using namespace std; + +namespace rp_prototype { + +class BooleanDataType : public DataType { +private: + const wstring TRUE = L"true"; + const wstring FALSE = L"false"; +public: + + BooleanDataType() : DataType(DATA_TYPE_ID_BOOLEAN, DATA_TYPE_CODE_BOOLEAN) { + } + + bool readValue(istream &input) override { + auto value = input.get(); // TODO: check failbit + if (value == 0) return false; + else if (value == 1) return true; + else throw RelpipeException(L"Unable to convert the octet to boolean", EXIT_CODE_DATA_ERROR); + } + + void writeValue(ostream &output, const bool &value) override { + output.put(value ? 1 : 0); + } + + bool toValue(const wstring &stringValue) override { + if (stringValue == TRUE) return true; + else if (stringValue == FALSE) return false; + else throw RelpipeException(L"Unable to convert the string to boolean", EXIT_CODE_DATA_ERROR); + } + + wstring toString(const bool &value) override { + return value ? TRUE : FALSE; + } + +}; + +} \ No newline at end of file diff -r e4543a40a85f -r 489e52138771 src/DataTypeCatalog.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/DataTypeCatalog.h Sat Jul 14 23:24:22 2018 +0200 @@ -0,0 +1,47 @@ +#pragma once + +#include +#include +#include + +#include "common.h" +#include "DataType.h" +#include "BooleanDataType.h" +#include "IntegerDataType.h" +#include "StringDataType.h" + +using namespace std; + +namespace rp_prototype { + +class DataTypeCatalog { +private: + BooleanDataType booleanType; + IntegerDataType integerType; + StringDataType stringType; + vector types = {&booleanType, &integerType, &stringType}; +public: + + integer_t toTypeId(const wstring typeCode) { + for (DataTypeBase* dataType : types) if (dataType->supports(typeCode)) return dataType->getTypeId(); + throw RelpipeException(L"Unsupported data type: " + typeCode, EXIT_CODE_DATA_ERROR); + } + + wstring toTypeCode(const integer_t typeId) { + for (DataTypeBase* dataType : types) if (dataType->supports(typeId)) return dataType->getTypeCode(); + throw RelpipeException(L"Unsupported data type: " + typeId, EXIT_CODE_DATA_ERROR); + } + + void writeString(ostream &output, const wstring &stringValue, const integer_t typeId) { + for (DataTypeBase* dataType : types) if (dataType->supports(typeId)) return dataType->writeString(output, stringValue); + throw RelpipeException(L"Unsupported data type: " + typeId, EXIT_CODE_DATA_ERROR); + } + + wstring readString(istream &input, const integer_t typeId) { + for (DataTypeBase* dataType : types) if (dataType->supports(typeId)) return dataType->readString(input); + throw RelpipeException(L"Unsupported data type: " + typeId, EXIT_CODE_DATA_ERROR); + } + +}; + +} \ No newline at end of file diff -r e4543a40a85f -r 489e52138771 src/IntegerDataType.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/IntegerDataType.h Sat Jul 14 23:24:22 2018 +0200 @@ -0,0 +1,131 @@ +#pragma once + +#include +#include +#include +#include + +#include "common.h" +#include "DataType.h" +#include "RelpipeException.h" + +using namespace std; + +namespace rp_prototype { + +/** + * The prototype does not have various integer and other numeric data types, + * it just works with one type of integer. + * But this integer has variable length -- smaller values occupy only one byte, bigger ones, more bytes 1,2,4,8 + first byte (contains length signalization). + * In the real implementation of relational pipes, there will be DataTypes for particular numeric types. + * + * TODO: support also big endian architectures. + * TODO: throw exception if a value was stored in bigger type than needed (while reading – there should be only one supported way how to encode a single value) + * + * Example of encoded values: + * ------------------------------------------------------------------------------------------------- + * $ for n in 0 1 10 250 251 252 65535 65536 4294967295 4294967296 18446744073709551615; do printf '%20s = ' $n; dist/Debug/GNU-Linux/rp-prototype write integer $n | hd | head -n 1; done + * 0 = 00000000 00 |.| + * 1 = 00000000 01 |.| + * 10 = 00000000 0a |.| + * 250 = 00000000 fa |.| + * 251 = 00000000 fb fb |..| + * 252 = 00000000 fb fc |..| + * 65535 = 00000000 fc ff ff |...| + * 65536 = 00000000 fd 00 00 01 00 |.....| + * 4294967295 = 00000000 fd ff ff ff ff |.....| + * 4294967296 = 00000000 fe 00 00 00 00 01 00 00 00 |.........| + * 18446744073709551615 = 00000000 fe ff ff ff ff ff ff ff ff |.........| + * ------------------------------------------------------------------------------------------------- + * + * Example of decoded values: + * ------------------------------------------------------------------------------------------------- + * $ for n in 0 1 10 250 251 252 65535 65536 4294967295 4294967296 18446744073709551615; do dist/Debug/GNU-Linux/rp-prototype write integer $n | dist/Debug/GNU-Linux/rp-prototype read integer; done; + * 0 + * 1 + * 10 + * 250 + * 251 + * 252 + * 65535 + * 65536 + * 4294967295 + * 4294967296 + * 18446744073709551615 + * ------------------------------------------------------------------------------------------------- + * + * Note: similar format as original idea: https://en.wikipedia.org/wiki/X.690#Length_octets + * + */ +class IntegerDataType : public DataType { +private: + static const uint8_t INTEGER_TYPE_UINT8 = 251; + static const uint8_t INTEGER_TYPE_UINT16 = 252; + static const uint8_t INTEGER_TYPE_UINT32 = 253; + static const uint8_t INTEGER_TYPE_UINT64 = 254; + static const uint8_t INTEGER_TYPE_RESERVED = 255; + + template integer_t read(istream &input) { + T value = 0; + input.read(reinterpret_cast (&value), sizeof (value)); + return value; + } + + template void write(ostream &output, const integer_t &value) { + assert(sizeof (T) <= sizeof (value)); + output.write(reinterpret_cast (&value), sizeof (T)); + } + + template void write(ostream &output, const uint8_t type, const integer_t &value) { + write(output, type); + write(output, value); + } + + template bool fits(const integer_t &value) { + return value <= numeric_limits::max(); + } + +public: + + IntegerDataType() : DataType(DATA_TYPE_ID_INTEGER, DATA_TYPE_CODE_INTEGER) { + } + + integer_t readValue(istream &input) override { + uint8_t first; + input.read(reinterpret_cast (&first), sizeof (first)); + if (input.good()) { + + if (first < INTEGER_TYPE_UINT8) return first; + else if (first == INTEGER_TYPE_UINT8) return read(input); + else if (first == INTEGER_TYPE_UINT16) return read(input); + else if (first == INTEGER_TYPE_UINT32) return read(input); + else if (first == INTEGER_TYPE_UINT64) return read(input); + else throw RelpipeException(L"Error while parsing integer type: unsupported type", EXIT_CODE_DATA_ERROR); + } else { + throw RelpipeException(L"Error while reading integer from the stream.", EXIT_CODE_DATA_ERROR); + } + } + + void writeValue(ostream &output, const integer_t &value) override { + // output << value; // by zapsalo číslo jako ASII text + + if (value < INTEGER_TYPE_UINT8) write(output, value); + else if (fits(value)) write(output, INTEGER_TYPE_UINT8, value); + else if (fits(value)) write(output, INTEGER_TYPE_UINT16, value); + else if (fits(value)) write(output, INTEGER_TYPE_UINT32, value); + else if (fits(value)) write(output, INTEGER_TYPE_UINT64, value); + else throw RelpipeException(L"Error while writing integer type: value too long", EXIT_CODE_DATA_ERROR); + } + + integer_t toValue(const wstring &stringValue) override { + // throws „terminate called after throwing an instance of 'std::invalid_argument'“ SIGABRT, core dumped on invalid number + return stoul(stringValue); + } + + wstring toString(const integer_t &value) override { + return to_wstring(value); + } + +}; + +} \ No newline at end of file diff -r e4543a40a85f -r 489e52138771 src/StringDataType.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/StringDataType.h Sat Jul 14 23:24:22 2018 +0200 @@ -0,0 +1,61 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "DataType.h" +#include "RelpipeException.h" +#include "IntegerDataType.h" + +using namespace std; + +namespace rp_prototype { + +/** + * The prototype does not recognize any encoding, + * it just works with c++ strings in encoding default to given platform. + * In the real implementation of relational pipes, there will be DataTypes for particular encodings. + */ +class StringDataType : public DataType { +private: + IntegerDataType integerType; + wstring_convert> convertor; // TODO: support also other encodings. +public: + + StringDataType() : DataType(DATA_TYPE_ID_STRING, DATA_TYPE_CODE_STRING) { + } + + wstring readValue(istream &input) override { + integer_t length = integerType.readValue(input); + // TODO: check maximum length of single field + // if (length > 4000) throw RelpipeException("data too long", EXIT_CODE_DATA_ERROR); + vector buf(length); + input.read(buf.data(), length); + if (input.good()) { + return convertor.from_bytes(string(buf.data(), length)); + } else { + throw RelpipeException(L"Error while reading string from the stream.", EXIT_CODE_DATA_ERROR); + } + } + + void writeValue(ostream &output, const wstring &value) override { + string s = convertor.to_bytes(value); + integerType.writeValue(output, s.length()); + output << s.c_str(); + } + + wstring toValue(const wstring &stringValue) override { + return stringValue; + } + + wstring toString(const wstring &value) override { + return value; + } + +}; + +} \ No newline at end of file