ObjectDataOutput.h

/*
 * Copyright (c) 2008-2017, 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.
 */
//
// Created by sancar koyunlu on 8/12/13.

#ifndef HAZELCAST_ObjectDataOutput
#define HAZELCAST_ObjectDataOutput

#include "hazelcast/client/serialization/pimpl/SerializationConstants.h"
#include "hazelcast/client/exception/HazelcastSerializationException.h"
#include "hazelcast/client/serialization/pimpl/SerializerHolder.h"
#include "hazelcast/client/serialization/pimpl/PortableContext.h"
#include "hazelcast/client/serialization/Serializer.h"
#include "hazelcast/util/IOUtil.h"
#include "hazelcast/client/serialization/TypeIDS.h"
#include "hazelcast/client/PartitionAware.h"

#include<stdint.h>

#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 {
            namespace pimpl {
                class DataOutput;

                class Data;
            }

            class HAZELCAST_API ObjectDataOutput {
            public:
                ObjectDataOutput(pimpl::DataOutput& dataOutput, pimpl::PortableContext& portableContext);

                ObjectDataOutput();

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

                void write(const std::vector<byte>& bytes);

                void writeBoolean(bool value);

                void writeByte(int32_t value);

                void writeBytes(const byte *bytes, size_t len);

                void writeShort(int32_t value);

                void writeChar(int32_t value);

                void writeInt(int32_t value);

                void writeLong(int64_t value);

                void writeFloat(float value);

                void writeDouble(double value);

                void writeUTF(const std::string *value);

                void writeByteArray(const std::vector<byte> *value);

                void writeCharArray(const std::vector<char> *value);

                void writeBooleanArray(const std::vector<bool> *value);

                void writeShortArray(const std::vector<int16_t> *value);

                void writeIntArray(const std::vector<int32_t> *value);

                void writeLongArray(const std::vector<int64_t > *value);

                void writeFloatArray(const std::vector<float> *value);

                void writeDoubleArray(const std::vector<double> *value);

                void writeUTFArray(const std::vector<std::string *> *strings);

                void writeData(const pimpl::Data *value);

                template <typename T>
                void writeObject(const Portable *object) {
                    if (isEmpty) return;

                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_PORTABLE);

                        writeInt(object->getFactoryId());
                        writeInt(object->getClassId());

                        context->getSerializerHolder().getPortableSerializer().write(*this->dataOutput, *object);
                    }
                }

                template<typename T>
                void writeObject(const IdentifiedDataSerializable *object) {
                    if (isEmpty) return;

                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_DATA);
                        context->getSerializerHolder().getDataSerializer().write(*this, *object);
                    }
                }

                template <typename T>
                void writeObject(const void *serializable) {
                    if (isEmpty) return;

                    if (NULL == serializable) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        const T *object = static_cast<const T *>(serializable);
                        int32_t type = getHazelcastTypeId(object);
                        writeInt(type);

                        boost::shared_ptr<SerializerBase> serializer = context->getSerializerHolder().serializerFor(type);

                        if (NULL == serializer.get()) {
                            const std::string message = "No serializer found for serializerId :"+
                                                         util::IOUtil::to_string(type) + ", typename :" +
                                                         typeid(T).name();
                            throw exception::HazelcastSerializationException("ObjectDataOutput::toData", message);
                        }

                        Serializer<T> *s = static_cast<Serializer<T> * >(serializer.get());

                        s->write(*this, *object);
                    }
                }

                template <typename T>
                void writeObject(const byte *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_BYTE);
                        writeByte(*object);
                    }
                }

                template <typename T>
                void writeObject(const bool *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_BOOLEAN);
                        writeBoolean(*object);
                    }
                }

                template <typename T>
                void writeObject(const char *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_CHAR);
                        writeChar(*object);
                    }
                }

                template <typename T>
                void writeObject(const int16_t *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_SHORT);
                        writeShort(*object);
                    }
                }

                template <typename T>
                void writeObject(const int32_t *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_INTEGER);
                        writeInt(*object);
                    }
                }

                template <typename T>
                void writeObject(const int64_t  *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_LONG);
                        writeLong(*object);
                    }
                }

                template <typename T>
                void writeObject(const float *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_FLOAT);
                        writeFloat(*object);
                    }
                }

                template <typename T>
                void writeObject(const double *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_DOUBLE);
                        writeDouble(*object);
                    }
                }

                template <typename T>
                void writeObject(const std::string *object) {
                    if (NULL == object) {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_NULL);
                    } else {
                        writeInt(pimpl::SerializationConstants::CONSTANT_TYPE_STRING);
                        writeUTF(object);
                    }
                }
            private:
                pimpl::DataOutput *dataOutput;
                pimpl::PortableContext *context;
                pimpl::SerializerHolder *serializerHolder;
                bool isEmpty;

                size_t position();

                void position(size_t newPos);

                ObjectDataOutput(const ObjectDataOutput&);

                void operator=(const ObjectDataOutput&);
            };
        }
    }
}

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

#endif //HAZELCAST_ObjectDataOutput