ObjectDataInput.h

/*
 * Copyright (c) 2008-2019, 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/DataSerializer.h"
#include "hazelcast/client/serialization/pimpl/PortableSerializer.h"
#include "hazelcast/client/serialization/pimpl/ConstantSerializers.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 "hazelcast/util/HazelcastDll.h"

#include <boost/shared_ptr.hpp>
#include <vector>
#include <string>
#include <stdint.h>
#include <memory>

#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 &dataInput, pimpl::SerializerHolder &serializerHolder);

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

                int skipBytes(int i);

                bool readBoolean();

                byte readByte();

                int16_t readShort();

                char readChar();

                int32_t readInt();

                int64_t 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<int32_t> > readIntArray();

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

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

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

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

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

                std::auto_ptr<std::vector<std::string *> > readUTFPointerArray();

                template<typename T>
                std::auto_ptr<T> readObject() {
                    int32_t typeId = readInt();
                    return readObject<T>(typeId);
                }

                template<typename T>
                std::auto_ptr<T> readObject(int32_t typeId) {
                    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);
                    }

                    return readObjectInternal<T>(typeId, serializer);
                }

                pimpl::Data readData();

                int position();

                void position(int newPos);

            private:
                pimpl::DataInput &dataInput;
                pimpl::SerializerHolder &serializerHolder;

                ObjectDataInput(const ObjectDataInput &);

                void operator=(const ObjectDataInput &);

                template<typename T>
                T *getBackwardCompatiblePointer(void *actualData, const T *typePointer) const {
                    return reinterpret_cast<T *>(actualData);
                }

                template<typename T>
                std::auto_ptr<T>
                readObjectInternal(int32_t typeId, const boost::shared_ptr<SerializerBase> &serializer) {
                    switch (typeId) {
                        case serialization::pimpl::SerializationConstants::CONSTANT_TYPE_DATA: {
                            serialization::pimpl::DataSerializer *dataSerializer =
                                    static_cast<serialization::pimpl::DataSerializer *>(serializer.get());
                            return dataSerializer->readObject<T>(*this);
                        }
                        case serialization::pimpl::SerializationConstants::CONSTANT_TYPE_PORTABLE: {
                            serialization::pimpl::PortableSerializer *portableSerializer =
                                    static_cast<serialization::pimpl::PortableSerializer *>(serializer.get());

                            return portableSerializer->readObject<T>(*this);
                        }
                        default: {
                            boost::shared_ptr<StreamSerializer> streamSerializer = boost::static_pointer_cast<StreamSerializer>(
                                    serializer);
                            return std::auto_ptr<T>(getBackwardCompatiblePointer<T>(streamSerializer->read(*this),
                                                                                    (T *) NULL));
                        }
                    }
                }
            };

            template<>
            HAZELCAST_API std::vector<std::string> *ObjectDataInput::getBackwardCompatiblePointer(void *actualData,
                                                                                                  const std::vector<std::string> *typePointer) const;


            template<>
            std::auto_ptr<HazelcastJsonValue>
            HAZELCAST_API
            ObjectDataInput::readObjectInternal(int32_t typeId, const boost::shared_ptr<SerializerBase> &serializer);
        }
    }
}

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

#endif /* HAZELCAST_DATA_INPUT */