Mercurial Mercurial > relpipe > relpipe-in-cbortable.cpp / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/XMLDocumentConstructor.h
branchv_0
changeset 31 273faff8b848
parent 30 f5ac2d29eeb4
child 32 82b7f6e41a65
equal deleted inserted replaced
30:f5ac2d29eeb4 31:273faff8b848 
    36 private:
 
    36 private:
 
    37 	std::istream* input = nullptr;
 
    37 	std::istream* input = nullptr;
 
    38 	xmlpp::DomParser* parser = nullptr;
 
    38 	xmlpp::DomParser* parser = nullptr;
 
    39 	XMLNameCodec nameCodec;
 
    39 	XMLNameCodec nameCodec;
 
    40 
    40 
       
    41 	enum class Mode {
 
       
    42 		ROOT,
 
       
    43 		SEQUENCE,
 
       
    44 		MAPPING,
 
       
    45 		MAP_KEY
 
       
    46 	};
 
       
    47 
    41 	std::string rootName = "cbor";
 
    48 	std::string rootName = "cbor";
 
    42 	xmlpp::Element* current;
 
    49 	xmlpp::Element* current;
 
       
    50 	std::vector<Mode> mode;
 
    43 
    51 
    44 	cbor_callbacks callbacks = cbor_empty_callbacks;
 
    52 	cbor_callbacks callbacks = cbor_empty_callbacks;
 
    45 
    53 
    46 	/**
 
    54 	/**
 
    47 	 * Both CBOR and XML strings are in UTF-8.
 
    55 	 * Both CBOR and XML strings are in UTF-8.
 
    56 
    64 
    57 	xmlpp::Element* parentOrSelf(xmlpp::Element* current) {
 
    65 	xmlpp::Element* parentOrSelf(xmlpp::Element* current) {
 
    58 		return current->get_parent() == nullptr ? current : current->get_parent();
 
    66 		return current->get_parent() == nullptr ? current : current->get_parent();
 
    59 	}
 
    67 	}
 
    60 
    68 
       
    69 	void appendScalarValue(Glib::ustring value, Glib::ustring cborType, bool isNull = false) {
 
       
    70 		// TODO: different behavior depending on mode
 
       
    71 		xmlpp::Element* element = current->add_child("scalar");
 
       
    72 		element->add_child_text(value);
 
       
    73 		element->set_attribute("type", cborType);
 
       
    74 	}
 
       
    75 
    61 public:
 
    76 public:
 
    62 
    77 
    63 	XMLDocumentConstructor(std::istream* input, xmlpp::DomParser* parser) : input(input), parser(parser) {
 
    78 	XMLDocumentConstructor(std::istream* input, xmlpp::DomParser* parser) : input(input), parser(parser) {
 
    64 
    79 
    65 #define CBOR_CALLBACK_START if (XMLDocumentConstructor* instance = static_cast<XMLDocumentConstructor*> (context)) {
 
    80 #define CBOR_CALLBACK_START if (XMLDocumentConstructor* instance = static_cast<XMLDocumentConstructor*> (context)) {
 
    66 #define CBOR_CALLBACK_END } else throw relpipe::writer::RelpipeWriterException(L"Invalid context in the CBOR callback.");
 
    81 #define CBOR_CALLBACK_END } else throw relpipe::writer::RelpipeWriterException(L"Invalid context in the CBOR callback.");
 
    67 
    82 
    68 		callbacks.array_start = [](void* context, size_t size) {
 
    83 		callbacks.array_start = [](void* context, size_t size) {
 
    69 			CBOR_CALLBACK_START
 
    84 			CBOR_CALLBACK_START
 
       
    85 			// TODO: implement
 
    70 			xmlpp::Element* element = instance->current->add_child("array-start");
 
    86 			xmlpp::Element* element = instance->current->add_child("array-start");
 
       
    87 			element->set_attribute("size", std::to_string(size));
 
    71 			CBOR_CALLBACK_END
 
    88 			CBOR_CALLBACK_END
 
    72 		};
 
    89 		};
 
    73 
    90 
    74 		callbacks.boolean = [](void* context, bool value) {
 
    91 		callbacks.boolean = [](void* context, bool value) {
 
    75 			CBOR_CALLBACK_START
 
    92 			CBOR_CALLBACK_START
 
    76 			xmlpp::Element* element = instance->current->add_child("boolean");
 
    93 			instance->appendScalarValue(value ? "true" : "false", "boolean");
 
    77 			element->add_child_text(value ? "true" : "false");
 
       
    78 			CBOR_CALLBACK_END
 
    94 			CBOR_CALLBACK_END
 
    79 		};
 
    95 		};
 
    80 
    96 
    81 		callbacks.byte_string = [](void* context, cbor_data value, uint64_t size) {
 
    97 		callbacks.byte_string = [](void* context, cbor_data value, uint64_t size) {
 
    82 			CBOR_CALLBACK_START
 
    98 			CBOR_CALLBACK_START
 
    83 			xmlpp::Element* element = instance->current->add_child("byte-string");
 
       
    84 			element->set_attribute("size", std::to_string(size));
 
       
    85 			std::stringstream hex;
 
    99 			std::stringstream hex;
 
    86 			hex << std::hex << std::setfill('0') << std::setw(2);
 
   100 			hex << std::hex << std::setfill('0') << std::setw(2);
 
    87 			for (uint64_t i = 0; i < size; i++) hex << (int) value[i];
 
   101 			for (uint64_t i = 0; i < size; i++) hex << (int) value[i];
 
    88 			element->add_child_text(hex.str());
 
   102 			instance->appendScalarValue(hex.str(), "byte-string");
 
    89 			CBOR_CALLBACK_END
 
   103 			CBOR_CALLBACK_END
 
    90 		};
 
   104 		};
 
    91 
   105 
    92 		callbacks.byte_string_start = [](void* context) {
 
   106 		callbacks.byte_string_start = [](void* context) {
 
    93 			CBOR_CALLBACK_START
 
   107 			CBOR_CALLBACK_START
 
       
   108 			// TODO: implement
 
    94 			xmlpp::Element* element = instance->current->add_child("byte-string-start");
 
   109 			xmlpp::Element* element = instance->current->add_child("byte-string-start");
 
    95 			CBOR_CALLBACK_END
 
   110 			CBOR_CALLBACK_END
 
    96 		};
 
   111 		};
 
    97 
   112 
    98 		callbacks.float2 = [](void* context, float value) {
 
   113 		callbacks.float2 = [](void* context, float value) {
 
    99 			CBOR_CALLBACK_START
 
   114 			CBOR_CALLBACK_START
 
   100 			xmlpp::Element* element = instance->current->add_child("float2");
 
   115 			instance->appendScalarValue(std::to_string(value), "float2");
 
   101 			element->add_child_text(std::to_string(value));
 
       
   102 			CBOR_CALLBACK_END
 
   116 			CBOR_CALLBACK_END
 
   103 		};
 
   117 		};
 
   104 
   118 
   105 		callbacks.float4 = [](void* context, float value) {
 
   119 		callbacks.float4 = [](void* context, float value) {
 
   106 			CBOR_CALLBACK_START
 
   120 			CBOR_CALLBACK_START
 
   107 			xmlpp::Element* element = instance->current->add_child("float4");
 
   121 			instance->appendScalarValue(std::to_string(value), "float4");
 
   108 			element->add_child_text(std::to_string(value));
 
       
   109 			CBOR_CALLBACK_END
 
   122 			CBOR_CALLBACK_END
 
   110 		};
 
   123 		};
 
   111 
   124 
   112 		callbacks.float8 = [](void* context, double value) {
 
   125 		callbacks.float8 = [](void* context, double value) {
 
   113 			CBOR_CALLBACK_START
 
   126 			CBOR_CALLBACK_START
 
   114 			xmlpp::Element* element = instance->current->add_child("float8");
 
   127 			instance->appendScalarValue(std::to_string(value), "float8");
 
   115 			element->add_child_text(std::to_string(value));
 
       
   116 			CBOR_CALLBACK_END
 
   128 			CBOR_CALLBACK_END
 
   117 		};
 
   129 		};
 
   118 
   130 
   119 		callbacks.indef_array_start = [](void* context) {
 
   131 		callbacks.indef_array_start = [](void* context) {
 
   120 			CBOR_CALLBACK_START
 
   132 			CBOR_CALLBACK_START
 
       
   133 			// TODO: implement
 
   121 			xmlpp::Element* element = instance->current->add_child("array-start");
 
   134 			xmlpp::Element* element = instance->current->add_child("array-start");
 
   122 			CBOR_CALLBACK_END
 
   135 			CBOR_CALLBACK_END
 
   123 		};
 
   136 		};
 
   124 
   137 
   125 		callbacks.indef_map_start = [](void* context) {
 
   138 		callbacks.indef_map_start = [](void* context) {
 
   126 			CBOR_CALLBACK_START
 
   139 			CBOR_CALLBACK_START
 
       
   140 			// TODO: implement
 
   127 			xmlpp::Element* element = instance->current->add_child("map-start");
 
   141 			xmlpp::Element* element = instance->current->add_child("map-start");
 
   128 			CBOR_CALLBACK_END
 
   142 			CBOR_CALLBACK_END
 
   129 		};
 
   143 		};
 
   130 
   144 
   131 		callbacks.indef_break = [](void* context) {
 
   145 		callbacks.indef_break = [](void* context) {
 
   132 			CBOR_CALLBACK_START
 
   146 			CBOR_CALLBACK_START
 
       
   147 			// TODO: implement
 
   133 			xmlpp::Element* element = instance->current->add_child("indef-break");
 
   148 			xmlpp::Element* element = instance->current->add_child("indef-break");
 
   134 			CBOR_CALLBACK_END
 
   149 			CBOR_CALLBACK_END
 
   135 		};
 
   150 		};
 
   136 
   151 
   137 		callbacks.map_start = [](void* context, size_t size) {
 
   152 		callbacks.map_start = [](void* context, size_t size) {
 
   138 			CBOR_CALLBACK_START
 
   153 			CBOR_CALLBACK_START
 
       
   154 			// TODO: implement
 
   139 			xmlpp::Element* element = instance->current->add_child("map-start");
 
   155 			xmlpp::Element* element = instance->current->add_child("map-start");
 
   140 			element->set_attribute("size", std::to_string(size));
 
   156 			element->set_attribute("size", std::to_string(size));
 
   141 			CBOR_CALLBACK_END
 
   157 			CBOR_CALLBACK_END
 
   142 		};
 
   158 		};
 
   143 
   159 
   144 		callbacks.negint8 = [](void* context, uint8_t value) {
 
   160 		callbacks.negint8 = [](void* context, uint8_t value) {
 
   145 			CBOR_CALLBACK_START
 
   161 			CBOR_CALLBACK_START
 
   146 			xmlpp::Element* element = instance->current->add_child("negative-int8");
 
   162 			instance->appendScalarValue(std::to_string(value), "negative-int8");
 
   147 			element->add_child_text(std::to_string(value));
 
       
   148 			CBOR_CALLBACK_END
 
   163 			CBOR_CALLBACK_END
 
   149 		};
 
   164 		};
 
   150 
   165 
   151 		callbacks.negint16 = [](void* context, uint16_t value) {
 
   166 		callbacks.negint16 = [](void* context, uint16_t value) {
 
   152 			CBOR_CALLBACK_START
 
   167 			CBOR_CALLBACK_START
 
   153 			xmlpp::Element* element = instance->current->add_child("negative-int16");
 
   168 			instance->appendScalarValue(std::to_string(value), "negative-int16");
 
   154 			element->add_child_text(std::to_string(value));
 
       
   155 			CBOR_CALLBACK_END
 
   169 			CBOR_CALLBACK_END
 
   156 		};
 
   170 		};
 
   157 
   171 
   158 		callbacks.negint32 = [](void* context, uint32_t value) {
 
   172 		callbacks.negint32 = [](void* context, uint32_t value) {
 
   159 			CBOR_CALLBACK_START
 
   173 			CBOR_CALLBACK_START
 
   160 			xmlpp::Element* element = instance->current->add_child("negative-int32");
 
   174 			instance->appendScalarValue(std::to_string(value), "negative-int32");
 
   161 			element->add_child_text(std::to_string(value));
 
       
   162 			CBOR_CALLBACK_END
 
   175 			CBOR_CALLBACK_END
 
   163 		};
 
   176 		};
 
   164 
   177 
   165 		callbacks.negint64 = [](void* context, uint64_t value) {
 
   178 		callbacks.negint64 = [](void* context, uint64_t value) {
 
   166 			CBOR_CALLBACK_START
 
   179 			CBOR_CALLBACK_START
 
   167 			xmlpp::Element* element = instance->current->add_child("negative-int64");
 
   180 			instance->appendScalarValue(std::to_string(value), "negative-int64");
 
   168 			element->add_child_text(std::to_string(value));
 
       
   169 			CBOR_CALLBACK_END
 
   181 			CBOR_CALLBACK_END
 
   170 		};
 
   182 		};
 
   171 
   183 
   172 		callbacks.null = [](void* context) {
 
   184 		callbacks.null = [](void* context) {
 
   173 			CBOR_CALLBACK_START
 
   185 			CBOR_CALLBACK_START
 
   174 			xmlpp::Element* element = instance->current->add_child("null");
 
   186 			instance->appendScalarValue("", "null", true);
 
   175 			CBOR_CALLBACK_END
 
   187 			CBOR_CALLBACK_END
 
   176 		};
 
   188 		};
 
   177 
   189 
   178 		callbacks.string = [](void* context, cbor_data value, uint64_t size) {
 
   190 		callbacks.string = [](void* context, cbor_data value, uint64_t size) {
 
   179 			CBOR_CALLBACK_START
 
   191 			CBOR_CALLBACK_START
 
   180 			xmlpp::Element* element = instance->current->add_child("string");
 
   192 			instance->appendScalarValue(c2x(value, size), "string");
 
   181 			element->set_attribute("size", std::to_string(size));
 
       
   182 			element->add_child_text(c2x(value, size));
 
       
   183 			CBOR_CALLBACK_END
 
   193 			CBOR_CALLBACK_END
 
   184 		};
 
   194 		};
 
   185 
   195 
   186 		callbacks.string_start = [](void* context) {
 
   196 		callbacks.string_start = [](void* context) {
 
   187 			CBOR_CALLBACK_START
 
   197 			CBOR_CALLBACK_START
 
       
   198 			// TODO: implement
 
   188 			xmlpp::Element* element = instance->current->add_child("string-start");
 
   199 			xmlpp::Element* element = instance->current->add_child("string-start");
 
   189 			CBOR_CALLBACK_END
 
   200 			CBOR_CALLBACK_END
 
   190 		};
 
   201 		};
 
   191 
   202 
   192 		callbacks.tag = [](void* context, uint64_t value) {
 
   203 		callbacks.tag = [](void* context, uint64_t value) {
 
   193 			CBOR_CALLBACK_START
 
   204 			CBOR_CALLBACK_START
 
       
   205 			// TODO: implement
 
   194 			xmlpp::Element* element = instance->current->add_child("tag");
 
   206 			xmlpp::Element* element = instance->current->add_child("tag");
 
   195 			element->add_child_text(std::to_string(value));
 
   207 			element->add_child_text(std::to_string(value));
 
   196 			CBOR_CALLBACK_END
 
   208 			CBOR_CALLBACK_END
 
   197 		};
 
   209 		};
 
   198 
   210 
   199 		callbacks.uint8 = [](void* context, uint8_t value) {
 
   211 		callbacks.uint8 = [](void* context, uint8_t value) {
 
   200 			CBOR_CALLBACK_START
 
   212 			CBOR_CALLBACK_START
 
   201 			xmlpp::Element* element = instance->current->add_child("uint8");
 
   213 			instance->appendScalarValue(std::to_string(value), "uint8");
 
   202 			element->add_child_text(std::to_string(value));
 
       
   203 			CBOR_CALLBACK_END
 
   214 			CBOR_CALLBACK_END
 
   204 		};
 
   215 		};
 
   205 
   216 
   206 		callbacks.uint16 = [](void* context, uint16_t value) {
 
   217 		callbacks.uint16 = [](void* context, uint16_t value) {
 
   207 			CBOR_CALLBACK_START
 
   218 			CBOR_CALLBACK_START
 
   208 			xmlpp::Element* element = instance->current->add_child("uint16");
 
   219 			instance->appendScalarValue(std::to_string(value), "uint16");
 
   209 			element->add_child_text(std::to_string(value));
 
       
   210 			CBOR_CALLBACK_END
 
   220 			CBOR_CALLBACK_END
 
   211 		};
 
   221 		};
 
   212 
   222 
   213 		callbacks.uint32 = [](void* context, uint32_t value) {
 
   223 		callbacks.uint32 = [](void* context, uint32_t value) {
 
   214 			CBOR_CALLBACK_START
 
   224 			CBOR_CALLBACK_START
 
   215 			xmlpp::Element* element = instance->current->add_child("uint32");
 
   225 			instance->appendScalarValue(std::to_string(value), "uint32");
 
   216 			element->add_child_text(std::to_string(value));
 
       
   217 			CBOR_CALLBACK_END
 
   226 			CBOR_CALLBACK_END
 
   218 		};
 
   227 		};
 
   219 
   228 
   220 		callbacks.uint64 = [](void* context, uint64_t value) {
 
   229 		callbacks.uint64 = [](void* context, uint64_t value) {
 
   221 			CBOR_CALLBACK_START
 
   230 			CBOR_CALLBACK_START
 
   222 			xmlpp::Element* element = instance->current->add_child("uint64");
 
   231 			instance->appendScalarValue(std::to_string(value), "uint64");
 
   223 			element->add_child_text(std::to_string(value));
 
       
   224 			CBOR_CALLBACK_END
 
   232 			CBOR_CALLBACK_END
 
   225 		};
 
   233 		};
 
   226 
   234 
   227 		callbacks.undefined = [](void* context) {
 
   235 		callbacks.undefined = [](void* context) {
 
   228 			CBOR_CALLBACK_START
 
   236 			CBOR_CALLBACK_START
 
   229 			xmlpp::Element* element = instance->current->add_child("undefined");
 
   237 			instance->appendScalarValue("undefined", "undefined", true); // FIXME: throw exception?
 
   230 			CBOR_CALLBACK_END
 
   238 			CBOR_CALLBACK_END
 
   231 		};
 
   239 		};
 
   232 
   240 
   233 	}
 
   241 	}
 
   234 
   242
relpipe/relpipe-in-cbortable.cpp