PortableWriter.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.
 */
//
// Created by sancar koyunlu on 8/10/13.





#ifndef HAZELCAST_PortableWriter
#define HAZELCAST_PortableWriter

#include "hazelcast/client/serialization/pimpl/DefaultPortableWriter.h"
#include "hazelcast/client/serialization/pimpl/ClassDefinitionWriter.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 {

            class HAZELCAST_API PortableWriter {
            public:
                PortableWriter(pimpl::DefaultPortableWriter *defaultPortableWriter);

                PortableWriter(pimpl::ClassDefinitionWriter *classDefinitionWriter);

                void writeInt(const char *fieldName, int value);

                void writeLong(const char *fieldName, long value);

                void writeBoolean(const char *fieldName, bool value);

                void writeByte(const char *fieldName, byte value);

                void writeChar(const char *fieldName, int value);

                void writeDouble(const char *fieldName, double value);

                void writeFloat(const char *fieldName, float value);

                void writeShort(const char *fieldName, short value);

                void writeUTF(const char *fieldName, const std::string *value);

                void writeByteArray(const char *fieldName, const std::vector<byte> *values);

                void writeCharArray(const char *fieldName, const std::vector<char> *values);

                void writeShortArray(const char *fieldName, const std::vector<short> *values);

                void writeIntArray(const char *fieldName, const std::vector<int> *values);

                void writeLongArray(const char *fieldName, const std::vector<long> *values);

                void writeFloatArray(const char *fieldName, const std::vector<float> *values);

                void writeDoubleArray(const char *fieldName, const std::vector<double> *values);

                void end();

                template<typename T>
                void writeNullPortable(const char *fieldName) {
                    if (isDefaultWriter)
                        return defaultPortableWriter->writeNullPortable<T>(fieldName);
                    return classDefinitionWriter->writeNullPortable<T>(fieldName);
                }

                template<typename T>
                void writePortable(const char *fieldName, const T *portable) {
                    if (isDefaultWriter)
                        return defaultPortableWriter->writePortable(fieldName, portable);
                    return classDefinitionWriter->writePortable(fieldName, portable);

                };

                template<typename T>
                void writePortableArray(const char *fieldName, const std::vector<T> *values) {
                    if (isDefaultWriter)
                        return defaultPortableWriter->writePortableArray(fieldName, values);
                    return classDefinitionWriter->writePortableArray(fieldName, values);
                };

                ObjectDataOutput &getRawDataOutput();

            private:
                pimpl::DefaultPortableWriter *defaultPortableWriter;
                pimpl::ClassDefinitionWriter *classDefinitionWriter;
                bool isDefaultWriter;
            };
        }
    }
}

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

#endif //HAZELCAST_PortableWriter