Hazelcast C++ Client

#include <hazelcast/client/hazelcast.h>

  using namespace hazelcast::client;
  int main() {
      // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
      hazelcast_client hz;
      // Get a Blocking Queue called "my-distributed-queue"
      auto queue = hz.get_queue("my-distributed-queue").get();
      // Offer a String into the Distributed Queue
      queue->offer("item").get();
      // Poll the Distributed Queue and return the String
      auto item = queue->poll().get();
      //Timed blocking Operations
      queue->offer("anotheritem", std::chrono::milliseconds(500)).get();
      auto anotherItem = queue->poll(std::chrono::seconds(5)).get();
      //Indefinitely blocking Operations
      queue->put("yetanotheritem");
      std::cout <take().get() << std::endl;
      // Shutdown this Hazelcast Client
      hz.shutdown();
  
      return 0;
  }

#include <hazelcast/client/hazelcast.h>

using namespace hazelcast::client;

int main() {
    // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
    hazelcast_client hz;
    // Get a Topic called "my-distributed-topic"
    auto topic = hz.get_topic("my-distributed-topic").get();
    // Add a Listener to the Topic
    topic->add_message_listener(
        topic::listener().
            on_received([](topic::message &&message) {
                std::cout << "Got message " << message.get_message_object().get().value_or("null") <publish("Hello to distributed world").get();
    // Shutdown this Hazelcast Client
    hz.shutdown();

    return 0;
}

#include <hazelcast/client/hazelcast.h>

using namespace hazelcast::client;
int main() {
    // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
    hazelcast_client hz;
    // Get the Distributed List from Cluster.
    auto list = hz.get_list("my-distributed-list").get();
    // Add elements to the list
    list->add("item1").get();
    // Using future continuation here so that the calls are not blocking
    auto f = list->add("item2").then(boost::launch::deferred, [=] (boost::future f) {
       if (!f.get()) {
           std::cerr << "Element 2 could not be added !!!\n";
           return;
       }

        std::cout << std::boolalpha;
        // Remove the first element
        std::cout << "Removed: " <remove(0).get();
        // There is only one element left
        std::cout << "Current size is " <size().get() <clear().get();
    });

    // make the deferred future execute
    f.get();

    // Shutdown this Hazelcast Client
    hz.shutdown();

    return 0;
}

#include <hazelcast/client/hazelcast.h>

using namespace hazelcast::client;
int main() {
    // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
    hazelcast_client hz;
    // Get a Replicated Map called "my-replicated-map"
    auto map = hz.get_replicated_map("my-replicated-map").get();
    // Add items to the set with duplicates
    // Put and Get a value from the Replicated Map
    auto replacedValue = map->put("key", "value").get();
    // key/value replicated to all members
    std::cout << "replacedValue = " <get("key").get();
    // the value is retrieved from a random member in the cluster
    std::cout << "value for key = " << value.value_or("null");
    // Shutdown this Hazelcast Client
    hz.shutdown();

    return 0;
}

#include <hazelcast/client/hazelcast.h>

using namespace hazelcast::client;
int main() {
    // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
    hazelcast_client hz;
    // Get the Distributed Set from Cluster.
    auto set = hz.get_set("my-distributed-set").get();
    // Add items to the set with duplicates
    set->add("item1").get();
    set->add("item1").get();
    set->add("item2").get();
    set->add("item2").get();
    set->add("item2").get();
    set->add("item3").get();
    // Get the items. Note that there are no duplicates.
    auto future = set->to_array().then(boost::launch::deferred, [] (boost::future<std::vector> f) {
        for(auto &v : f.get()) {
            std::cout << v << '\n';
        }
    });

    // do something else
    //...
    // print the output
    future.get();

    // Shutdown this Hazelcast Client
    hz.shutdown();

    return 0;
}

#include <hazelcast/client/hazelcast.h>

using namespace hazelcast::client;
int main() {
    // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
    hazelcast_client hz;
    // Get the Distributed MultiMap from Cluster.
    auto multiMap = hz.get_multi_map("my-distributed-multimap").get();
    // Put values in the map against the same key
    multiMap->put("my-key", "value1").get();
    multiMap->put("my-key", "value2").get();
    multiMap->put("my-key", "value3").get();
    // Print out all the values for associated with key called "my-key"
    multiMap->get("my-key").then(boost::launch::deferred,[] (boost::future<std::vector> f) {
        for (auto &value : f.get()) {
            std::cout << value <remove("my-key", "value2").get();    // Shutdown this Hazelcast Client
    hz.shutdown();

    return 0;
}

#include <hazelcast/client/hazelcast.h>

using namespace hazelcast::client;
int main() {
    // Start the Hazelcast Client and connect to an already running Hazelcast Cluster on 127.0.0.1
    hazelcast_client hz;
    auto rb = hz.get_ringbuffer("rb").get();
    // add two items into ring buffer
    rb->add(100).get();
    rb->add(200).get();
    // we start from the oldest item.
    // if you want to start from the next item, call rb.tailSequence()+1
    int64_t sequence = rb->head_sequence().get();
    std::cout <read_one(sequence).get() << std::endl;
    sequence++;
    std::cout <read_one(sequence).get() << std::endl;
    // Shutdown this Hazelcast Client
    hz.shutdown();
}