http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/binary/binary_containers.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/binary/binary_containers.h b/modules/platforms/cpp/binary/include/ignite/binary/binary_containers.h new file mode 100644 index 0000000..946101c --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/binary/binary_containers.h @@ -0,0 +1,531 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Declares binary reader and writer types for the collections. + */ + +#ifndef _IGNITE_BINARY_BINARY_CONTAINERS +#define _IGNITE_BINARY_BINARY_CONTAINERS + +#include <stdint.h> + +#include <ignite/common/utils.h> + +#include "ignite/impl/binary/binary_writer_impl.h" +#include "ignite/impl/binary/binary_reader_impl.h" +#include "ignite/binary/binary_consts.h" + +namespace ignite +{ + namespace binary + { + /** + * Binary string array writer. + */ + class IGNITE_IMPORT_EXPORT BinaryStringArrayWriter + { + public: + /** + * Constructor. + * + * @param id Identifier. + * @param impl Writer. + */ + BinaryStringArrayWriter(impl::binary::BinaryWriterImpl* impl, int32_t id); + + /** + * Write string. + * + * @param val Null-terminated character sequence. + */ + void Write(const char* val); + + /** + * Write string. + * + * @param val String. + * @param len String length (characters). + */ + void Write(const char* val, int32_t len); + + /** + * Write string. + * + * @param val String. + */ + void Write(const std::string& val) + { + Write(val.c_str()); + } + + /** + * Close the writer. + */ + void Close(); + private: + /** Implementation delegate. */ + impl::binary::BinaryWriterImpl* impl; + + /** Idnetifier. */ + const int32_t id; + }; + + /** + * Binary collection writer. + */ + template<typename T> + class IGNITE_IMPORT_EXPORT BinaryArrayWriter + { + public: + /** + * Constructor. + * + * @param impl Writer. + * @param id Identifier. + */ + BinaryArrayWriter(impl::binary::BinaryWriterImpl* impl, int32_t id) : impl(impl), id(id) + { + // No-op. + } + + /** + * Write a value. + * + * @param val Value. + */ + void Write(const T& val) + { + impl->WriteElement<T>(id, val); + } + + /** + * Close the writer. + */ + void Close() + { + impl->CommitContainer(id); + } + private: + /** Implementation delegate. */ + impl::binary::BinaryWriterImpl* impl; + + /** Idnetifier. */ + const int32_t id; + }; + + /** + * Binary collection writer. + */ + template<typename T> + class IGNITE_IMPORT_EXPORT BinaryCollectionWriter + { + public: + /** + * Constructor. + * + * @param impl Writer. + * @param id Identifier. + */ + BinaryCollectionWriter(impl::binary::BinaryWriterImpl* impl, int32_t id) : impl(impl), id(id) + { + // No-op. + } + + /** + * Write a value. + * + * @param val Value. + */ + void Write(const T& val) + { + impl->WriteElement<T>(id, val); + } + + /** + * Close the writer. + */ + void Close() + { + impl->CommitContainer(id); + } + private: + /** Implementation delegate. */ + impl::binary::BinaryWriterImpl* impl; + + /** Identifier. */ + const int32_t id; + }; + + /** + * Binary map writer. + */ + template<typename K, typename V> + class IGNITE_IMPORT_EXPORT BinaryMapWriter + { + public: + /** + * Constructor. + * + * @param impl Writer. + */ + BinaryMapWriter(impl::binary::BinaryWriterImpl* impl, int32_t id) : impl(impl), id(id) + { + // No-op. + } + + /** + * Write a value. + * + * @param key Key. + * @param val Value. + */ + void Write(const K& key, const V& val) + { + impl->WriteElement<K, V>(id, key, val); + } + + /** + * Close the writer. + */ + void Close() + { + impl->CommitContainer(id); + } + private: + /** Implementation delegate. */ + impl::binary::BinaryWriterImpl* impl; + + /** Identifier. */ + const int32_t id; + }; + + /** + * Binary string array reader. + */ + class IGNITE_IMPORT_EXPORT BinaryStringArrayReader + { + public: + /** + * Constructor. + * + * @param impl Reader. + * @param id Identifier. + * @param size Array size. + */ + BinaryStringArrayReader(impl::binary::BinaryReaderImpl* impl, int32_t id, int32_t size); + + /** + * Check whether next element is available for read. + * + * @return True if available. + */ + bool HasNext(); + + /** + * Get next element. + * + * @param res Array to store data to. + * @param len Expected length of string. NULL terminator will be set in case len is + * greater than real string length. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t GetNext(char* res, int32_t len); + + /** + * Get next element. + * + * @return String. + */ + std::string GetNext() + { + int32_t len = GetNext(NULL, 0); + + if (len != -1) + { + common::SafeArray<char> arr(len + 1); + + GetNext(arr.target, len + 1); + + return std::string(arr.target); + } + else + return std::string(); + } + + /** + * Get array size. + * + * @return Size or -1 if array is NULL. + */ + int32_t GetSize() const; + + /** + * Whether array is NULL. + */ + bool IsNull() const; + private: + /** Implementation delegate. */ + impl::binary::BinaryReaderImpl* impl; + + /** Identifier. */ + const int32_t id; + + /** Size. */ + const int32_t size; + }; + + /** + * Binary array reader. + */ + template<typename T> + class BinaryArrayReader + { + public: + /** + * Constructor. + * + * @param impl Reader. + * @param id Identifier. + * @param size Array size. + */ + BinaryArrayReader(impl::binary::BinaryReaderImpl* impl, int32_t id, int32_t size) : + impl(impl), id(id), size(size) + { + // No-op. + } + + /** + * Check whether next element is available for read. + * + * @return True if available. + */ + bool HasNext() + { + return impl->HasNextElement(id); + } + + /** + * Read next element. + * + * @return Next element. + */ + T GetNext() + { + return impl->ReadElement<T>(id); + } + + /** + * Get array size. + * + * @return Size or -1 if array is NULL. + */ + int32_t GetSize() + { + return size; + } + + /** + * Whether array is NULL. + */ + bool IsNull() + { + return size == -1; + } + private: + /** Implementation delegate. */ + impl::binary::BinaryReaderImpl* impl; + + /** Identifier. */ + const int32_t id; + + /** Size. */ + const int32_t size; + }; + + /** + * Binary collection reader. + */ + template<typename T> + class BinaryCollectionReader + { + public: + /** + * Constructor. + * + * @param impl Reader. + * @param id Identifier. + * @param type Collection type. + * @param size Collection size. + */ + BinaryCollectionReader(impl::binary::BinaryReaderImpl* impl, int32_t id, + const CollectionType type, int32_t size) : impl(impl), id(id), type(type), size(size) + { + // No-op. + } + + /** + * Check whether next element is available for read. + * + * @return True if available. + */ + bool HasNext() + { + return impl->HasNextElement(id); + } + + /** + * Read next element. + * + * @return Next element. + */ + T GetNext() + { + return impl->ReadElement<T>(id); + } + + /** + * Get collection type. + * + * @return Type. + */ + CollectionType GetType() + { + return type; + } + + /** + * Get collection size. + * + * @return Size or -1 if collection is NULL. + */ + int32_t GetSize() + { + return size; + } + + /** + * Whether collection is NULL. + */ + bool IsNull() + { + return size == -1; + } + private: + /** Implementation delegate. */ + impl::binary::BinaryReaderImpl* impl; + + /** Identifier. */ + const int32_t id; + + /** Collection type. */ + const CollectionType type; + + /** Size. */ + const int32_t size; + }; + + /** + * Binary map reader. + */ + template<typename K, typename V> + class BinaryMapReader + { + public: + /** + * Constructor. + * + * @param impl Reader. + * @param id Identifier. + * @param type Map type. + * @param size Map size. + */ + BinaryMapReader(impl::binary::BinaryReaderImpl* impl, int32_t id, MapType type, + int32_t size) : impl(impl), id(id), type(type), size(size) + { + // No-op. + } + + /** + * Check whether next element is available for read. + * + * @return True if available. + */ + bool HasNext() + { + return impl->HasNextElement(id); + } + + /** + * Read next element. + * + * @param key Key. + * @param val Value. + */ + void GetNext(K* key, V* val) + { + return impl->ReadElement<K, V>(id, key, val); + } + + /** + * Get map type. + * + * @return Type. + */ + MapType GetType() + { + return type; + } + + /** + * Get map size. + * + * @return Size or -1 if map is NULL. + */ + int32_t GetSize() + { + return size; + } + + /** + * Whether map is NULL. + */ + bool IsNull() + { + return size == -1; + } + private: + /** Implementation delegate. */ + impl::binary::BinaryReaderImpl* impl; + + /** Identifier. */ + const int32_t id; + + /** Map type. */ + const MapType type; + + /** Size. */ + const int32_t size; + }; + } +} + +#endif //_IGNITE_BINARY_BINARY_CONTAINERS \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_reader.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_reader.h b/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_reader.h new file mode 100644 index 0000000..473be3d --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_reader.h @@ -0,0 +1,395 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Declares ignite::binary::BinaryRawReader class. + */ + +#ifndef _IGNITE_BINARY_BINARY_RAW_READER +#define _IGNITE_BINARY_BINARY_RAW_READER + +#include <stdint.h> +#include <string> + +#include <ignite/common/common.h> + +#include "ignite/impl/binary/binary_reader_impl.h" +#include "ignite/binary/binary_consts.h" +#include "ignite/binary/binary_containers.h" +#include "ignite/guid.h" +#include "ignite/date.h" +#include "ignite/timestamp.h" + +namespace ignite +{ + namespace binary + { + /** + * Binary raw reader. + */ + class IGNITE_IMPORT_EXPORT BinaryRawReader + { + public: + /** + * Constructor. + * + * @param impl Implementation. + */ + BinaryRawReader(ignite::impl::binary::BinaryReaderImpl* impl); + + /** + * Read 8-byte signed integer. Maps to "byte" type in Java. + * + * @return Result. + */ + int8_t ReadInt8(); + + /** + * Read array of 8-byte signed integers. Maps to "byte[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt8Array(int8_t* res, int32_t len); + + /** + * Read bool. Maps to "boolean" type in Java. + * + * @return Result. + */ + bool ReadBool(); + + /** + * Read array of bools. Maps to "boolean[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadBoolArray(bool* res, int32_t len); + + /** + * Read 16-byte signed integer. Maps to "short" type in Java. + * + * @return Result. + */ + int16_t ReadInt16(); + + /** + * Read array of 16-byte signed integers. Maps to "short[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt16Array(int16_t* res, int32_t len); + + /** + * Read 16-byte unsigned integer. Maps to "char" type in Java. + * + * @return Result. + */ + uint16_t ReadUInt16(); + + /** + * Read array of 16-byte unsigned integers. Maps to "char[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadUInt16Array(uint16_t* res, int32_t len); + + /** + * Read 32-byte signed integer. Maps to "int" type in Java. + * + * @return Result. + */ + int32_t ReadInt32(); + + /** + * Read array of 32-byte signed integers. Maps to "int[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt32Array(int32_t* res, int32_t len); + + /** + * Read 64-byte signed integer. Maps to "long" type in Java. + * + * @return Result. + */ + int64_t ReadInt64(); + + /** + * Read array of 64-byte signed integers. Maps to "long[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt64Array(int64_t* res, int32_t len); + + /** + * Read float. Maps to "float" type in Java. + * + * @return Result. + */ + float ReadFloat(); + + /** + * Read array of floats. Maps to "float[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadFloatArray(float* res, int32_t len); + + /** + * Read double. Maps to "double" type in Java. + * + * @return Result. + */ + double ReadDouble(); + + /** + * Read array of doubles. Maps to "double[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadDoubleArray(double* res, int32_t len); + + /** + * Read Guid. Maps to "UUID" type in Java. + * + * @return Result. + */ + Guid ReadGuid(); + + /** + * Read array of Guids. Maps to "UUID[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadGuidArray(Guid* res, int32_t len); + + /** + * Read Date. Maps to "Date" type in Java. + * + * @return Result. + */ + Date ReadDate(); + + /** + * Read array of Dates. Maps to "Date[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadDateArray(Date* res, int32_t len); + + /** + * Read Timestamp. Maps to "Timestamp" type in Java. + * + * @return Result. + */ + Timestamp ReadTimestamp(); + + /** + * Read array of Timestamps. Maps to "Timestamp[]" type in Java. + * + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadTimestampArray(Timestamp* res, int32_t len); + + /** + * Read string. + * + * @param res Array to store data to. + * @param len Expected length of string. NULL terminator will be set in case len is + * greater than real string length. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadString(char* res, int32_t len); + + /** + * Read string from the stream. + * + * @return String. + */ + std::string ReadString() + { + int32_t len = ReadString(NULL, 0); + + if (len != -1) + { + ignite::common::SafeArray<char> arr(len + 1); + + ReadString(arr.target, len + 1); + + return std::string(arr.target); + } + else + return std::string(); + } + + /** + * Start string array read. + * + * @return String array reader. + */ + BinaryStringArrayReader ReadStringArray(); + + /** + * Start array read. + * + * @return Array reader. + */ + template<typename T> + BinaryArrayReader<T> ReadArray() + { + int32_t size; + + int32_t id = impl->ReadArray(&size); + + return BinaryArrayReader<T>(impl, id, size); + } + + /** + * Start collection read. + * + * @return Collection reader. + */ + template<typename T> + BinaryCollectionReader<T> ReadCollection() + { + CollectionType typ; + int32_t size; + + int32_t id = impl->ReadCollection(&typ, &size); + + return BinaryCollectionReader<T>(impl, id, typ, size); + } + + /** + * Read values and insert them to specified position. + * + * @param out Output iterator to the initial position in the destination sequence. + * @return Number of elements that have been read. + */ + template<typename T, typename OutputIterator> + int32_t ReadCollection(OutputIterator out) + { + return impl->ReadCollection<T>(out); + } + + /** + * Start map read. + * + * @return Map reader. + */ + template<typename K, typename V> + BinaryMapReader<K, V> ReadMap() + { + MapType typ; + int32_t size; + + int32_t id = impl->ReadMap(&typ, &size); + + return BinaryMapReader<K, V>(impl, id, typ, size); + } + + /** + * Read type of the collection. + * + * @return Collection type. + */ + CollectionType ReadCollectionType(); + + /** + * Read type of the collection. + * + * @return Collection size. + */ + int32_t ReadCollectionSize(); + + /** + * Read object. + * + * @return Object. + */ + template<typename T> + T ReadObject() + { + return impl->ReadObject<T>(); + } + private: + /** Implementation delegate. */ + ignite::impl::binary::BinaryReaderImpl* impl; + }; + } +} + +#endif //_IGNITE_BINARY_BINARY_RAW_READER \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_writer.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_writer.h b/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_writer.h new file mode 100644 index 0000000..41cfef7 --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/binary/binary_raw_writer.h @@ -0,0 +1,363 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Declares ignite::binary::BinaryRawWriter class. + */ + +#ifndef _IGNITE_BINARY_BINARY_RAW_WRITER +#define _IGNITE_BINARY_BINARY_RAW_WRITER + +#include <stdint.h> + +#include <ignite/common/common.h> + +#include "ignite/impl/binary/binary_writer_impl.h" +#include "ignite/binary/binary_consts.h" +#include "ignite/binary/binary_containers.h" +#include "ignite/guid.h" +#include "ignite/date.h" +#include "ignite/timestamp.h" + +namespace ignite +{ + namespace binary + { + /** + * Binary raw writer. + */ + class IGNITE_IMPORT_EXPORT BinaryRawWriter + { + public: + /** + * Constructor. + * + * @param impl Implementation. + */ + BinaryRawWriter(ignite::impl::binary::BinaryWriterImpl* impl); + + /** + * Write 8-byte signed integer. Maps to "byte" type in Java. + * + * @param val Value. + */ + void WriteInt8(int8_t val); + + /** + * Write array of 8-byte signed integers. Maps to "byte[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteInt8Array(const int8_t* val, int32_t len); + + /** + * Write bool. Maps to "short" type in Java. + * + * @param val Value. + */ + void WriteBool(bool val); + + /** + * Write array of bools. Maps to "bool[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteBoolArray(const bool* val, int32_t len); + + /** + * Write 16-byte signed integer. Maps to "short" type in Java. + * + * @param val Value. + */ + void WriteInt16(int16_t val); + + /** + * Write array of 16-byte signed integers. Maps to "short[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteInt16Array(const int16_t* val, int32_t len); + + /** + * Write 16-byte unsigned integer. Maps to "char" type in Java. + * + * @param val Value. + */ + void WriteUInt16(uint16_t val); + + /** + * Write array of 16-byte unsigned integers. Maps to "char[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteUInt16Array(const uint16_t* val, int32_t len); + + /** + * Write 32-byte signed integer. Maps to "int" type in Java. + * + * @param val Value. + */ + void WriteInt32(int32_t val); + + /** + * Write array of 32-byte signed integers. Maps to "int[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteInt32Array(const int32_t* val, int32_t len); + + /** + * Write 64-byte signed integer. Maps to "long" type in Java. + * + * @param val Value. + */ + void WriteInt64(int64_t val); + + /** + * Write array of 64-byte signed integers. Maps to "long[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteInt64Array(const int64_t* val, int32_t len); + + /** + * Write float. Maps to "float" type in Java. + * + * @param val Value. + */ + void WriteFloat(float val); + + /** + * Write array of floats. Maps to "float[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteFloatArray(const float* val, int32_t len); + + /** + * Write double. Maps to "double" type in Java. + * + * @param val Value. + */ + void WriteDouble(double val); + + /** + * Write array of doubles. Maps to "double[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteDoubleArray(const double* val, int32_t len); + + /** + * Write Guid. Maps to "UUID" type in Java. + * + * @param val Value. + */ + void WriteGuid(const Guid& val); + + /** + * Write array of Guids. Maps to "UUID[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteGuidArray(const Guid* val, int32_t len); + + /** + * Write Date. Maps to "Date" type in Java. + * + * @param val Value. + */ + void WriteDate(const Date& val); + + /** + * Write array of Dates. Maps to "Date[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteDateArray(const Date* val, int32_t len); + + /** + * Write Timestamp. Maps to "Timestamp" type in Java. + * + * @param val Value. + */ + void WriteTimestamp(const Timestamp& val); + + /** + * Write array of Timestamps. Maps to "Timestamp[]" type in Java. + * + * @param val Array. + * @param len Array length. + */ + void WriteTimestampArray(const Timestamp* val, int32_t len); + + /** + * Write string. + * + * @param val Null-terminated character array. + */ + void WriteString(const char* val); + + /** + * Write string. + * + * @param val String. + * @param len String length (characters). + */ + void WriteString(const char* val, int32_t len); + + /** + * Write string. + * + * @param val String. + */ + void WriteString(const std::string& val) + { + WriteString(val.c_str()); + } + + /** + * Start string array write. + * + * @return String array writer. + */ + BinaryStringArrayWriter WriteStringArray(); + + /** + * Write NULL value. + */ + void WriteNull(); + + /** + * Start array write. + * + * @return Array writer. + */ + template<typename T> + BinaryArrayWriter<T> WriteArray() + { + int32_t id = impl->WriteArray(); + + return BinaryArrayWriter<T>(impl, id); + } + + /** + * Start collection write. + * + * @return Collection writer. + */ + template<typename T> + BinaryCollectionWriter<T> WriteCollection() + { + return WriteCollection<T>(IGNITE_COLLECTION_UNDEFINED); + } + + /** + * Start collection write. + * + * @param type Collection type. + * @return Collection writer. + */ + template<typename T> + BinaryCollectionWriter<T> WriteCollection(CollectionType typ) + { + int32_t id = impl->WriteCollection(typ); + + return BinaryCollectionWriter<T>(impl, id); + } + + /** + * Write values in interval [first, last). + * + * @param first Iterator pointing to the beginning of the interval. + * @param last Iterator pointing to the end of the interval. + * @param typ Collection type. + */ + template<typename InputIterator> + void WriteCollection(InputIterator first, InputIterator last) + { + impl->WriteCollection(first, last, IGNITE_COLLECTION_UNDEFINED); + } + + /** + * Write values in interval [first, last). + * + * @param first Iterator pointing to the beginning of the interval. + * @param last Iterator pointing to the end of the interval. + * @param typ Collection type. + */ + template<typename InputIterator> + void WriteCollection(InputIterator first, InputIterator last, CollectionType typ) + { + impl->WriteCollection(first, last, typ); + } + + /** + * Start map write. + * + * @param typ Map type. + * @return Map writer. + */ + template<typename K, typename V> + BinaryMapWriter<K, V> WriteMap() + { + return WriteMap<K, V>(IGNITE_MAP_UNDEFINED); + } + + /** + * Start map write. + * + * @param typ Map type. + * @return Map writer. + */ + template<typename K, typename V> + BinaryMapWriter<K, V> WriteMap(MapType typ) + { + int32_t id = impl->WriteMap(typ); + + return BinaryMapWriter<K, V>(impl, id); + } + + /** + * Write object. + * + * @param val Object. + */ + template<typename T> + void WriteObject(T val) + { + impl->WriteObject<T>(val); + } + private: + /** Implementation delegate. */ + ignite::impl::binary::BinaryWriterImpl* impl; + }; + } +} + +#endif //_IGNITE_BINARY_BINARY_RAW_WRITER \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/binary/binary_reader.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/binary/binary_reader.h b/modules/platforms/cpp/binary/include/ignite/binary/binary_reader.h new file mode 100644 index 0000000..3e5bbb1 --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/binary/binary_reader.h @@ -0,0 +1,433 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Declares ignite::binary::BinaryReader class. + */ + +#ifndef _IGNITE_BINARY_BINARY_READER +#define _IGNITE_BINARY_BINARY_READER + +#include <stdint.h> +#include <string> + +#include <ignite/common/common.h> + +#include "ignite/binary/binary_raw_reader.h" +#include "ignite/guid.h" +#include "ignite/date.h" +#include "ignite/timestamp.h" + +namespace ignite +{ + namespace binary + { + /** + * Binary reader. + */ + class IGNITE_IMPORT_EXPORT BinaryReader + { + public: + /** + * Constructor. + * + * @param impl Implementation. + */ + BinaryReader(ignite::impl::binary::BinaryReaderImpl* impl); + + /** + * Read 8-byte signed integer. Maps to "byte" type in Java. + * + * @param fieldName Field name. + * @param fieldName Field name. + * @return Result. + */ + int8_t ReadInt8(const char* fieldName); + + /** + * Read array of 8-byte signed integers. Maps to "byte[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt8Array(const char* fieldName, int8_t* res, int32_t len); + + /** + * Read bool. Maps to "short" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + bool ReadBool(const char* fieldName); + + /** + * Read array of bools. Maps to "bool[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadBoolArray(const char* fieldName, bool* res, int32_t len); + + /** + * Read 16-byte signed integer. Maps to "short" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + int16_t ReadInt16(const char* fieldName); + + /** + * Read array of 16-byte signed integers. Maps to "short[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt16Array(const char* fieldName, int16_t* res, int32_t len); + + /** + * Read 16-byte unsigned integer. Maps to "char" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + uint16_t ReadUInt16(const char* fieldName); + + /** + * Read array of 16-byte unsigned integers. Maps to "char[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadUInt16Array(const char* fieldName, uint16_t* res, int32_t len); + + /** + * Read 32-byte signed integer. Maps to "int" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + int32_t ReadInt32(const char* fieldName); + + /** + * Read array of 32-byte signed integers. Maps to "int[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt32Array(const char* fieldName, int32_t* res, int32_t len); + + /** + * Read 64-byte signed integer. Maps to "long" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + int64_t ReadInt64(const char* fieldName); + + /** + * Read array of 64-byte signed integers. Maps to "long[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadInt64Array(const char* fieldName, int64_t* res, int32_t len); + + /** + * Read float. Maps to "float" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + float ReadFloat(const char* fieldName); + + /** + * Read array of floats. Maps to "float[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadFloatArray(const char* fieldName, float* res, int32_t len); + + /** + * Read double. Maps to "double" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + double ReadDouble(const char* fieldName); + + /** + * Read array of doubles. Maps to "double[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadDoubleArray(const char* fieldName, double* res, int32_t len); + + /** + * Read Guid. Maps to "UUID" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + Guid ReadGuid(const char* fieldName); + + /** + * Read array of Guids. Maps to "UUID[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadGuidArray(const char* fieldName, Guid* res, int32_t len); + + /** + * Read Date. Maps to "Date" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + Date ReadDate(const char* fieldName); + + /** + * Read array of Dates. Maps to "Date[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadDateArray(const char* fieldName, Date* res, const int32_t len); + + /** + * Read Timestamp. Maps to "Timestamp" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + Timestamp ReadTimestamp(const char* fieldName); + + /** + * Read array of Timestamps. Maps to "Timestamp[]" type in Java. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of array. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadTimestampArray(const char* fieldName, Timestamp* res, const int32_t len); + + /** + * Read string. + * + * @param fieldName Field name. + * @param res Array to store data to. + * @param len Expected length of string. NULL terminator will be set in case len is + * greater than real string length. + * @return Actual amount of elements read. If "len" argument is less than actual + * array size or resulting array is set to null, nothing will be written + * to resulting array and returned value will contain required array length. + * -1 will be returned in case array in stream was null. + */ + int32_t ReadString(const char* fieldName, char* res, int32_t len); + + /** + * Read string from the stream. + * + * @param fieldName Field name. + * @return String. + */ + std::string ReadString(const char* fieldName) + { + int32_t len = ReadString(fieldName, NULL, 0); + + if (len != -1) + { + ignite::common::SafeArray<char> arr(len + 1); + + ReadString(fieldName, arr.target, len + 1); + + return std::string(arr.target); + } + else + return std::string(); + } + + /** + * Start string array read. + * + * @param fieldName Field name. + * @return String array reader. + */ + BinaryStringArrayReader ReadStringArray(const char* fieldName); + + /** + * Start array read. + * + * @param fieldName Field name. + * @return Array reader. + */ + template<typename T> + BinaryArrayReader<T> ReadArray(const char* fieldName) + { + int32_t size; + + int32_t id = impl->ReadArray(fieldName, &size); + + return BinaryArrayReader<T>(impl, id, size); + } + + /** + * Start collection read. + * + * @param fieldName Field name. + * @return Collection reader. + */ + template<typename T> + BinaryCollectionReader<T> ReadCollection(const char* fieldName) + { + CollectionType typ; + int32_t size; + + int32_t id = impl->ReadCollection(fieldName, &typ, &size); + + return BinaryCollectionReader<T>(impl, id, typ, size); + } + + /** + * Read values and insert them to specified position. + * + * @param fieldName Field name. + * @param out Output iterator to the initial position in the destination sequence. + * @return Number of elements that have been read. + */ + template<typename T, typename OutputIterator> + int32_t ReadCollection(const char* fieldName, OutputIterator out) + { + return impl->ReadCollection<T>(fieldName, out); + } + + /** + * Start map read. + * + * @param fieldName Field name. + * @return Map reader. + */ + template<typename K, typename V> + BinaryMapReader<K, V> ReadMap(const char* fieldName) + { + MapType typ; + int32_t size; + + int32_t id = impl->ReadMap(fieldName, &typ, &size); + + return BinaryMapReader<K, V>(impl, id, typ, size); + } + + /** + * Read type of the collection. + * + * @param fieldName Field name. + * @return Collection type. + */ + CollectionType ReadCollectionType(const char* fieldName); + + /** + * Read type of the collection. + * + * @param fieldName Field name. + * @return Collection size. + */ + int32_t ReadCollectionSize(const char* fieldName); + + /** + * Read object. + * + * @param fieldName Field name. + * @return Object. + */ + template<typename T> + T ReadObject(const char* fieldName) + { + return impl->ReadObject<T>(fieldName); + } + + /** + * Get raw reader for this reader. + * + * @return Raw reader. + */ + BinaryRawReader RawReader(); + private: + /** Implementation delegate. */ + ignite::impl::binary::BinaryReaderImpl* impl; + }; + } +} + +#endif //_IGNITE_BINARY_BINARY_READER \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/binary/binary_type.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/binary/binary_type.h b/modules/platforms/cpp/binary/include/ignite/binary/binary_type.h new file mode 100644 index 0000000..978a928 --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/binary/binary_type.h @@ -0,0 +1,310 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Declares ignite::binary::BinaryType class template and helping macros + * to declare binary type specialisation for user types. + */ + +#ifndef _IGNITE_BINARY_BINARY_TYPE +#define _IGNITE_BINARY_BINARY_TYPE + +#include <stdint.h> + +#include <ignite/common/common.h> + +#include <ignite/ignite_error.h> + +/** + * @def IGNITE_BINARY_TYPE_START(T) + * Start binary type definition. + */ +#define IGNITE_BINARY_TYPE_START(T) \ +template<> \ +struct BinaryType<T> \ +{ + +/** + * @def IGNITE_BINARY_TYPE_END + * End binary type definition. + */ +#define IGNITE_BINARY_TYPE_END \ +}; + +/** + * @def IGNITE_BINARY_GET_TYPE_ID_AS_CONST(id) + * Implementation of GetTypeId() which returns predefined constant. + */ +#define IGNITE_BINARY_GET_TYPE_ID_AS_CONST(id) \ +int32_t GetTypeId() \ +{ \ + return id; \ +} + +/** + * @def IGNITE_BINARY_GET_TYPE_ID_AS_HASH(typeName) + * Implementation of GetTypeId() which returns hash of passed type name. + */ +#define IGNITE_BINARY_GET_TYPE_ID_AS_HASH(typeName) \ +int32_t GetTypeId() \ +{ \ + return GetBinaryStringHashCode(#typeName); \ +} + +/** + * @def IGNITE_BINARY_GET_TYPE_NAME_AS_IS(typeName) + * Implementation of GetTypeName() which returns type name as is. + */ +#define IGNITE_BINARY_GET_TYPE_NAME_AS_IS(typeName) \ +std::string GetTypeName() \ +{ \ + return #typeName; \ +} + +/** + * @def IGNITE_BINARY_GET_FIELD_ID_AS_HASH + * Default implementation of GetFieldId() function which returns Java-way hash code of the string. + */ +#define IGNITE_BINARY_GET_FIELD_ID_AS_HASH \ +int32_t GetFieldId(const char* name) \ +{ \ + return GetBinaryStringHashCode(name); \ +} + +/** + * @def IGNITE_BINARY_GET_HASH_CODE_ZERO(T) + * Implementation of GetHashCode() function which always returns 0. + */ +#define IGNITE_BINARY_GET_HASH_CODE_ZERO(T) \ +int32_t GetHashCode(const T& obj) \ +{ \ + return 0; \ +} + +/** + * @def IGNITE_BINARY_IS_NULL_FALSE(T) + * Implementation of IsNull() function which always returns false. + */ +#define IGNITE_BINARY_IS_NULL_FALSE(T) \ +bool IsNull(const T& obj) \ +{ \ + return false; \ +} + +/** + * @def IGNITE_BINARY_IS_NULL_IF_NULLPTR(T) + * Implementation of IsNull() function which return true if passed object is null pointer. + */ +#define IGNITE_BINARY_IS_NULL_IF_NULLPTR(T) \ +bool IsNull(const T& obj) \ +{ \ + return obj; \ +} + +/** + * @def IGNITE_BINARY_GET_NULL_DEFAULT_CTOR(T) + * Implementation of GetNull() function which returns an instance created with defult constructor. + */ +#define IGNITE_BINARY_GET_NULL_DEFAULT_CTOR(T) \ +T GetNull() \ +{ \ + return T(); \ +} + +/** + * @def IGNITE_BINARY_GET_NULL_NULLPTR(T) + * Implementation of GetNull() function which returns NULL pointer. + */ +#define IGNITE_BINARY_GET_NULL_NULLPTR(T) \ +T GetNull() \ +{ \ + return NULL; \ +} + +namespace ignite +{ + namespace binary + { + class BinaryWriter; + class BinaryReader; + + /** + * Get binary string hash code. + * + * @param val Value. + * @return Hash code. + */ + IGNITE_IMPORT_EXPORT int32_t GetBinaryStringHashCode(const char* val); + + /** + * Binary type structure. Defines a set of functions required for type to be serialized and deserialized. + */ + template<typename T> + struct IGNITE_IMPORT_EXPORT BinaryType + { + /** + * Get binary object type ID. + * + * @return Type ID. + */ + int32_t GetTypeId() + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "GetTypeId function is not defined for binary type."); + } + + /** + * Get binary object type name. + * + * @return Type name. + */ + std::string GetTypeName() + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "GetTypeName function is not defined for binary type."); + } + + /** + * Get binary object field ID. + * + * @param name Field name. + * @return Field ID. + */ + int32_t GetFieldId(const char* name) + { + return GetBinaryStringHashCode(name); + } + + /** + * Get binary object hash code. + * + * @param obj Binary object. + * @return Hash code. + */ + int32_t GetHashCode(const T& obj) + { + return 0; + } + + /** + * Write binary object. + * + * @param writer Writer. + * @param obj Object. + */ + void Write(BinaryWriter& writer, const T& obj) + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Write function is not defined for binary type."); + } + + /** + * Read binary object. + * + * @param reader Reader. + * @return Object. + */ + T Read(BinaryReader& reader) + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Read function is not defined for binary type."); + } + + /** + * Check whether passed binary object should be interpreted as NULL. + * + * @param obj Binary object to test. + * @return True if binary object should be interpreted as NULL. + */ + bool IsNull(const T& obj) + { + return false; + } + + /** + * Get NULL value for the given binary type. + * + * @return NULL value. + */ + T GetNull() + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "GetNull function is not defined for binary type."); + } + }; + + /** + * Templated binary type specification for pointers. + */ + template <typename T> + struct IGNITE_IMPORT_EXPORT BinaryType<T*> + { + /** Actual type. */ + BinaryType<T> typ; + + /** + * Constructor. + */ + BinaryType() + { + typ = BinaryType<T>(); + } + + int32_t GetTypeId() + { + return typ.GetTypeId(); + } + + std::string GetTypeName() + { + return typ.GetTypeName(); + } + + int32_t GetFieldId(const char* name) + { + return typ.GetFieldId(name); + } + + int32_t GetHashCode(T* const& obj) + { + return typ.GetHashCode(*obj); + } + + void Write(BinaryWriter& writer, T* const& obj) + { + typ.Write(writer, *obj); + } + + T* Read(BinaryReader& reader) + { + T* res = new T(); + + *res = typ.Read(reader); + + return res; + } + + bool IsNull(T* const& obj) + { + return !obj || typ.IsNull(*obj); + } + + T* GetNull() + { + return NULL; + } + }; + } +} + +#endif //_IGNITE_BINARY_BINARY_TYPE http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/binary/binary_writer.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/binary/binary_writer.h b/modules/platforms/cpp/binary/include/ignite/binary/binary_writer.h new file mode 100644 index 0000000..1bee82a --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/binary/binary_writer.h @@ -0,0 +1,401 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Declares ignite::binary::BinaryWriter class. + */ + +#ifndef _IGNITE_BINARY_BINARY_WRITER +#define _IGNITE_BINARY_BINARY_WRITER + +#include <string> +#include <stdint.h> + +#include <ignite/common/common.h> + +#include "ignite/binary/binary_raw_writer.h" + +namespace ignite +{ + namespace binary + { + /** + * Binary writer. + */ + class IGNITE_IMPORT_EXPORT BinaryWriter + { + public: + /** + * Constructor. + * + * @param impl Implementation. + */ + BinaryWriter(ignite::impl::binary::BinaryWriterImpl* impl); + + /** + * Write 8-byte signed integer. Maps to "byte" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteInt8(const char* fieldName, int8_t val); + + /** + * Write array of 8-byte signed integers. Maps to "byte[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteInt8Array(const char* fieldName, const int8_t* val, int32_t len); + + /** + * Write bool. Maps to "short" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteBool(const char* fieldName, bool val); + + /** + * Write array of bools. Maps to "bool[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteBoolArray(const char* fieldName, const bool* val, int32_t len); + + /** + * Write 16-byte signed integer. Maps to "short" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteInt16(const char* fieldName, int16_t val); + + /** + * Write array of 16-byte signed integers. Maps to "short[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteInt16Array(const char* fieldName, const int16_t* val, int32_t len); + + /** + * Write 16-byte unsigned integer. Maps to "char" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteUInt16(const char* fieldName, uint16_t val); + + /** + * Write array of 16-byte unsigned integers. Maps to "char[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteUInt16Array(const char* fieldName, const uint16_t* val, int32_t len); + + /** + * Write 32-byte signed integer. Maps to "int" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteInt32(const char* fieldName, int32_t val); + + /** + * Write array of 32-byte signed integers. Maps to "int[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteInt32Array(const char* fieldName, const int32_t* val, int32_t len); + + /** + * Write 64-byte signed integer. Maps to "long" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteInt64(const char* fieldName, int64_t val); + + /** + * Write array of 64-byte signed integers. Maps to "long[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteInt64Array(const char* fieldName, const int64_t* val, int32_t len); + + /** + * Write float. Maps to "float" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteFloat(const char* fieldName, float val); + + /** + * Write array of floats. Maps to "float[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteFloatArray(const char* fieldName, const float* val, int32_t len); + + /** + * Write double. Maps to "double" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteDouble(const char* fieldName, double val); + + /** + * Write array of doubles. Maps to "double[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteDoubleArray(const char* fieldName, const double* val, int32_t len); + + /** + * Write Guid. Maps to "UUID" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteGuid(const char* fieldName, const Guid& val); + + /** + * Write array of Guids. Maps to "UUID[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteGuidArray(const char* fieldName, const Guid* val, int32_t len); + + /** + * Write Date. Maps to "Date" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteDate(const char* fieldName, const Date& val); + + /** + * Write array of Dates. Maps to "Date[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteDateArray(const char* fieldName, const Date* val, const int32_t len); + + /** + * Write Timestamp. Maps to "Timestamp" type in Java. + * + * @param fieldName Field name. + * @param val Value. + */ + void WriteTimestamp(const char* fieldName, const Timestamp& val); + + /** + * Write array of Timestamps. Maps to "Timestamp[]" type in Java. + * + * @param fieldName Field name. + * @param val Array. + * @param len Array length. + */ + void WriteTimestampArray(const char* fieldName, const Timestamp* val, const int32_t len); + + /** + * Write string. + * + * @param fieldName Field name. + * @param val Null-terminated character sequence. + */ + void WriteString(const char* fieldName, const char* val); + + /** + * Write string. + * + * @param fieldName Field name. + * @param val String. + * @param len String length (characters). + */ + void WriteString(const char* fieldName, const char* val, int32_t len); + + /** + * Write string. + * + * @param fieldName Field name. + * @param val String. + */ + void WriteString(const char* fieldName, const std::string& val) + { + WriteString(fieldName, val.c_str()); + } + + /** + * Start string array write. + * + * @param fieldName Field name. + * @return String array writer. + */ + BinaryStringArrayWriter WriteStringArray(const char* fieldName); + + /** + * Write NULL value. + * + * @param fieldName Field name. + */ + void WriteNull(const char* fieldName); + + /** + * Start array write. + * + * @param fieldName Field name. + * @return Array writer. + */ + template<typename T> + BinaryArrayWriter<T> WriteArray(const char* fieldName) + { + int32_t id = impl->WriteArray(fieldName); + + return BinaryArrayWriter<T>(impl, id); + } + + /** + * Start collection write. + * + * @param fieldName Field name. + * @return Collection writer. + */ + template<typename T> + BinaryCollectionWriter<T> WriteCollection(const char* fieldName) + { + return WriteCollection<T>(fieldName, IGNITE_COLLECTION_UNDEFINED); + } + + /** + * Start collection write. + * + * @param fieldName Field name. + * @param type Collection type. + * @return Collection writer. + */ + template<typename T> + BinaryCollectionWriter<T> WriteCollection(const char* fieldName, ignite::binary::CollectionType typ) + { + int32_t id = impl->WriteCollection(fieldName, typ); + + return BinaryCollectionWriter<T>(impl, id); + } + + /** + * Write values in interval [first, last). + * + * @param fieldName Field name. + * @param first Iterator pointing to the beginning of the interval. + * @param last Iterator pointing to the end of the interval. + */ + template<typename InputIterator> + void WriteCollection(const char* fieldName, InputIterator first, InputIterator last) + { + WriteCollection(fieldName, first, last, IGNITE_COLLECTION_UNDEFINED); + } + + /** + * Write values in interval [first, last). + * + * @param fieldName Field name. + * @param first Iterator pointing to the beginning of the interval. + * @param last Iterator pointing to the end of the interval. + * @param typ Collection type. + */ + template<typename InputIterator> + void WriteCollection(const char* fieldName, InputIterator first, InputIterator last, CollectionType typ) + { + impl->WriteCollection(fieldName, first, last, typ); + } + + /** + * Start map write. + * + * @param fieldName Field name. + * @param typ Map type. + * @return Map writer. + */ + template<typename K, typename V> + BinaryMapWriter<K, V> WriteMap(const char* fieldName) + { + return WriteMap<K, V>(fieldName, IGNITE_MAP_UNDEFINED); + } + + /** + * Start map write. + * + * @param fieldName Field name. + * @param typ Map type. + * @return Map writer. + */ + template<typename K, typename V> + BinaryMapWriter<K, V> WriteMap(const char* fieldName, ignite::binary::MapType typ) + { + int32_t id = impl->WriteMap(fieldName, typ); + + return BinaryMapWriter<K, V>(impl, id); + } + + /** + * Write object. + * + * @param fieldName Field name. + * @param val Value. + */ + template<typename T> + void WriteObject(const char* fieldName, T val) + { + impl->WriteObject<T>(fieldName, val); + } + + /** + * Get raw writer for this reader. + * + * @return Raw writer. + */ + BinaryRawWriter RawWriter(); + private: + /** Implementation delegate. */ + ignite::impl::binary::BinaryWriterImpl* impl; + }; + } +} + +#endif //_IGNITE_BINARY_BINARY_WRITER \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/764c97b9/modules/platforms/cpp/binary/include/ignite/impl/binary/binary_common.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/binary/include/ignite/impl/binary/binary_common.h b/modules/platforms/cpp/binary/include/ignite/impl/binary/binary_common.h new file mode 100644 index 0000000..462bc5b --- /dev/null +++ b/modules/platforms/cpp/binary/include/ignite/impl/binary/binary_common.h @@ -0,0 +1,194 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _IGNITE_IMPL_BINARY_BINARY_COMMON +#define _IGNITE_IMPL_BINARY_BINARY_COMMON + +#include <stdint.h> + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** Header: null. */ + const int8_t IGNITE_HDR_NULL = 101; + + /** Header: handle. */ + const int8_t IGNITE_HDR_HND = 102; + + /** Header: fulle form. */ + const int8_t IGNITE_HDR_FULL = 103; + + /** Binary protocol version. */ + const int8_t IGNITE_PROTO_VER = 1; + + /** Protocol version position. */ + const int32_t PROTO_VER_POS = 1; + + /** Header offset: Flags. */ + const int32_t IGNITE_OFFSET_FLAGS = 2; + + /** Header offset: Type ID. */ + const int32_t IGNITE_OFFSET_TYPE_ID = 4; + + /** Header offset: Hash Code. */ + const int32_t IGNITE_OFFSET_HASH_CODE = 8; + + /** Header offset: Object Length. */ + const int32_t IGNITE_OFFSET_LEN = 12; + + /** Header offset: Schema ID. */ + const int32_t IGNITE_OFFSET_SCHEMA_ID = 16; + + /** Header offset: Schema or Raw Offset. */ + const int32_t IGNITE_OFFSET_SCHEMA_OR_RAW_OFF = 20; + + /** Full header length. */ + const int32_t IGNITE_DFLT_HDR_LEN = 24; + + /** Type: object. */ + const int8_t IGNITE_TYPE_OBJECT = IGNITE_HDR_FULL; + + /** Type: unsigned byte. */ + const int8_t IGNITE_TYPE_BYTE = 1; + + /** Type: short. */ + const int8_t IGNITE_TYPE_SHORT = 2; + + /** Type: int. */ + const int8_t IGNITE_TYPE_INT = 3; + + /** Type: long. */ + const int8_t IGNITE_TYPE_LONG = 4; + + /** Type: float. */ + const int8_t IGNITE_TYPE_FLOAT = 5; + + /** Type: double. */ + const int8_t IGNITE_TYPE_DOUBLE = 6; + + /** Type: char. */ + const int8_t IGNITE_TYPE_CHAR = 7; + + /** Type: boolean. */ + const int8_t IGNITE_TYPE_BOOL = 8; + + /** Type: decimal. */ + const int8_t IGNITE_TYPE_DECIMAL = 30; + + /** Type: string. */ + const int8_t IGNITE_TYPE_STRING = 9; + + /** Type: UUID. */ + const int8_t IGNITE_TYPE_UUID = 10; + + /** Type: date. */ + const int8_t IGNITE_TYPE_DATE = 11; + + /** Type: unsigned byte array. */ + const int8_t IGNITE_TYPE_ARRAY_BYTE = 12; + + /** Type: short array. */ + const int8_t IGNITE_TYPE_ARRAY_SHORT = 13; + + /** Type: int array. */ + const int8_t IGNITE_TYPE_ARRAY_INT = 14; + + /** Type: long array. */ + const int8_t IGNITE_TYPE_ARRAY_LONG = 15; + + /** Type: float array. */ + const int8_t IGNITE_TYPE_ARRAY_FLOAT = 16; + + /** Type: double array. */ + const int8_t IGNITE_TYPE_ARRAY_DOUBLE = 17; + + /** Type: char array. */ + const int8_t IGNITE_TYPE_ARRAY_CHAR = 18; + + /** Type: boolean array. */ + const int8_t IGNITE_TYPE_ARRAY_BOOL = 19; + + /** Type: decimal array. */ + const int8_t IGNITE_TYPE_ARRAY_DECIMAL = 31; + + /** Type: string array. */ + const int8_t IGNITE_TYPE_ARRAY_STRING = 20; + + /** Type: UUID array. */ + const int8_t IGNITE_TYPE_ARRAY_UUID = 21; + + /** Type: date array. */ + const int8_t IGNITE_TYPE_ARRAY_DATE = 22; + + /** Type: object array. */ + const int8_t IGNITE_TYPE_ARRAY = 23; + + /** Type: collection. */ + const int8_t IGNITE_TYPE_COLLECTION = 24; + + /** Type: map. */ + const int8_t IGNITE_TYPE_MAP = 25; + + /** Type: map entry. */ + const int8_t IGNITE_TYPE_MAP_ENTRY = 26; + + /** Type: binary object. */ + const int8_t IGNITE_TYPE_BINARY = 27; + + /** Type: timestamp. */ + const int8_t IGNITE_TYPE_TIMESTAMP = 33; + + /** Type: timestamp array. */ + const int8_t IGNITE_TYPE_ARRAY_TIMESTAMP = 34; + + /** Read/write single object. */ + const int32_t IGNITE_BINARY_MODE_SINGLE = 0; + + /** Read/write array. */ + const int32_t IGNITE_BINARY_MODE_ARRAY = 1; + + /** Read/write collection. */ + const int32_t IGNITE_BINARY_MODE_COL = 2; + + /** Read/write map. */ + const int32_t IGNITE_BINARY_MODE_MAP = 3; + + /** User type flag. */ + const int16_t IGNITE_BINARY_FLAG_USER_TYPE = 0x0001; + + /** Flag: schema exists. */ + const int16_t IGNITE_BINARY_FLAG_HAS_SCHEMA = 0x0002; + + /** Flag indicating that object has raw data. */ + const int16_t IGNITE_BINARY_FLAG_HAS_RAW = 0x0004; + + /** Flag indicating that schema field offset is one byte long. */ + const int16_t IGNITE_BINARY_FLAG_OFFSET_ONE_BYTE = 0x0008; + + /** Flag indicating that schema field offset is two byte long. */ + const int16_t IGNITE_BINARY_FLAG_OFFSET_TWO_BYTES = 0x0010; + + /** Flag: compact footer, no field IDs. */ + const int16_t IGNITE_BINARY_FLAG_COMPACT_FOOTER = 0x0020; + } + } +} + +#endif //_IGNITE_IMPL_BINARY_BINARY_COMMON \ No newline at end of file
