binary_raw_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_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/binary/binary_enum_entry.h"
#include "ignite/guid.h"
#include "ignite/date.h"
#include "ignite/timestamp.h"
 
namespace ignite
{    
    namespace binary
    {
        class IGNITE_IMPORT_EXPORT BinaryRawReader
        {
        public:
            BinaryRawReader(ignite::impl::binary::BinaryReaderImpl* impl);
                        
            int8_t ReadInt8();
 
            int32_t ReadInt8Array(int8_t* res, int32_t len);
 
            bool ReadBool();
 
            int32_t ReadBoolArray(bool* res, int32_t len);
            
            int16_t ReadInt16();
 
            int32_t ReadInt16Array(int16_t* res, int32_t len);
 
            uint16_t ReadUInt16();
 
            int32_t ReadUInt16Array(uint16_t* res, int32_t len);
 
            int32_t ReadInt32();
            
            int32_t ReadInt32Array(int32_t* res, int32_t len);
 
            int64_t ReadInt64();
 
            int32_t ReadInt64Array(int64_t* res, int32_t len);
 
            float ReadFloat();
            
            int32_t ReadFloatArray(float* res, int32_t len);
 
            double ReadDouble();
            
            int32_t ReadDoubleArray(double* res, int32_t len);
 
            Guid ReadGuid();
 
            int32_t ReadGuidArray(Guid* res, int32_t len);
 
            Date ReadDate();
 
            int32_t ReadDateArray(Date* res, int32_t len);
 
            Timestamp ReadTimestamp();
 
            int32_t ReadTimestampArray(Timestamp* res, int32_t len);
 
            Time ReadTime();
 
            int32_t ReadTimeArray(Time* res, int32_t len);
 
            int32_t ReadString(char* res, int32_t len);
 
            std::string ReadString()
            {
                std::string res;
 
                ReadString(res);
 
                return res;
            }
 
            void ReadString(std::string& dst)
            {
                int32_t len = ReadString(NULL, 0);
 
                if (len != -1)
                {
                    dst.resize(static_cast<size_t>(len));
 
                    ReadString(&dst[0], len);
                }
                else
                    dst.clear();
            }
 
            BinaryStringArrayReader ReadStringArray();
 
            BinaryEnumEntry ReadBinaryEnum();
 
            template<typename T>
            BinaryArrayReader<T> ReadArray()
            {
                int32_t size;
 
                int32_t id = impl->ReadArray(&size);
 
                return BinaryArrayReader<T>(impl, id, size);
            }
 
            template<typename T>
            BinaryCollectionReader<T> ReadCollection()
            {
                CollectionType::Type typ;
                int32_t size;
 
                int32_t id = impl->ReadCollection(&typ, &size);
 
                return BinaryCollectionReader<T>(impl, id, typ, size);
            }
 
            template<typename T, typename OutputIterator>
            int32_t ReadCollection(OutputIterator out)
            {
                return impl->ReadCollection<T>(out);
            }
 
            template<typename K, typename V>
            BinaryMapReader<K, V> ReadMap()
            {
                MapType::Type typ;
                int32_t size;
 
                int32_t id = impl->ReadMap(&typ, &size);
 
                return BinaryMapReader<K, V>(impl, id, typ, size);
            }
 
            CollectionType::Type ReadCollectionType();
 
            int32_t ReadCollectionSize();
 
            template<typename T>
            T ReadObject()
            {
                return impl->ReadObject<T>();
            }
 
            template<typename T>
            T ReadEnum()
            {
                return impl->ReadEnum<T>();
            }
 
            template<typename T>
            bool TryReadObject(T& res)
            {
                if (impl->SkipIfNull())
                    return false;
 
                res = impl->ReadObject<T>();
 
                return true;
            }
 
        private:
            ignite::impl::binary::BinaryReaderImpl* impl;  
        };
    }
}
 
#endif //_IGNITE_BINARY_BINARY_RAW_READER