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 client_impl_->get_distributed_object<reliable_topic>(name);
            }
 
            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