key_value_view.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 "ignite/client/detail/type_mapping_utils.h"
#include "ignite/client/table/ignite_tuple.h"
#include "ignite/client/transaction/transaction.h"
#include "ignite/client/type_mapping.h"
 
#include "ignite/common/detail/config.h"
#include "ignite/common/ignite_result.h"
 
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace ignite {
 
class table;
 
namespace detail {
class table_impl;
}
 
template<typename K, typename V>
class key_value_view;

template<>
class key_value_view<ignite_tuple, ignite_tuple> {
    friend class table;
 
public:
    typedef ignite_tuple key_type;
    typedef ignite_tuple value_type;
 
    // Deleted
    key_value_view(const key_value_view &) = delete;
    key_value_view &operator=(const key_value_view &) = delete;
 
    // Default
    key_value_view() = default;
    key_value_view(key_value_view &&) noexcept = default;
    key_value_view &operator=(key_value_view &&) noexcept = default;

    IGNITE_API void get_async(
        transaction *tx, const key_type &key, ignite_callback<std::optional<value_type>> callback);

    [[nodiscard]] IGNITE_API std::optional<value_type> get(transaction *tx, const key_type &key) {
        return sync<std::optional<value_type>>(
            [this, tx, &key](auto callback) { get_async(tx, key, std::move(callback)); });
    }

    IGNITE_API void get_all_async(
        transaction *tx, std::vector<key_type> keys, ignite_callback<std::vector<std::optional<value_type>>> callback);

    [[nodiscard]] IGNITE_API std::vector<std::optional<value_type>> get_all(
        transaction *tx, std::vector<key_type> keys) {
        return sync<std::vector<std::optional<value_type>>>([this, tx, keys = std::move(keys)](auto callback) mutable {
            get_all_async(tx, std::move(keys), std::move(callback));
        });
    }

    IGNITE_API void contains_async(transaction *tx, const key_type &key, ignite_callback<bool> callback);

    [[nodiscard]] IGNITE_API bool contains(transaction *tx, const key_type &key) {
        return sync<bool>([this, tx, &key](auto callback) { contains_async(tx, key, std::move(callback)); });
    }

    IGNITE_API void put_async(
        transaction *tx, const key_type &key, const value_type &value, ignite_callback<void> callback);

    IGNITE_API void put(transaction *tx, const key_type &key, const value_type &value) {
        sync<void>([this, tx, &key, &value](auto callback) { put_async(tx, key, value, std::move(callback)); });
    }

    IGNITE_API void put_all_async(
        transaction *tx, const std::vector<std::pair<key_type, value_type>> &pairs, ignite_callback<void> callback);

    IGNITE_API void put_all(transaction *tx, const std::vector<std::pair<key_type, value_type>> &pairs) {
        sync<void>([this, tx, pairs](auto callback) mutable { put_all_async(tx, pairs, std::move(callback)); });
    }

    IGNITE_API void get_and_put_async(transaction *tx, const key_type &key, const value_type &value,
        ignite_callback<std::optional<value_type>> callback);

    [[nodiscard]] IGNITE_API std::optional<value_type> get_and_put(
        transaction *tx, const key_type &key, const value_type &value) {
        return sync<std::optional<value_type>>(
            [this, tx, &key, &value](auto callback) { get_and_put_async(tx, key, value, std::move(callback)); });
    }

    IGNITE_API void put_if_absent_async(
        transaction *tx, const key_type &key, const value_type &value, ignite_callback<bool> callback);

    IGNITE_API bool put_if_absent(transaction *tx, const key_type &key, const value_type &value) {
        return sync<bool>(
            [this, tx, &key, &value](auto callback) { put_if_absent_async(tx, key, value, std::move(callback)); });
    }

    IGNITE_API void remove_async(transaction *tx, const key_type &key, ignite_callback<bool> callback);

    IGNITE_API bool remove(transaction *tx, const key_type &key) {
        return sync<bool>([this, tx, &key](auto callback) { remove_async(tx, key, std::move(callback)); });
    }

    IGNITE_API void remove_async(
        transaction *tx, const key_type &key, const value_type &value, ignite_callback<bool> callback);

    IGNITE_API bool remove(transaction *tx, const key_type &key, const value_type &value) {
        return sync<bool>(
            [this, tx, &key, &value](auto callback) { remove_async(tx, key, value, std::move(callback)); });
    }

    IGNITE_API void remove_all_async(
        transaction *tx, std::vector<key_type> keys, ignite_callback<std::vector<key_type>> callback);

    IGNITE_API std::vector<key_type> remove_all(transaction *tx, std::vector<key_type> keys) {
        return sync<std::vector<key_type>>([this, tx, keys = std::move(keys)](auto callback) mutable {
            remove_all_async(tx, std::move(keys), std::move(callback));
        });
    }

    IGNITE_API void remove_all_async(transaction *tx, const std::vector<std::pair<key_type, value_type>> &pairs,
        ignite_callback<std::vector<key_type>> callback);

    IGNITE_API std::vector<key_type> remove_all(transaction *tx, std::vector<std::pair<key_type, value_type>> pairs) {
        return sync<std::vector<key_type>>([this, tx, pairs = std::move(pairs)](auto callback) mutable {
            remove_all_async(tx, std::move(pairs), std::move(callback));
        });
    }

    IGNITE_API void get_and_remove_async(
        transaction *tx, const key_type &key, ignite_callback<std::optional<value_type>> callback);

    IGNITE_API std::optional<value_type> get_and_remove(transaction *tx, const key_type &key) {
        return sync<std::optional<value_type>>(
            [this, tx, &key](auto callback) { get_and_remove_async(tx, key, std::move(callback)); });
    }

    IGNITE_API void replace_async(
        transaction *tx, const key_type &key, const value_type &value, ignite_callback<bool> callback);

    IGNITE_API bool replace(transaction *tx, const key_type &key, const value_type &value) {
        return sync<bool>(
            [this, tx, &key, &value](auto callback) { replace_async(tx, key, value, std::move(callback)); });
    }

    IGNITE_API void replace_async(transaction *tx, const key_type &key, const value_type &old_value,
        const value_type &new_value, ignite_callback<bool> callback);

    IGNITE_API bool replace(
        transaction *tx, const key_type &key, const value_type &old_value, const value_type &new_value) {
        return sync<bool>([this, tx, &key, &old_value, &new_value](
                              auto callback) { replace_async(tx, key, old_value, new_value, std::move(callback)); });
    }

    IGNITE_API void get_and_replace_async(transaction *tx, const key_type &key, const value_type &value,
        ignite_callback<std::optional<value_type>> callback);

    [[nodiscard]] IGNITE_API std::optional<value_type> get_and_replace(
        transaction *tx, const key_type &key, const value_type &value) {
        return sync<std::optional<value_type>>(
            [this, tx, &key, &value](auto callback) { get_and_replace_async(tx, key, value, std::move(callback)); });
    }
 
private:
    explicit key_value_view(std::shared_ptr<detail::table_impl> impl)
        : m_impl(std::move(impl)) {}

    std::shared_ptr<detail::table_impl> m_impl;
};

template<typename K, typename V>
class key_value_view {
    friend class table;
 
public:
    typedef typename std::decay<K>::type key_type;
    typedef typename std::decay<V>::type value_type;
 
    // Deleted
    key_value_view(const key_value_view &) = delete;
    key_value_view &operator=(const key_value_view &) = delete;
 
    // Default
    key_value_view() = default;
    key_value_view(key_value_view &&) noexcept = default;
    key_value_view &operator=(key_value_view &&) noexcept = default;

    void get_async(transaction *tx, const key_type &key, ignite_callback<std::optional<value_type>> callback) {
        m_delegate.get_async(tx, convert_to_tuple(key),
            [callback = std::move(callback)](auto res) { callback(convert_result<value_type>(std::move(res))); });
    }

    [[nodiscard]] std::optional<value_type> get(transaction *tx, const key_type &key) {
        return sync<std::optional<value_type>>(
            [this, tx, &key](auto callback) { get_async(tx, key, std::move(callback)); });
    }

    void get_all_async(
        transaction *tx, std::vector<key_type> keys, ignite_callback<std::vector<std::optional<value_type>>> callback) {
        m_delegate.get_all_async(tx, values_to_tuples<key_type>(std::move(keys)),
            [callback = std::move(callback)](auto res) { callback(convert_result<value_type>(std::move(res))); });
    }

    [[nodiscard]] std::vector<std::optional<value_type>> get_all(transaction *tx, std::vector<key_type> keys) {
        return sync<std::vector<std::optional<value_type>>>([this, tx, keys = std::move(keys)](auto callback) mutable {
            get_all_async(tx, std::move(keys), std::move(callback));
        });
    }

    void contains_async(transaction *tx, const key_type &key, ignite_callback<bool> callback) {
        m_delegate.contains_async(tx, convert_to_tuple(key), std::move(callback));
    }

    [[nodiscard]] bool contains(transaction *tx, const key_type &key) {
        return sync<bool>([this, tx, &key](auto callback) { contains_async(tx, key, std::move(callback)); });
    }

    void put_async(transaction *tx, const key_type &key, const value_type &value, ignite_callback<void> callback) {
        m_delegate.put_async(tx, convert_to_tuple(key), convert_to_tuple(value), std::move(callback));
    }

    void put(transaction *tx, const key_type &key, const value_type &value) {
        sync<void>([this, tx, &key, &value](auto callback) { put_async(tx, key, value, std::move(callback)); });
    }

    void put_all_async(
        transaction *tx, const std::vector<std::pair<key_type, value_type>> &pairs, ignite_callback<void> callback) {
        m_delegate.put_all_async(tx, values_to_tuples<key_type, value_type>(std::move(pairs)), std::move(callback));
    }

    void put_all(transaction *tx, const std::vector<std::pair<key_type, value_type>> &pairs) {
        sync<void>([this, tx, pairs](auto callback) mutable { put_all_async(tx, pairs, std::move(callback)); });
    }

    void get_and_put_async(transaction *tx, const key_type &key, const value_type &value,
        ignite_callback<std::optional<value_type>> callback) {
        m_delegate.get_and_put_async(tx, convert_to_tuple(key), convert_to_tuple(value),
            [callback = std::move(callback)](auto res) { callback(convert_result<value_type>(std::move(res))); });
    }

    [[nodiscard]] std::optional<value_type> get_and_put(transaction *tx, const key_type &key, const value_type &value) {
        return sync<std::optional<value_type>>(
            [this, tx, &key, &value](auto callback) { get_and_put_async(tx, key, value, std::move(callback)); });
    }

    void put_if_absent_async(
        transaction *tx, const key_type &key, const value_type &value, ignite_callback<bool> callback) {
        m_delegate.put_if_absent_async(tx, convert_to_tuple(key), convert_to_tuple(value), std::move(callback));
    }

    bool put_if_absent(transaction *tx, const key_type &key, const value_type &value) {
        return sync<bool>(
            [this, tx, &key, &value](auto callback) { put_if_absent_async(tx, key, value, std::move(callback)); });
    }

    void remove_async(transaction *tx, const key_type &key, ignite_callback<bool> callback) {
        m_delegate.remove_async(tx, convert_to_tuple(key), std::move(callback));
    }

    bool remove(transaction *tx, const key_type &key) {
        return sync<bool>([this, tx, &key](auto callback) { remove_async(tx, key, std::move(callback)); });
    }

    void remove_async(transaction *tx, const key_type &key, const value_type &value, ignite_callback<bool> callback) {
        m_delegate.remove_async(tx, convert_to_tuple(key), convert_to_tuple(value), std::move(callback));
    }

    bool remove(transaction *tx, const key_type &key, const value_type &value) {
        return sync<bool>(
            [this, tx, &key, &value](auto callback) { remove_async(tx, key, value, std::move(callback)); });
    }

    void remove_all_async(
        transaction *tx, std::vector<key_type> keys, ignite_callback<std::vector<key_type>> callback) {
        m_delegate.remove_all_async(tx, values_to_tuples<key_type>(std::move(keys)),
            [callback = std::move(callback)](auto res) { callback(convert_result<key_type>(std::move(res))); });
    }

    std::vector<key_type> remove_all(transaction *tx, std::vector<key_type> keys) {
        return sync<std::vector<key_type>>([this, tx, keys = std::move(keys)](auto callback) mutable {
            remove_all_async(tx, std::move(keys), std::move(callback));
        });
    }

    void remove_all_async(transaction *tx, const std::vector<std::pair<key_type, value_type>> &pairs,
        ignite_callback<std::vector<key_type>> callback) {
        m_delegate.remove_all_async(tx, values_to_tuples<key_type, value_type>(std::move(pairs)),
            [callback = std::move(callback)](auto res) { callback(convert_result<key_type>(std::move(res))); });
    }

    std::vector<key_type> remove_all(transaction *tx, std::vector<std::pair<key_type, value_type>> pairs) {
        return sync<std::vector<key_type>>([this, tx, pairs = std::move(pairs)](auto callback) mutable {
            remove_all_async(tx, std::move(pairs), std::move(callback));
        });
    }

    void get_and_remove_async(
        transaction *tx, const key_type &key, ignite_callback<std::optional<value_type>> callback) {
        m_delegate.get_and_remove_async(tx, convert_to_tuple(key),
            [callback = std::move(callback)](auto res) { callback(convert_result<value_type>(std::move(res))); });
    }

    std::optional<value_type> get_and_remove(transaction *tx, const key_type &key) {
        return sync<std::optional<value_type>>(
            [this, tx, &key](auto callback) { get_and_remove_async(tx, key, std::move(callback)); });
    }

    void replace_async(transaction *tx, const key_type &key, const value_type &value, ignite_callback<bool> callback) {
        m_delegate.replace_async(tx, convert_to_tuple(key), convert_to_tuple(value), std::move(callback));
    }

    bool replace(transaction *tx, const key_type &key, const value_type &value) {
        return sync<bool>(
            [this, tx, &key, &value](auto callback) { replace_async(tx, key, value, std::move(callback)); });
    }

    void replace_async(transaction *tx, const key_type &key, const value_type &old_value, const value_type &new_value,
        ignite_callback<bool> callback) {
        m_delegate.replace_async(
            tx, convert_to_tuple(key), convert_to_tuple(old_value), convert_to_tuple(new_value), std::move(callback));
    }

    bool replace(transaction *tx, const key_type &key, const value_type &old_value, const value_type &new_value) {
        return sync<bool>([this, tx, &key, &old_value, &new_value](
                              auto callback) { replace_async(tx, key, old_value, new_value, std::move(callback)); });
    }

    void get_and_replace_async(transaction *tx, const key_type &key, const value_type &value,
        ignite_callback<std::optional<value_type>> callback) {
        m_delegate.get_and_replace_async(tx, convert_to_tuple(key), convert_to_tuple(value),
            [callback = std::move(callback)](auto res) { callback(convert_result<value_type>(std::move(res))); });
    }

    [[nodiscard]] std::optional<value_type> get_and_replace(
        transaction *tx, const key_type &key, const value_type &value) {
        return sync<std::optional<value_type>>(
            [this, tx, &key, &value](auto callback) { get_and_replace_async(tx, key, value, std::move(callback)); });
    }
 
private:
    explicit key_value_view(key_value_view<ignite_tuple, ignite_tuple> delegate)
        : m_delegate(std::move(delegate)) {}

    key_value_view<ignite_tuple, ignite_tuple> m_delegate;
};
 
} // namespace ignite