binary_reader.h

Go to the documentation of this file.

/*
 * 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_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
    {
        class IGNITE_IMPORT_EXPORT BinaryReader
        {
        public:
            BinaryReader(ignite::impl::binary::BinaryReaderImpl* impl);

            int8_t ReadInt8(const char* fieldName);

            int32_t ReadInt8Array(const char* fieldName, int8_t* res, int32_t len);

            bool ReadBool(const char* fieldName);

            int32_t ReadBoolArray(const char* fieldName, bool* res, int32_t len);

            int16_t ReadInt16(const char* fieldName);

            int32_t ReadInt16Array(const char* fieldName, int16_t* res, int32_t len);

            uint16_t ReadUInt16(const char* fieldName);

            int32_t ReadUInt16Array(const char* fieldName, uint16_t* res, int32_t len);

            int32_t ReadInt32(const char* fieldName);

            int32_t ReadInt32Array(const char* fieldName, int32_t* res, int32_t len);

            int64_t ReadInt64(const char* fieldName);

            int32_t ReadInt64Array(const char* fieldName, int64_t* res, int32_t len);

            float ReadFloat(const char* fieldName);

            int32_t ReadFloatArray(const char* fieldName, float* res, int32_t len);

            double ReadDouble(const char* fieldName);

            int32_t ReadDoubleArray(const char* fieldName, double* res, int32_t len);

            Guid ReadGuid(const char* fieldName);

            int32_t ReadGuidArray(const char* fieldName, Guid* res, int32_t len);

            Date ReadDate(const char* fieldName);

            int32_t ReadDateArray(const char* fieldName, Date* res, const int32_t len);

            Timestamp ReadTimestamp(const char* fieldName);

            int32_t ReadTimestampArray(const char* fieldName, Timestamp* res, const int32_t len);

            int32_t ReadString(const char* fieldName, char* res, int32_t len);

            std::string ReadString(const char* fieldName)
            {
                int32_t len = ReadString(fieldName, NULL, 0);

                if (len != -1)
                {
                    ignite::common::FixedSizeArray<char> arr(len + 1);

                    ReadString(fieldName, arr.GetData(), static_cast<int32_t>(arr.GetSize()));

                    return std::string(arr.GetData());
                }
                else
                    return std::string();
            }

            BinaryStringArrayReader ReadStringArray(const char* fieldName);

            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);
            }

            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);
            }

            template<typename T, typename OutputIterator>
            int32_t ReadCollection(const char* fieldName, OutputIterator out)
            {
                return impl->ReadCollection<T>(fieldName, out);
            }

            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);
            }

            CollectionType ReadCollectionType(const char* fieldName);

            int32_t ReadCollectionSize(const char* fieldName);

            template<typename T>
            T ReadObject(const char* fieldName)
            {
                return impl->ReadObject<T>(fieldName);
            }

            BinaryRawReader RawReader();
        private:
            ignite::impl::binary::BinaryReaderImpl* impl;
        };            
    }
}

#endif //_IGNITE_BINARY_BINARY_READER