record_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 T>
class record_view;

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

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

    [[nodiscard]] IGNITE_API std::optional<value_type> get(transaction *tx, const value_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<value_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<value_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 upsert_async(transaction *tx, const value_type &record, ignite_callback<void> callback);

    IGNITE_API void upsert(transaction *tx, const value_type &record) {
        sync<void>([this, tx, &record](auto callback) { upsert_async(tx, record, std::move(callback)); });
    }

    IGNITE_API void upsert_all_async(transaction *tx, std::vector<value_type> records, ignite_callback<void> callback);

    IGNITE_API void upsert_all(transaction *tx, std::vector<value_type> records) {
        sync<void>([this, tx, records = std::move(records)](
                       auto callback) mutable { upsert_all_async(tx, std::move(records), std::move(callback)); });
    }

    IGNITE_API void get_and_upsert_async(
        transaction *tx, const value_type &record, ignite_callback<std::optional<value_type>> callback);

    [[nodiscard]] IGNITE_API std::optional<value_type> get_and_upsert(transaction *tx, const value_type &record) {
        return sync<std::optional<value_type>>(
            [this, tx, &record](auto callback) { get_and_upsert_async(tx, record, std::move(callback)); });
    }

    IGNITE_API void insert_async(transaction *tx, const value_type &record, ignite_callback<bool> callback);

    IGNITE_API bool insert(transaction *tx, const value_type &record) {
        return sync<bool>([this, tx, &record](auto callback) { insert_async(tx, record, std::move(callback)); });
    }

    IGNITE_API void insert_all_async(
        transaction *tx, std::vector<value_type> records, ignite_callback<std::vector<value_type>> callback);

    IGNITE_API std::vector<value_type> insert_all(transaction *tx, std::vector<value_type> records) {
        return sync<std::vector<value_type>>([this, tx, records = std::move(records)](auto callback) mutable {
            insert_all_async(tx, std::move(records), std::move(callback));
        });
    }

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

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

    IGNITE_API void replace_async(
        transaction *tx, const value_type &record, const value_type &new_record, ignite_callback<bool> callback);

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

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

    [[nodiscard]] IGNITE_API std::optional<value_type> get_and_replace(transaction *tx, const value_type &record) {
        return sync<std::optional<value_type>>(
            [this, tx, &record](auto callback) { get_and_replace_async(tx, record, std::move(callback)); });
    }

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

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

    IGNITE_API void remove_exact_async(transaction *tx, const value_type &record, ignite_callback<bool> callback);

    IGNITE_API bool remove_exact(transaction *tx, const value_type &record) {
        return sync<bool>([this, tx, &record](auto callback) { remove_exact_async(tx, record, std::move(callback)); });
    }

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

    IGNITE_API std::optional<value_type> get_and_remove(transaction *tx, const value_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 remove_all_async(
        transaction *tx, std::vector<value_type> keys, ignite_callback<std::vector<value_type>> callback);

    IGNITE_API std::vector<value_type> remove_all(transaction *tx, std::vector<value_type> keys) {
        return sync<std::vector<value_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_exact_async(
        transaction *tx, std::vector<value_type> records, ignite_callback<std::vector<value_type>> callback);

    IGNITE_API std::vector<value_type> remove_all_exact(transaction *tx, std::vector<value_type> records) {
        return sync<std::vector<value_type>>([this, tx, records = std::move(records)](auto callback) mutable {
            remove_all_exact_async(tx, std::move(records), std::move(callback));
        });
    }
 
private:
    explicit record_view(std::shared_ptr<detail::table_impl> impl)
        : m_impl(std::move(impl)) {}

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

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

    void get_async(transaction *tx, const value_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 value_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<value_type> keys,
        ignite_callback<std::vector<std::optional<value_type>>> callback) {
        m_delegate.get_all_async(tx, values_to_tuples<value_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<value_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 upsert_async(transaction *tx, const value_type &record, ignite_callback<void> callback) {
        m_delegate.upsert_async(tx, convert_to_tuple(record), std::move(callback));
    }

    void upsert(transaction *tx, const value_type &record) {
        sync<void>([this, tx, &record](auto callback) { upsert_async(tx, record, std::move(callback)); });
    }

    void upsert_all_async(transaction *tx, std::vector<value_type> records, ignite_callback<void> callback) {
        m_delegate.upsert_all_async(tx, values_to_tuples<value_type>(std::move(records)), std::move(callback));
    }

    void upsert_all(transaction *tx, std::vector<value_type> records) {
        sync<void>([this, tx, records = std::move(records)](
                       auto callback) mutable { upsert_all_async(tx, std::move(records), std::move(callback)); });
    }

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

    [[nodiscard]] std::optional<value_type> get_and_upsert(transaction *tx, const value_type &record) {
        return sync<std::optional<value_type>>(
            [this, tx, &record](auto callback) { get_and_upsert_async(tx, record, std::move(callback)); });
    }

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

    bool insert(transaction *tx, const value_type &record) {
        return sync<bool>([this, tx, &record](auto callback) { insert_async(tx, record, std::move(callback)); });
    }

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

    std::vector<value_type> insert_all(transaction *tx, std::vector<value_type> records) {
        return sync<std::vector<value_type>>([this, tx, records = std::move(records)](auto callback) mutable {
            insert_all_async(tx, std::move(records), std::move(callback));
        });
    }

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

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

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

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

    void get_and_replace_async(
        transaction *tx, const value_type &record, ignite_callback<std::optional<value_type>> callback) {
        m_delegate.get_and_replace_async(tx, convert_to_tuple(record),
            [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 value_type &record) {
        return sync<std::optional<value_type>>(
            [this, tx, &record](auto callback) { get_and_replace_async(tx, record, std::move(callback)); });
    }

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

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

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

    bool remove_exact(transaction *tx, const value_type &record) {
        return sync<bool>([this, tx, &record](auto callback) { remove_exact_async(tx, record, std::move(callback)); });
    }

    void get_and_remove_async(
        transaction *tx, const value_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 value_type &key) {
        return sync<std::optional<value_type>>(
            [this, tx, &key](auto callback) { get_and_remove_async(tx, key, std::move(callback)); });
    }

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

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

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

    std::vector<value_type> remove_all_exact(transaction *tx, std::vector<value_type> records) {
        return sync<std::vector<value_type>>([this, tx, records = std::move(records)](auto callback) mutable {
            remove_all_exact_async(tx, std::move(records), std::move(callback));
        });
    }
 
private:
    explicit record_view(record_view<ignite_tuple> delegate)
        : m_delegate(std::move(delegate)) {}

    record_view<ignite_tuple> m_delegate;
};
 
} // namespace ignite