Future.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.
 */
#ifndef HAZELCAST_CLIENT_FUTURE_H_
#define HAZELCAST_CLIENT_FUTURE_H_

#include <stdint.h>
#include <memory>
#include <assert.h>

#include "hazelcast/client/connection/CallFuture.h"
#include "hazelcast/client/serialization/pimpl/SerializationService.h"
#include "hazelcast/client/connection/CallPromise.h"
#include "hazelcast/client/TypedData.h"
#include "hazelcast/client/protocol/ClientMessage.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 {
        class HAZELCAST_API future_status {
        public:
            future_status(int value) : value(value) { }

            enum enum_type {
                ready,
                timeout
            };

            friend bool operator==(future_status lhs, future_status rhs) {
                return enum_type(lhs.value) == enum_type(rhs.value);
            }

            friend bool operator==(future_status lhs, enum_type rhs) { return enum_type(lhs.value) == rhs; }

            friend bool operator==(enum_type lhs, future_status rhs) { return lhs == enum_type(rhs.value); }

            friend bool operator!=(future_status lhs, future_status rhs) {
                return enum_type(lhs.value) != enum_type(rhs.value);
            }

            friend bool operator!=(future_status lhs, enum_type rhs) { return enum_type(lhs.value) != rhs; }

            friend bool operator!=(enum_type lhs, future_status rhs) { return lhs != enum_type(rhs.value); }

            friend bool operator<(future_status lhs, future_status rhs) {
                return enum_type(lhs.value) < enum_type(rhs.value);
            }

            friend bool operator<(future_status lhs, enum_type rhs) { return enum_type(lhs.value) < rhs; }

            friend bool operator<(enum_type lhs, future_status rhs) { return lhs < enum_type(rhs.value); }

            friend bool operator<=(future_status lhs, future_status rhs) {
                return enum_type(lhs.value) <= enum_type(rhs.value);
            }

            friend bool operator<=(future_status lhs, enum_type rhs) { return enum_type(lhs.value) <= rhs; }

            friend bool operator<=(enum_type lhs, future_status rhs) { return lhs <= enum_type(rhs.value); }

            friend bool operator>(future_status lhs, future_status rhs) {
                return enum_type(lhs.value) > enum_type(rhs.value);
            }

            friend bool operator>(future_status lhs, enum_type rhs) { return enum_type(lhs.value) > rhs; }

            friend bool operator>(enum_type lhs, future_status rhs) { return lhs > enum_type(rhs.value); }

            friend bool operator>=(future_status lhs, future_status rhs) {
                return enum_type(lhs.value) >= enum_type(rhs.value);
            }

            friend bool operator>=(future_status lhs, enum_type rhs) { return enum_type(lhs.value) >= rhs; }

            friend bool operator>=(enum_type lhs, future_status rhs) { return lhs >= enum_type(rhs.value); }

        private:
            int value;
        };

        namespace exception {
            class HAZELCAST_API FutureUninitialized : public IException {
            public:
                FutureUninitialized(const std::string &source, const std::string &message) : IException(source,
                                                                                                        message) { }
            };
        }

        template<typename V>
        class Future {
        public:
            typedef std::auto_ptr<serialization::pimpl::Data> (*Decoder)(protocol::ClientMessage &response);

            Future(connection::CallFuture &callFuture,
                   serialization::pimpl::SerializationService &serializationService,
                   Decoder decoder) : callFuture(new connection::CallFuture(callFuture)),
                                      serializationService(serializationService), decoderFunction(decoder) {
            }

            Future(const Future &movedFuture) : callFuture(movedFuture.callFuture),
                                                serializationService(movedFuture.serializationService),
                                                decoderFunction(movedFuture.decoderFunction) {
            }

            Future &operator=(const Future &movedFuture) {
                this->callFuture = movedFuture.callFuture;
                this->decoderFunction = movedFuture.decoderFunction;
                return *this;
            }

            virtual ~Future() {
            }

            std::auto_ptr<V> get() {
                if (!callFuture.get()) {
                    throw exception::FutureUninitialized("Future::get", "Future needs to be initialized. "
                            "It may have been moved from.");
                }

                std::auto_ptr<protocol::ClientMessage> responseMsg = callFuture->get();

                assert(responseMsg.get());

                callFuture.reset();

                std::auto_ptr<serialization::pimpl::Data> response = decoderFunction(*responseMsg);

                std::auto_ptr<V> result = serializationService.toObject<V>(response.get());

                return result;
            }

            future_status wait_for(int64_t timeoutInMilliseconds) const {
                if (!callFuture.get()) {
                    throw exception::FutureUninitialized("Future::get", "Future needs to be initialized.");
                }

                return callFuture->waitFor(timeoutInMilliseconds) ? future_status::ready : future_status::timeout;
            }

            void wait() const {
                wait_for(INT64_MAX);
            }

            bool valid() const {
                return callFuture.get() != NULL;
            }

        private:
            mutable std::auto_ptr<connection::CallFuture> callFuture;
            serialization::pimpl::SerializationService &serializationService;
            Decoder decoderFunction;
        };

        template<>
        class Future<TypedData> {
        public:
            typedef std::auto_ptr<serialization::pimpl::Data> (*Decoder)(protocol::ClientMessage &response);

            Future(connection::CallFuture &callFuture,
                   serialization::pimpl::SerializationService &serializationService,
                   Decoder decoder) : callFuture(new connection::CallFuture(callFuture)),
                                      serializationService(serializationService), decoderFunction(decoder) {
            }

            Future(const Future &movedFuture) : callFuture(movedFuture.callFuture),
                                                serializationService(movedFuture.serializationService),
                                                decoderFunction(movedFuture.decoderFunction) {
            }

            Future &operator=(const Future &movedFuture) {
                this->callFuture = movedFuture.callFuture;
                this->decoderFunction = movedFuture.decoderFunction;
                return *this;
            }

            virtual ~Future() {
            }

            TypedData get() {
                if (!callFuture.get()) {
                    throw exception::FutureUninitialized("Future::get", "Future needs to be initialized. "
                            "It may have been moved from.");
                }

                std::auto_ptr<protocol::ClientMessage> responseMsg = callFuture->get();

                assert(responseMsg.get());

                callFuture.reset();

                std::auto_ptr<serialization::pimpl::Data> response = decoderFunction(*responseMsg);

                return TypedData(response, serializationService);
            }

            future_status wait_for(int64_t timeoutInMilliseconds) const {
                if (!callFuture.get()) {
                    throw exception::FutureUninitialized("Future::get", "Future needs to be initialized.");
                }

                return callFuture->waitFor(timeoutInMilliseconds) ? future_status::ready : future_status::timeout;
            }

            void wait() const {
                wait_for(INT64_MAX);
            }

            bool valid() const {
                return callFuture.get() != NULL;
            }

        private:
            mutable std::auto_ptr<connection::CallFuture> callFuture;
            serialization::pimpl::SerializationService &serializationService;
            Decoder decoderFunction;
        };
    }
}

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

#endif /* HAZELCAST_CLIENT_FUTURE_H_ */