http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_id_resolver.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_id_resolver.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_id_resolver.h new file mode 100644 index 0000000..b5f31e9 --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_id_resolver.h @@ -0,0 +1,106 @@ +/* + * 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_ID_RESOLVER +#define _IGNITE_IMPL_BINARY_ID_RESOLVER + +#include "ignite/binary/binary_type.h" + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Binary type id resolver. + */ + class BinaryIdResolver + { + public: + /** + * Destructor. + */ + virtual ~BinaryIdResolver() + { + // No-op. + } + + /** + * Get binary object type ID. + * + * @return Type ID. + */ + virtual int32_t GetTypeId() = 0; + + /** + * Get binary object field ID. + * + * @param typeId Type ID. + * @param name Field name. + * @return Field ID. + */ + virtual int32_t GetFieldId(const int32_t typeId, const char* name) = 0; + }; + + /** + * Templated binary type descriptor. + */ + template<typename T> + class TemplatedBinaryIdResolver : public BinaryIdResolver + { + public: + /** + * Constructor. + */ + TemplatedBinaryIdResolver() + { + type = ignite::binary::BinaryType<T>(); + } + + /** + * Constructor. + * + * @param type Binary type. + */ + TemplatedBinaryIdResolver(ignite::binary::BinaryType<T> type) : type(type) + { + // No-op. + } + + virtual int32_t GetTypeId() + { + return type.GetTypeId(); + } + + virtual int32_t GetFieldId(const int32_t typeId, const char* name) { + if (!name) + { + IGNITE_ERROR_1(IgniteError::IGNITE_ERR_BINARY, "Field name cannot be NULL."); + } + + return type.GetFieldId(name); + } + private: + /** Actual type. */ + ignite::binary::BinaryType<T> type; + }; + } + } +} + +#endif \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_reader_impl.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_reader_impl.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_reader_impl.h new file mode 100644 index 0000000..923553d --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_reader_impl.h @@ -0,0 +1,1311 @@ +/* + * 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_READER +#define _IGNITE_IMPL_BINARY_READER + +#include <stdint.h> + +#include <ignite/common/common.h> + +#include "ignite/impl/interop/interop_input_stream.h" +#include "ignite/impl/binary/binary_common.h" +#include "ignite/impl/binary/binary_id_resolver.h" +#include "ignite/impl/binary/binary_schema.h" +#include "ignite/impl/utils.h" +#include "ignite/binary/binary_consts.h" +#include "ignite/binary/binary_type.h" +#include "ignite/guid.h" + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Internal implementation of binary reader. + */ + class IGNITE_IMPORT_EXPORT BinaryReaderImpl + { + public: + /** + * Constructor. + * + * @param stream Interop stream. + * @param idRslvr Binary ID resolver. + * @param pos Object position in the stream. + * @param usrType user type flag. + * @param typeId Type ID. + * @param hashcode Hash code. + * @param len Length in bytes. + * @param rawOff Raw data offset. + * @param footerBegin Footer beginning absolute position in stream. + * @param footerEnd Footer ending absolute position in stream. + */ + BinaryReaderImpl(interop::InteropInputStream* stream, BinaryIdResolver* idRslvr, + int32_t pos, bool usrType, int32_t typeId, int32_t hashCode, int32_t len, int32_t rawOff, + int32_t footerBegin, int32_t footerEnd, BinaryOffsetType schemaType); + + /** + * Constructor used to construct light-weight reader allowing only raw operations + * and read of primitives. + * + * @param stream Interop stream. + */ + BinaryReaderImpl(interop::InteropInputStream* stream); + + /** + * 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, const int32_t len); + + /** + * Read 8-byte signed integer. Maps to "byte" type in Java. + * + * @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, const int32_t len); + + /** + * Read bool. Maps to "boolean" type in Java. + * + * @return Result. + */ + bool ReadBool(); + + /** + * Read bool array. 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, const int32_t len); + + /** + * Read bool. Maps to "short" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + bool ReadBool(const char* fieldName); + + /** + * Read bool array. 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const 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, const int32_t len); + + /** + * Read float. Maps to "float" type in Java. + * + * @return Result. + */ + float ReadFloat(); + + /** + * Read float array. 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, const int32_t len); + + /** + * Read float. Maps to "float" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + float ReadFloat(const char* fieldName); + + /** + * Read float array. 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, const int32_t len); + + /** + * Read double. Maps to "double" type in Java. + * + * @return Result. + */ + double ReadDouble(); + + /** + * Read double array. 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, const int32_t len); + + /** + * Read double. Maps to "double" type in Java. + * + * @param fieldName Field name. + * @return Result. + */ + double ReadDouble(const char* fieldName); + + /** + * Read double array. 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, const 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, const 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, const int32_t len); + + /** + * Read string. + * + * @param len Expected length of string. + * @param res Array to store data to (should be able to acocmodate null-terminator). + * @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, const int32_t len); + + /** + * Read string. + * + * @param fieldName Field name. + * @param res Array to store data to (should be able to acocmodate null-terminator). + * @param len Expected length of string. + * @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, const int32_t len); + + /** + * Start string array read. + * + * @param size Array size. + * @return Read session ID. + */ + int32_t ReadStringArray(int32_t* size); + + /** + * Start string array read. + * + * @param fieldName Field name. + * @param size Array size. + * @return Read session ID. + */ + int32_t ReadStringArray(const char* fieldName, int32_t* size); + + /** + * Read string element. + * + * @param id Session ID. + * @param len Expected length of string. + * @param res Array to store data to (should be able to acocmodate null-terminator). + * @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 ReadStringElement(int32_t id, char* res, const int32_t len); + + /** + * Start array read. + * + * @param size Array size. + * @return Read session ID. + */ + int32_t ReadArray(int32_t* size); + + /** + * Start array read. + * + * @param fieldName Field name. + * @param size Array size. + * @return Read session ID. + */ + int32_t ReadArray(const char* fieldName, int32_t* size); + + /** + * Start collection read. + * + * @param typ Collection type. + * @param size Collection size. + * @return Read session ID. + */ + int32_t ReadCollection(ignite::binary::CollectionType* typ, int32_t* size); + + /** + * Start collection read. + * + * @param fieldName Field name. + * @param typ Collection type. + * @param size Collection size. + * @return Read session ID. + */ + int32_t ReadCollection(const char* fieldName, ignite::binary::CollectionType* typ, int32_t* size); + + /** + * Read values and insert them to specified position. + * + * @param out Output iterator to the initial position in the destination sequence. + * @return Actual amount of elements read. + */ + template<typename T, typename OutputIterator> + int32_t ReadCollection(OutputIterator out) + { + int32_t size; + int32_t id = StartContainerSession(true, IGNITE_TYPE_COLLECTION, &size); + + // Reading collection type. We don't need it here but it should be read. + if (size != -1) + stream->ReadInt8(); + + while (HasNextElement(id)) + { + *out = ReadElement<T>(id); + ++out; + } + + return 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 Actual amount of elements read. + */ + template<typename T, typename OutputIterator> + int32_t ReadCollection(const char* fieldName, OutputIterator out) + { + CheckRawMode(false); + CheckSingleMode(true); + + int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName); + int32_t fieldPos = FindField(fieldId); + + if (fieldPos <= 0) + return -1; + + stream->Position(fieldPos); + + int32_t size; + int32_t id = StartContainerSession(false, IGNITE_TYPE_COLLECTION, &size); + + // Reading collection type. We don't need it here but it should be read. + if (size != -1) + stream->ReadInt8(); + + while (HasNextElement(id)) + { + *out = ReadElement<T>(id); + ++out; + } + + return size; + } + + /** + * Start map read. + * + * @param typ Map type. + * @param size Map size. + * @return Read session ID. + */ + int32_t ReadMap(ignite::binary::MapType* typ, int32_t* size); + + /** + * Start map read. + * + * @param fieldName Field name. + * @param typ Map type. + * @param size Map size. + * @return Read session ID. + */ + int32_t ReadMap(const char* fieldName, ignite::binary::MapType* typ, int32_t* size); + + /** + * Read type of the collection. + * + * @return Collection type. + */ + ignite::binary::CollectionType ReadCollectionType(); + + /** + * Read type of the collection. + * + * @param fieldName Field name. + * @return Collection type. + */ + ignite::binary::CollectionType ReadCollectionType(const char* fieldName); + + /** + * Read size of the collection. + * + * @return Collection size. + */ + int32_t ReadCollectionSize(); + + /** + * Read size of the collection. + * + * @param fieldName Field name. + * @return Collection size. + */ + int32_t ReadCollectionSize(const char* fieldName); + + /** + * Check whether next value exists. + * + * @param id Session ID. + * @return True if next element exists for the given session. + */ + bool HasNextElement(int32_t id) const; + + /** + * Read element. + * + * @param id Session ID. + * @return Value. + */ + template<typename T> + T ReadElement(const int32_t id) + { + CheckSession(id); + + if (++elemRead == elemCnt) { + elemId = 0; + elemCnt = -1; + elemRead = 0; + } + + return ReadTopObject<T>(); + } + + /** + * Read element. + * + * @param id Session ID. + * @param key Key. + * @param val Value. + */ + template<typename K, typename V> + void ReadElement(const int32_t id, K* key, V* val) + { + CheckSession(id); + + if (++elemRead == elemCnt) { + elemId = 0; + elemCnt = -1; + elemRead = 0; + } + + *key = ReadTopObject<K>(); + *val = ReadTopObject<V>(); + } + + /** + * Read object. + * + * @return Object. + */ + template<typename T> + T ReadObject() + { + CheckRawMode(true); + + return ReadTopObject<T>(); + } + + /** + * Read object. + * + * @param fieldName Field name. + * @return Object. + */ + template<typename T> + T ReadObject(const char* fieldName) + { + CheckRawMode(false); + + int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName); + + int32_t fieldPos = FindField(fieldId); + + if (fieldPos <= 0) + return GetNull<T>(); + + stream->Position(fieldPos); + + return ReadTopObject<T>(); + } + + /** + * Set raw mode. + */ + void SetRawMode(); + + /** + * Read object. + * + * @return Read object. + */ + template<typename T> + T ReadTopObject() + { + int32_t pos = stream->Position(); + int8_t hdr = stream->ReadInt8(); + + switch (hdr) + { + case IGNITE_HDR_NULL: + { + return GetNull<T>(); + } + + case IGNITE_HDR_HND: + { + IGNITE_ERROR_1(ignite::IgniteError::IGNITE_ERR_BINARY, + "Circular references are not supported."); + } + + case IGNITE_TYPE_BINARY: + { + int32_t portLen = stream->ReadInt32(); // Total length of binary object. + int32_t curPos = stream->Position(); + int32_t portOff = stream->ReadInt32(curPos + portLen); + + stream->Position(curPos + portOff); // Position stream right on the object. + + T val = ReadTopObject<T>(); + + stream->Position(curPos + portLen + 4); // Position stream after binary. + + return val; + } + + case IGNITE_HDR_FULL: + { + int8_t protoVer = stream->ReadInt8(); + + if (protoVer != IGNITE_PROTO_VER) { + IGNITE_ERROR_2(ignite::IgniteError::IGNITE_ERR_BINARY, + "Unsupported binary protocol version: ", protoVer); + } + + int16_t flags = stream->ReadInt16(); + int32_t typeId = stream->ReadInt32(); + int32_t hashCode = stream->ReadInt32(); + int32_t len = stream->ReadInt32(); + + // Ignoring Schema Id for now. + stream->ReadInt32(); + + int32_t schemaOrRawOff = stream->ReadInt32(); + + int32_t rawOff; + int32_t footerBegin; + + if (flags & IGNITE_BINARY_FLAG_RAW_ONLY) + footerBegin = len; + else + footerBegin = schemaOrRawOff; + + BinaryOffsetType schemaType; + int32_t trailingBytes; + + if (flags & IGNITE_BINARY_FLAG_OFFSET_1_BYTE) + { + schemaType = OFFSET_TYPE_1_BYTE; + + trailingBytes = (len - footerBegin) % 5; + } + else if (flags & IGNITE_BINARY_FLAG_OFFSET_2_BYTE) + { + schemaType = OFFSET_TYPE_2_BYTE; + + trailingBytes = (len - footerBegin) % 6; + } + else + { + schemaType = OFFSET_TYPE_4_BYTE; + + trailingBytes = (len - footerBegin) % 8; + } + + int32_t footerEnd = len - trailingBytes; + + if (trailingBytes) + rawOff = stream->ReadInt32(pos + len - 4); + else + rawOff = schemaOrRawOff; + + bool usrType = flags & IGNITE_BINARY_FLAG_USER_OBJECT; + + footerBegin += pos; + footerEnd += pos; + + ignite::binary::BinaryType<T> type; + TemplatedBinaryIdResolver<T> idRslvr(type); + BinaryReaderImpl readerImpl(stream, &idRslvr, pos, usrType, + typeId, hashCode, len, rawOff, + footerBegin, footerEnd, schemaType); + ignite::binary::BinaryReader reader(&readerImpl); + + T val = type.Read(reader); + + stream->Position(pos + len); + + return val; + } + + default: + { + IGNITE_ERROR_2(ignite::IgniteError::IGNITE_ERR_BINARY, + "Unexpected header during deserialization: ", hdr); + } + } + } + + /** + * Get NULL value for the given type. + */ + template<typename T> + T GetNull() const + { + ignite::binary::BinaryType<T> type; + + return type.GetNull(); + } + + /** + * Get underlying stream. + * + * @return Stream. + */ + impl::interop::InteropInputStream* GetStream(); + private: + /** Underlying stream. */ + interop::InteropInputStream* stream; + + /** ID resolver. */ + BinaryIdResolver* idRslvr; + + /** Position in the stream where this object starts. */ + int32_t pos; + + /** Whether this is user type or system type. */ + bool usrType; + + /** Type ID as defined in the stream. */ + int32_t typeId; + + /** Hash code. */ + int32_t hashCode; + + /** Total object length in the stream. */ + int32_t len; + + /** Raw data offset. */ + int32_t rawOff; + + /** Raw mode flag. */ + bool rawMode; + + /** Elements read session ID generator. */ + int32_t elemIdGen; + + /** Elements read session ID. */ + int32_t elemId; + + /** Total amount of elements in collection. */ + int32_t elemCnt; + + /** Amount of elements read. */ + int32_t elemRead; + + /** Footer beginning position. */ + int32_t footerBegin; + + /** Footer ending position. */ + int32_t footerEnd; + + /** Object schema type. */ + BinaryOffsetType schemaType; + + IGNITE_NO_COPY_ASSIGNMENT(BinaryReaderImpl) + + /** + * Internal routine to read Guid array. + * + * @param stream Stream. + * @param res Resulting array. + * @param len Length. + */ + static void ReadGuidArrayInternal( + interop::InteropInputStream* stream, + Guid* res, + const int32_t len + ); + + /** + * Read single value in raw mode. + * + * @param stream Stream. + * @param func Function to be invoked on stream. + * @return Result. + */ + template<typename T> + T ReadRaw( + T(*func) (interop::InteropInputStream*) + ) + { + { + CheckRawMode(true); + CheckSingleMode(true); + + return func(stream); + } + } + + /** + * Read single value. + * + * @param fieldName Field name. + * @param func Function to be invoked on stream. + * @param epxHdr Expected header. + * @param dflt Default value returned if field is not found. + * @return Result. + */ + template<typename T> + T Read( + const char* fieldName, + T(*func) (interop::InteropInputStream*), + const int8_t expHdr, + T dflt + ) + { + { + CheckRawMode(false); + CheckSingleMode(true); + + int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName); + int32_t fieldPos = FindField(fieldId); + + if (fieldPos <= 0) + return dflt; + + stream->Position(fieldPos); + + int8_t typeId = stream->ReadInt8(); + + if (typeId == IGNITE_HDR_NULL) + return dflt; + + if (typeId != expHdr) + { + int32_t pos = stream->Position(); + + IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid type ID", + "position", pos, "expected", static_cast<int>(expHdr), "actual", static_cast<int>(typeId)) + } + + return func(stream); + } + } + + /** + * Read array in raw mode. + * + * @param res Resulting array. + * @param len Length. + * @param func Function to be invoked on stream. + * @param expHdr Expected header. + * @return Length. + */ + template<typename T> + int32_t ReadRawArray( + T* res, + const int32_t len, + void(*func)(interop::InteropInputStream*, T* const, const int32_t), + const int8_t expHdr + ) + { + { + CheckRawMode(true); + CheckSingleMode(true); + + return ReadArrayInternal(res, len, stream, func, expHdr); + } + } + + /** + * Read array. + * + * @param fieldName Field name. + * @param res Resulting array. + * @param len Length. + * @param func Function to be invoked on stream. + * @param expHdr Expected header. + * @return Length. + */ + template<typename T> + int32_t ReadArray( + const char* fieldName, + T* res, + const int32_t len, + void(*func)(interop::InteropInputStream*, T* const, const int32_t), + const int8_t expHdr + ) + { + { + CheckRawMode(false); + CheckSingleMode(true); + + int32_t pos = stream->Position(); + + int32_t fieldId = idRslvr->GetFieldId(typeId, fieldName); + int32_t fieldPos = FindField(fieldId); + + if (fieldPos <= 0) + return -1; + + stream->Position(fieldPos); + + int32_t realLen = ReadArrayInternal(res, len, stream, func, expHdr); + + return realLen; + } + } + + /** + * Internal read array routine. + * + * @param res Resulting array. + * @param len Length. + * @param stream Stream. + * @param func Function to be invoked on stream. + * @param expHdr Expected header. + * @return Length. + */ + template<typename T> + static int32_t ReadArrayInternal( + T* res, + const int32_t len, + interop::InteropInputStream* stream, + void(*func)(interop::InteropInputStream*, T* const, const int32_t), + const int8_t expHdr + ) + { + { + int8_t hdr = stream->ReadInt8(); + + if (hdr == expHdr) + { + int32_t realLen = stream->ReadInt32(); + + if (realLen == 0 || (res && len >= realLen)) + func(stream, res, realLen); + else + stream->Position(stream->Position() - 5); + + return realLen; + } + else if (hdr != IGNITE_HDR_NULL) + ThrowOnInvalidHeader(stream->Position() - 1, expHdr, hdr); + + return -1; + } + } + + /** + * Read nullable value. + * + * @param stream Stream. + * @param func Function to be invoked on stream. + * @param expHdr Expected header. + */ + template<typename T> + static T ReadNullable( + interop::InteropInputStream* stream, + T(*func)(interop::InteropInputStream*), + const int8_t expHdr + ) + { + { + int8_t hdr = stream->ReadInt8(); + + if (hdr == expHdr) + return func(stream); + else if (hdr == IGNITE_HDR_NULL) + return Guid(); + else { + ThrowOnInvalidHeader(stream->Position() - 1, expHdr, hdr); + + return Guid(); + } + } + } + + /** + * Seek field with the given ID. + * + * @param fieldId Field ID. + * @return Field length or -1 if field is not found. + */ + int32_t FindField(const int32_t fieldId); + + /** + * Check raw mode. + * + * @param expected Expected raw mode of the reader. + */ + void CheckRawMode(bool expected) const; + + /** + * Check whether reader is currently operating in single mode. + * + * @param expected Expected value. + */ + void CheckSingleMode(bool expected) const; + + /** + * Start new container reader session. + * + * @param expRawMode Expected raw mode. + * @param expHdr Expected header. + * @param size Container size. + * @return Session ID. + */ + int32_t StartContainerSession(const bool expRawMode, const int8_t expHdr, int32_t* size); + + /** + * Check whether session ID matches. + * + * @param ses Expected session ID. + */ + void CheckSession(int32_t expSes) const; + + /** + * Throw an error due to invalid header. + * + * @param pos Position in the stream. + * @param expHdr Expected header. + * @param hdr Actual header. + */ + static void ThrowOnInvalidHeader(int32_t pos, int8_t expHdr, int8_t hdr); + + /** + * Throw an error due to invalid header. + * + * @param expHdr Expected header. + * @param hdr Actual header. + */ + void ThrowOnInvalidHeader(int8_t expHdr, int8_t hdr) const; + + /** + * Internal string read routine. + * + * @param res Resulting array. + * @param len Length of array. + * @return Real array length. + */ + int32_t ReadStringInternal(char* res, const int32_t len); + + /** + * Read type of the collection. Do not preserve stream position. + * + * @return Collection type. + */ + ignite::binary::CollectionType ReadCollectionTypeUnprotected(); + + /** + * Read size of the collection. Do not preserve stream position. + * + * @return Collection size. + */ + int32_t ReadCollectionSizeUnprotected(); + + /** + * Read value. + * + * @param expHdr Expected header. + * @param func Function to be applied to the stream. + */ + template<typename T> + T ReadTopObject0(const int8_t expHdr, T(*func) (ignite::impl::interop::InteropInputStream*)) + { + int8_t typeId = stream->ReadInt8(); + + if (typeId == expHdr) + return func(stream); + else if (typeId == IGNITE_HDR_NULL) + return GetNull<T>(); + else { + int32_t pos = stream->Position() - 1; + + IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", expHdr, "actual", typeId) + } + } + + /** + * Read value. + * + * @param expHdr Expected header. + * @param func Function to be applied to the stream. + * @param dflt Default value. + */ + template<typename T> + T ReadTopObject0(const int8_t expHdr, T(*func) (ignite::impl::interop::InteropInputStream*), T dflt) + { + int8_t typeId = stream->ReadInt8(); + + if (typeId == expHdr) + return func(stream); + else if (typeId == IGNITE_HDR_NULL) + return dflt; + else { + int32_t pos = stream->Position() - 1; + + IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", expHdr, "actual", typeId) + } + } + }; + + template<> + int8_t IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<int8_t>(); + + template<> + bool IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<bool>(); + + template<> + int16_t IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<int16_t>(); + + template<> + uint16_t IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<uint16_t>(); + + template<> + int32_t IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<int32_t>(); + + template<> + int64_t IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<int64_t>(); + + template<> + float IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<float>(); + + template<> + double IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<double>(); + + + template<> + Guid IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<Guid>(); + + template<> + inline std::string IGNITE_IMPORT_EXPORT BinaryReaderImpl::ReadTopObject<std::string>() + { + int8_t typeId = stream->ReadInt8(); + + if (typeId == IGNITE_TYPE_STRING) + { + int32_t realLen = stream->ReadInt32(); + + ignite::impl::utils::SafeArray<char> arr(realLen + 1); + + for (int i = 0; i < realLen; i++) + *(arr.target + i) = static_cast<char>(stream->ReadInt8()); + + *(arr.target + realLen) = 0; + + return std::string(arr.target); + } + + else if (typeId == IGNITE_HDR_NULL) + return std::string(); + else { + int32_t pos = stream->Position() - 1; + + IGNITE_ERROR_FORMATTED_3(IgniteError::IGNITE_ERR_BINARY, "Invalid header", "position", pos, "expected", IGNITE_TYPE_STRING, "actual", typeId) + } + } + } + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_schema.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_schema.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_schema.h new file mode 100644 index 0000000..d0a9f26 --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_schema.h @@ -0,0 +1,136 @@ +/* + * 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_SCHEMA +#define _IGNITE_IMPL_BINARY_SCHEMA + +#include <vector> +#include <stdint.h> + +#include <ignite/common/common.h> +#include <ignite/impl/interop/interop_output_stream.h> + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** Binary writer implementation forward declaration. */ + class BinaryWriterImpl; + + /** + * Schema size variants. + */ + enum BinaryOffsetType + { + /** Means all field offsets can be fit in one byte. */ + OFFSET_TYPE_1_BYTE, + + /** Means all field offsets can be fit in two bytes. */ + OFFSET_TYPE_2_BYTE, + + /** Means field offsets should be stored in four bytes. */ + OFFSET_TYPE_4_BYTE + }; + + /** + * Binary schema. + */ + class IGNITE_IMPORT_EXPORT BinarySchema + { + public: + /** + * Default constructor. + */ + BinarySchema(); + + /** + * Destructor. + */ + ~BinarySchema(); + + /** + * Add another field to schema. + * + * @param id Field id. + * @param offset Field offset. + */ + void AddField(int32_t fieldId, int32_t offset); + + /** + * Write Schema to stream. + * + * @param out Stream to write schema to. + */ + void Write(interop::InteropOutputStream& out) const; + + /** + * Get Schema ID. + * + * @return Schema id. + */ + int32_t GetId() const + { + return id; + } + + /** + * Check if the schema contains field info. + * + * @return True if does not contain field info. + */ + bool Empty() const; + + /** + * Clear schema info. + */ + void Clear(); + + /** + * Get type of schema. + * + * @return Type of schema. + */ + BinaryOffsetType GetType() const; + + private: + /** + * Single schema field info. + */ + struct BinarySchemaFieldInfo + { + int32_t id; + int32_t offset; + }; + + /** Type alias for vector of field info. */ + typedef std::vector<BinarySchemaFieldInfo> FieldContainer; + + /** Schema ID. */ + int32_t id; + + /** Information about written fields. */ + FieldContainer* fieldsInfo; + + IGNITE_NO_COPY_ASSIGNMENT(BinarySchema) + }; + } + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_handler.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_handler.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_handler.h new file mode 100644 index 0000000..ba684c2 --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_handler.h @@ -0,0 +1,102 @@ +/* + * 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_TYPE_HANDLER +#define _IGNITE_IMPL_BINARY_TYPE_HANDLER + +#include <ignite/common/concurrent.h> + +#include "ignite/impl/binary/binary_type_snapshot.h" + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Type handler. Tracks all type updates during write session. + */ + class BinaryTypeHandler + { + public: + /** + * Constructor. + * + * @param snap Snapshot. + */ + BinaryTypeHandler(SPSnap snap); + + /** + * Destructor. + */ + ~BinaryTypeHandler(); + + /** + * Callback invoked when field is being written. + * + * @param fieldId Field ID. + * @param fieldName Field name. + * @param fieldTypeId Field type ID. + */ + void OnFieldWritten(int32_t fieldId, std::string fieldName, int32_t fieldTypeId); + + /** + * Get initial snapshot. + * + * @param Snapshot. + */ + SPSnap GetSnapshot(); + + /** + * Whether any difference exists. + * + * @param True if difference exists. + */ + bool HasDifference(); + + /** + * Get recorded field IDs difference. + * + * @param Recorded field IDs difference. + */ + std::set<int32_t>* GetFieldIds(); + + /** + * Get recorded fields difference. + * + * @param Recorded fields difference. + */ + std::map<std::string, int32_t>* GetFields(); + + private: + /** Snapshot. */ + SPSnap snap; + + /** Recorded field IDs difference. */ + std::set<int32_t>* fieldIds; + + /** Recorded fields difference. */ + std::map<std::string, int32_t>* fields; + + IGNITE_NO_COPY_ASSIGNMENT(BinaryTypeHandler) + }; + } + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_manager.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_manager.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_manager.h new file mode 100644 index 0000000..b937bd1 --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_manager.h @@ -0,0 +1,120 @@ +/* + * 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_TYPE_MANAGER +#define _IGNITE_IMPL_BINARY_TYPE_MANAGER + +#include <vector> + +#include "ignite/ignite_error.h" +#include "ignite/impl/binary/binary_type_handler.h" +#include "ignite/impl/binary/binary_type_updater.h" + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Type manager. + */ + class IGNITE_IMPORT_EXPORT BinaryTypeManager + { + public: + /** + * Constructor. + */ + BinaryTypeManager(); + + /** + * Destructor. + */ + ~BinaryTypeManager(); + + /** + * Get handler. + * + * @param typeId Type ID. + */ + ignite::common::concurrent::SharedPointer<BinaryTypeHandler> GetHandler(int32_t typeId); + + /** + * Submit handler for processing. + * + * @param typeName Type name. + * @param typeId Type ID. + * @param hnd Handler. + */ + void SubmitHandler(std::string typeName, int32_t typeId, BinaryTypeHandler* hnd); + + /** + * Get current type manager version. + * + * @param Version. + */ + int32_t GetVersion(); + + /** + * Check whether something is updated since the given version. + * + * @param oldVer Old version. + * @return True if updated and it is very likely that pending type exists. + */ + bool IsUpdatedSince(int32_t oldVer); + + /** + * Process pending updates. + * + * @param updated Updater. + * @param err Error. + * @return In case of success. + */ + bool ProcessPendingUpdates(BinaryTypeUpdater* updater, IgniteError* err); + + private: + /** Current snapshots. */ + ignite::common::concurrent::SharedPointer<std::map<int32_t, SPSnap>> snapshots; + + /** Pending snapshots. */ + std::vector<SPSnap>* pending; + + /** Critical section. */ + ignite::common::concurrent::CriticalSection* cs; + + /** Version of pending changes. */ + int32_t pendingVer; + + /** Latest version. */ + int32_t ver; + + IGNITE_NO_COPY_ASSIGNMENT(BinaryTypeManager); + + /** + * Copy fields from a snapshot into relevant collections. + * + * @param snap Target snapshot. + * @param fieldIds Field IDs. + * @param fields Fields. + */ + void CopyFields(Snap* snap, std::set<int32_t>* fieldIds, std::map<std::string, int32_t>* fields); + }; + } + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_snapshot.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_snapshot.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_snapshot.h new file mode 100644 index 0000000..30055cc --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_snapshot.h @@ -0,0 +1,122 @@ +/* + * 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_TYPE_SNAPSHOT +#define _IGNITE_IMPL_BINARY_TYPE_SNAPSHOT + +#include <map> +#include <set> +#include <stdint.h> +#include <string> + +#include <ignite/common/common.h> +#include <ignite/common/concurrent.h> + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Type snapshot. + */ + class BinaryTypeSnapshot + { + public: + /** + * Constructor. + * + * @param typeName Type name. + * @param typeId Type ID. + * @param fieldIds Field IDs. + * @param fields Fields. + */ + BinaryTypeSnapshot(std::string typeName, int32_t typeId, std::set<int32_t>* fieldIds, + std::map<std::string, int32_t>* fields); + + /** + * Destructor. + */ + ~BinaryTypeSnapshot(); + + /** + * Check whether snapshot contains a field with the given ID. + * + * @param fieldId Field ID. + * @return True if contains, false otherwise. + */ + bool ContainsFieldId(int32_t fieldId); + + /** + * Get type name. + * + * @param Type name. + */ + std::string GetTypeName(); + + /** + * Get type ID. + * + * @return Type ID. + */ + int32_t GetTypeId(); + + /** + * Whether snapshot contains any fields. + * + * @param True if fields exist. + */ + bool HasFields(); + + /** + * Get field IDs. + * + * @param Field IDs. + */ + std::set<int32_t>* GetFieldIds(); + + /** + * Get fields. + * + * @return Fields. + */ + std::map<std::string, int32_t>* GetFields(); + + private: + /** Type name. */ + std::string typeName; + + /** Type ID. */ + int32_t typeId; + + /** Known field IDs. */ + std::set<int32_t>* fieldIds; + + /** Field name-type mappings. */ + std::map<std::string, int32_t>* fields; + + IGNITE_NO_COPY_ASSIGNMENT(BinaryTypeSnapshot) + }; + + typedef BinaryTypeSnapshot Snap; + typedef ignite::common::concurrent::SharedPointer<Snap> SPSnap; + } + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater.h new file mode 100644 index 0000000..9343b19 --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater.h @@ -0,0 +1,53 @@ +/* + * 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_TYPE_UPDATER +#define _IGNITE_IMPL_BINARY_TYPE_UPDATER + +#include "ignite/ignite_error.h" +#include "ignite/impl/binary/binary_type_snapshot.h" + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Type updater interface. + */ + class IGNITE_IMPORT_EXPORT BinaryTypeUpdater + { + public: + /** + * Destructor. + */ + virtual ~BinaryTypeUpdater(); + + /** + * Update type using provided snapshot. + * + * @param snapshot Snapshot. + * @param err Error. + */ + virtual bool Update(Snap* snapshot, IgniteError* err) = 0; + }; + } + } +} + +#endif \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/303d79eb/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater_impl.h ---------------------------------------------------------------------- diff --git a/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater_impl.h b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater_impl.h new file mode 100644 index 0000000..a0e4a7b --- /dev/null +++ b/modules/platforms/cpp/core/include/ignite/impl/binary/binary_type_updater_impl.h @@ -0,0 +1,65 @@ +/* + * 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_TYPE_UPDATER_IMPL +#define _IGNITE_IMPL_BINARY_TYPE_UPDATER_IMPL + +#include <ignite/common/exports.h> + +#include "ignite/impl/ignite_environment.h" +#include "ignite/impl/binary/binary_type_updater.h" + +namespace ignite +{ + namespace impl + { + namespace binary + { + /** + * Type updater implementation. + */ + class IGNITE_IMPORT_EXPORT BinaryTypeUpdaterImpl : public BinaryTypeUpdater + { + public: + /** + * Constructor. + * + * @param env Environment. + * @param javaRef Reference to Java object which is able to process type request. + */ + BinaryTypeUpdaterImpl(ignite::common::concurrent::SharedPointer<IgniteEnvironment> env, jobject javaRef); + + /** + * Destructor. + */ + ~BinaryTypeUpdaterImpl(); + + bool Update(Snap* snapshot, IgniteError* err); + private: + /** Environment. */ + ignite::common::concurrent::SharedPointer<IgniteEnvironment> env; + + /** Handle to Java object. */ + jobject javaRef; + + IGNITE_NO_COPY_ASSIGNMENT(BinaryTypeUpdaterImpl) + }; + } + } +} + +#endif \ No newline at end of file