hazelcast_client.h

/*
 * Copyright (c) 2008-2021, 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.
 */
#pragma once

#include <boost/utility/string_view.hpp>

#include "hazelcast/client/impl/hazelcast_client_instance_impl.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_client;
    }

    boost::future<client::hazelcast_client> HAZELCAST_API new_client();

    boost::future<client::hazelcast_client> HAZELCAST_API new_client(client::client_config config);

    namespace client {
        /*
         * You can use native C++ Client to connect to hazelcast nodes and make almost all operations that a node does.
         * Different from nodes, clients do not hold data.
         *
         * Some of features of C++ Clients are:
         * * Access to distributed data structures like IMap, IQueue, MultiMap, ITopic etc... For complete list see the classes
         * extending DistributedObject
         * * Access to transactional distributed data structures like TransactionalMap, TransactionalQueue etc...
         * * Ability to add cluster listeners to a cluster and entry/item listeners to distributed data structures.
         * @see MembershipListener, IMap#add_entry_listener , IQueue#add_item_listener etc .
         * * C++ Client is smart by default, which means that it knows where the data is and asks directly to correct node.
         * Note that you can turn this feature off ( client_config#setSmart), if you don't want your clients to connect every
         * node.
         *
         * Our C++ client is completely open source and the source code is freely available at https://github.com/hazelcast/hazelcast-cpp-client .
         * Please feel free to contribute. You can join our community at https://groups.google.com/forum/#!forum/hazelcast where
         * you can find answers to your questions.
         */
        class HAZELCAST_API hazelcast_client {
            friend class spi::ClientContext;

        public:
            friend boost::future<hazelcast_client> hazelcast::new_client();

            friend boost::future<hazelcast_client> hazelcast::new_client(hazelcast::client::client_config config);

            virtual ~hazelcast_client();

            const std::string &get_name() const;

            template<typename T>
            boost::shared_future<std::shared_ptr<T>> get_distributed_object(const std::string& name) {
                return client_impl_->get_distributed_object<T>(name);
            }

            boost::shared_future<std::shared_ptr<imap>> get_map(const std::string &name) {
                return client_impl_->get_distributed_object<imap>(name);
            }

            boost::shared_future<std::shared_ptr<multi_map>> get_multi_map(const std::string& name) {
                return client_impl_->get_distributed_object<multi_map>(name);
            }

            boost::shared_future<std::shared_ptr<replicated_map>> get_replicated_map(const std::string &name) {
                return client_impl_->get_distributed_object<replicated_map>(name);
            }

            boost::shared_future<std::shared_ptr<iqueue>> get_queue(const std::string& name) {
                return client_impl_->get_distributed_object<iqueue>(name);
            }

            boost::shared_future<std::shared_ptr<iset>> get_set(const std::string& name) {
                return client_impl_->get_distributed_object<iset>(name);
            }

            boost::shared_future<std::shared_ptr<ilist>> get_list(const std::string& name) {
                return client_impl_->get_distributed_object<ilist>(name);
            }

            boost::shared_future<std::shared_ptr<itopic>> get_topic(const std::string& name) {
                return client_impl_->get_distributed_object<itopic>(name);
            };

            boost::shared_future<std::shared_ptr<reliable_topic>> get_reliable_topic(const std::string &name) {
                return get_distributed_object<ringbuffer>(std::string(reliable_topic::TOPIC_RB_PREFIX) + name).then(
                        boost::launch::sync, [=](boost::shared_future<std::shared_ptr<ringbuffer>> f) {
                            auto rb = f.get();
                            return std::shared_ptr<reliable_topic>(new reliable_topic(rb, name, &rb->get_context()));
                        });
            }

            boost::shared_future<std::shared_ptr<flake_id_generator>> get_flake_id_generator(const std::string& name) {
                return client_impl_->get_distributed_object<flake_id_generator>(name);
            }

            boost::shared_future<std::shared_ptr<pn_counter>> get_pn_counter(const std::string& name) {
                return client_impl_->get_distributed_object<pn_counter>(name);
            }

            boost::shared_future<std::shared_ptr<ringbuffer>> get_ringbuffer(const std::string& name) {
                return client_impl_->get_distributed_object<ringbuffer>(name);
            }

            boost::shared_future<std::shared_ptr<iexecutor_service>> get_executor_service(const std::string &name) {
                return client_impl_->get_distributed_object<iexecutor_service>(name);
            }

            client_config& get_client_config();

            transaction_context new_transaction_context();

            transaction_context new_transaction_context(const transaction_options& options);

            cluster& get_cluster();

            local_endpoint get_local_endpoint() const;

            boost::uuids::uuid add_lifecycle_listener(lifecycle_listener &&lifecycle_listener);

            bool remove_lifecycle_listener(const boost::uuids::uuid &registration_id);

            boost::future<void> shutdown();

            spi::lifecycle_service &get_lifecycle_service();

            cp::cp_subsystem &get_cp_subsystem();

        private:
            hazelcast_client();

            explicit hazelcast_client(client_config config);

            std::shared_ptr<impl::hazelcast_client_instance_impl> client_impl_;
        };

        const boost::string_view HAZELCAST_API version();

    }
}

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