hazelcast_client.h

/*
 * Copyright (c) 2008-2022, 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();
 
    sql::sql_service& get_sql();
 
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();
 
} // namespace client
} // namespace hazelcast
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif