ObjectDataInput.h

/*
 * Copyright (c) 2008-2015, Hazelcast, Inc. All Rights Reserved.
 *
 * Licensed 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.
 */
//
//  ObjectDataInput.h
//  Server
//
//  Created by sancar koyunlu on 1/3/13.
//  Copyright (c) 2013 sancar koyunlu. All rights reserved.
//

#ifndef HAZELCAST_DATA_INPUT
#define HAZELCAST_DATA_INPUT

#include "hazelcast/client/exception/IOException.h"
#include "hazelcast/client/serialization/Serializer.h"
#include "hazelcast/client/serialization/pimpl/SerializerHolder.h"
#include "hazelcast/client/serialization/ClassDefinition.h"
#include "hazelcast/client/serialization/pimpl/PortableContext.h"
#include "hazelcast/client/exception/HazelcastSerializationException.h"
#include "hazelcast/client/serialization/pimpl/SerializationConstants.h"
#include "hazelcast/util/IOUtil.h"
#include "hazelcast/client/serialization/TypeIDS.h"
#include <vector>
#include <boost/shared_ptr.hpp>
#include <string>

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable: 4251) //for dll export
#endif

namespace hazelcast {
    namespace client {
        namespace serialization {
            class Portable;

            class IdentifiedDataSerializable;

            namespace pimpl {
                class PortableContext;

                class DataInput;

                class Data;
            }

            class HAZELCAST_API ObjectDataInput {
            public:
                ObjectDataInput(pimpl::DataInput&, pimpl::PortableContext&);

                void readFully(std::vector<byte>& byteArray);

                int skipBytes(int i);

                bool readBoolean();

                byte readByte();

                short readShort();

                char readChar();

                int readInt();

                long readLong();

                float readFloat();

                double readDouble();

                std::auto_ptr<std::string> readUTF();

                std::auto_ptr<std::vector<byte> > readByteArray();

                std::auto_ptr<std::vector<bool> > readBooleanArray();

                std::auto_ptr<std::vector<char> > readCharArray();

                std::auto_ptr<std::vector<int> > readIntArray();

                std::auto_ptr<std::vector<long> > readLongArray();

                std::auto_ptr<std::vector<double> > readDoubleArray();

                std::auto_ptr<std::vector<float> > readFloatArray();

                std::auto_ptr<std::vector<short> > readShortArray();

                std::auto_ptr<std::vector<std::string> > readUTFArray();

                template<typename T>
                std::auto_ptr<T> readObject() {
                    int typeId = readInt();
                    const pimpl::SerializationConstants& constants = portableContext.getConstants();
                    if (constants.CONSTANT_TYPE_NULL == typeId) {
                        return std::auto_ptr<T>();
                    } else {
                        std::auto_ptr<T> result(new T);
                        constants.checkClassType(getHazelcastTypeId(result.get()) , typeId);
                        if (constants.CONSTANT_TYPE_DATA == typeId) {
                            readDataSerializable(reinterpret_cast<IdentifiedDataSerializable *>(result.get()));
                        } else if (constants.CONSTANT_TYPE_PORTABLE == typeId) {
                            readPortable(reinterpret_cast<Portable *>(result.get()));
                        } else {
                            readInternal<T>(typeId, result.get());
                        }
                        return std::auto_ptr<T>(result.release());
                    }
                }

                pimpl::Data readData();

                int position();

                void position(int newPos);

            private:

                template <typename T>
                void readInternal(int typeId, T * object) {
                    boost::shared_ptr<SerializerBase> serializer = serializerHolder.serializerFor(typeId);
                    if (NULL == serializer.get()) {
                        const std::string message = "No serializer found for serializerId :"+
                                                     util::IOUtil::to_string(typeId) + ", typename :" +
                                                     typeid(T).name();
                        throw exception::HazelcastSerializationException("ObjectDataInput::readInternal", message);
                    }

                    Serializer<T> *s = static_cast<Serializer<T> * >(serializer.get());
                    ObjectDataInput objectDataInput(dataInput, portableContext);
                    s->read(objectDataInput, *object);
                }

                void readPortable(Portable *object);

                void readDataSerializable(IdentifiedDataSerializable * object);

                pimpl::DataInput& dataInput;
                pimpl::PortableContext& portableContext;
                pimpl::SerializerHolder& serializerHolder;

                ObjectDataInput(const ObjectDataInput&);

                void operator=(const ObjectDataInput&);

            };

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, byte *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, bool *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, char *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, short *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, int *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, long *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, float *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, double *object);

            template <>
            HAZELCAST_API void ObjectDataInput::readInternal(int typeId, std::string *object);
        }
    }
}

#if  defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif

#endif /* HAZELCAST_DATA_INPUT */