PortableReader.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_PortableReader
#define HAZELCAST_PortableReader

#include "hazelcast/util/HazelcastDll.h"
#include "hazelcast/client/serialization/pimpl/DefaultPortableReader.h"
#include "hazelcast/client/serialization/pimpl/MorphingPortableReader.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 {
            namespace pimpl {

                class PortableContext;

                class DataInput;
            }

            class ClassDefinition;

            class HAZELCAST_API PortableReader {
            public:

                PortableReader(pimpl::PortableContext& context, pimpl::DataInput& dataInput,
                                boost::shared_ptr<ClassDefinition> cd, bool isDefaultReader);

                PortableReader(const PortableReader & reader);

                PortableReader &operator = (const PortableReader & reader);

                int readInt(const char *fieldName);

                long readLong(const char *fieldName);

                bool readBoolean(const char *fieldName);

                byte readByte(const char *fieldName);

                char readChar(const char *fieldName);

                double readDouble(const char *fieldName);

                float readFloat(const char *fieldName);

                short readShort(const char *fieldName);

                std::auto_ptr<std::string> readUTF(const char *fieldName);

                std::auto_ptr<std::vector<byte> > readByteArray(const char *fieldName);

                std::auto_ptr<std::vector<char> > readCharArray(const char *fieldName);

                std::auto_ptr<std::vector<int> > readIntArray(const char *fieldName);

                std::auto_ptr<std::vector<long> > readLongArray(const char *fieldName);

                std::auto_ptr<std::vector<double> > readDoubleArray(const char *fieldName);

                std::auto_ptr<std::vector<float> > readFloatArray(const char *fieldName);

                std::auto_ptr<std::vector<short> > readShortArray(const char *fieldName);

                template<typename T>
                boost::shared_ptr<T> readPortable(const char *fieldName) {
                    if (isDefaultReader)
                        return defaultPortableReader->readPortable<T>(fieldName);
                    return morphingPortableReader->readPortable<T>(fieldName);
                };

                template<typename T>
                std::vector<T> readPortableArray(const char *fieldName) {
                    if (isDefaultReader)
                        return defaultPortableReader->readPortableArray<T>(fieldName);
                    return morphingPortableReader->readPortableArray<T>(fieldName);
                };

                ObjectDataInput& getRawDataInput();

                void end();

            private:
                bool isDefaultReader;
                mutable std::auto_ptr<pimpl::DefaultPortableReader> defaultPortableReader;
                mutable std::auto_ptr<pimpl::MorphingPortableReader> morphingPortableReader;

            };
        }
    }
}

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

#endif //HAZELCAST_PortableReader