transaction_context.h

/*
 * Copyright (c) 2008-2025, 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 "hazelcast/client/iqueue.h"
#include "hazelcast/client/imap.h"
#include "hazelcast/client/ilist.h"
#include "hazelcast/client/iset.h"
#include "hazelcast/client/multi_map.h"
#include "hazelcast/client/transaction_options.h"
#include "hazelcast/client/txn/TransactionProxy.h"
#include "hazelcast/client/transactional_map.h"
#include "hazelcast/client/exception/protocol_exceptions.h"
#include "hazelcast/client/transactional_queue.h"
#include "hazelcast/client/transactional_multi_map.h"
#include "hazelcast/client/transactional_list.h"
#include "hazelcast/client/transactional_set.h"
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable : 4251) // for dll export
#endif
 
namespace std {
template<>
class HAZELCAST_API hash<std::pair<std::string, std::string>>
{
public:
    std::size_t operator()(
      const std::pair<std::string, std::string>& val) const noexcept;
};
} // namespace std
 
namespace hazelcast {
namespace client {
namespace spi {
namespace impl {
class ClientTransactionManagerServiceImpl;
} // namespace impl
} // namespace spi
 
namespace connection {
class ClientConnectionManagerImpl;
 
class Connection;
} // namespace connection

class HAZELCAST_API transaction_context
{
public:
    transaction_context(
      spi::impl::ClientTransactionManagerServiceImpl& transaction_manager,
      const transaction_options&);

    boost::uuids::uuid get_txn_id() const;

    boost::future<void> begin_transaction();

    boost::future<void> commit_transaction();

    boost::future<void> rollback_transaction();

    std::shared_ptr<transactional_map> get_map(const std::string& name)
    {
        return get_transactional_object<transactional_map>(imap::SERVICE_NAME,
                                                           name);
    }

    std::shared_ptr<transactional_queue> get_queue(const std::string& name)
    {
        return get_transactional_object<transactional_queue>(
          iqueue::SERVICE_NAME, name);
    }

    std::shared_ptr<transactional_multi_map> get_multi_map(
      const std::string& name)
    {
        return get_transactional_object<transactional_multi_map>(
          multi_map::SERVICE_NAME, name);
    }

    std::shared_ptr<transactional_list> get_list(const std::string& name)
    {
        return get_transactional_object<transactional_list>(ilist::SERVICE_NAME,
                                                            name);
    }

    std::shared_ptr<transactional_set> get_set(const std::string& name)
    {
        return get_transactional_object<transactional_set>(iset::SERVICE_NAME,
                                                           name);
    }

    template<typename T>
    std::shared_ptr<T> get_transactional_object(const std::string& service_name,
                                                const std::string& name)
    {
        if (transaction_.get_state() != txn::TxnState::ACTIVE) {
            std::string message = "No transaction is found while accessing ";
            message += "transactional object -> [" + name + "]!";
            BOOST_THROW_EXCEPTION(exception::illegal_state(
              "TransactionContext::getMap(const std::string& name)", message));
        }
        auto key = std::make_pair(service_name, name);
        std::shared_ptr<T> obj =
          std::static_pointer_cast<T>(txn_object_map_.get(key));
        if (!obj) {
            obj = std::shared_ptr<T>(new T(name, transaction_));
            txn_object_map_.put(key, obj);
        }
 
        return obj;
    }
 
private:
    transaction_options options_;
    std::shared_ptr<connection::Connection> txn_connection_;
    txn::TransactionProxy transaction_;
    util::SynchronizedMap<std::pair<std::string, std::string>,
                          proxy::TransactionalObject>
      txn_object_map_;
};
} // namespace client
} // namespace hazelcast
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif