primitive.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 "big_decimal.h"
#include "big_integer.h"
#include "ignite_date.h"
#include "ignite_date_time.h"
#include "ignite_duration.h"
#include "ignite_error.h"
#include "ignite_period.h"
#include "ignite_time.h"
#include "ignite_timestamp.h"
#include "ignite_type.h"
#include "uuid.h"
 
#include <cstdint>
#include <optional>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace ignite {

class primitive {
public:
    // Default
    primitive() = default;

    primitive(std::nullptr_t) {} // NOLINT(google-explicit-constructor)

    primitive(std::nullopt_t) {} // NOLINT(google-explicit-constructor)

    primitive(bool value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(std::int8_t value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(std::int16_t value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(std::int32_t value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(std::int64_t value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(float value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(double value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(uuid value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(std::string value) // NOLINT(google-explicit-constructor)
        : m_value(std::move(value)) {}

    primitive(std::string_view value) // NOLINT(google-explicit-constructor)
        : m_value(std::string(value)) {}

    primitive(const char *value) // NOLINT(google-explicit-constructor)
        : m_value(std::string(value)) {}

    primitive(std::vector<std::byte> value) // NOLINT(google-explicit-constructor)
        : m_value(std::move(value)) {}

    primitive(std::byte *buf, std::size_t len)
        : m_value(std::vector<std::byte>(buf, buf + len)) {}

    primitive(big_decimal value) // NOLINT(google-explicit-constructor)
        : m_value(std::move(value)) {}

    primitive(ignite_date value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(ignite_date_time value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(ignite_time value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(ignite_timestamp value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(ignite_period value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    primitive(ignite_duration value) // NOLINT(google-explicit-constructor)
        : m_value(value) {}

    template<typename T>
    [[nodiscard]] const T &get() const {
        if constexpr (std::is_same_v<T, bool> // Bool
            || std::is_same_v<T, std::int8_t> // Int8
            || std::is_same_v<T, std::int16_t> // Int16
            || std::is_same_v<T, std::int32_t> // Int32
            || std::is_same_v<T, std::int64_t> // Int64
            || std::is_same_v<T, float> // Float
            || std::is_same_v<T, double> // Double
            || std::is_same_v<T, uuid> // Uuid
            || std::is_same_v<T, std::string> // String
            || std::is_same_v<T, std::vector<std::byte>> // Bytes
            || std::is_same_v<T, big_decimal> // Decimal
            || std::is_same_v<T, ignite_date> // Date
            || std::is_same_v<T, ignite_date_time> // DateTime
            || std::is_same_v<T, ignite_time> // Time
            || std::is_same_v<T, ignite_timestamp> // Timestamp
            || std::is_same_v<T, ignite_period> // Period
            || std::is_same_v<T, ignite_duration> // Duration
        ) {
            return std::get<T>(m_value);
        } else {
            static_assert(sizeof(T) == 0, "Type is not an Ignite primitive type or is not yet supported");
        }
    }

    [[nodiscard]] bool is_null() const noexcept { return m_value.index() == 0; }

    [[nodiscard]] ignite_type get_type() const noexcept {
        auto type_idx = m_value.index();
        type_idx = type_idx <= 13 ? type_idx : type_idx + 1;
        return static_cast<ignite_type>(type_idx);
    }

    friend constexpr bool operator==(const primitive &lhs, const primitive &rhs) noexcept {
        return lhs.m_value == rhs.m_value;
    }

    friend constexpr bool operator!=(const primitive &lhs, const primitive &rhs) noexcept {
        return lhs.m_value != rhs.m_value;
    }
 
private:
    typedef std::variant<std::nullptr_t, // Null = 0
        bool, // Bool = 1
        std::int8_t, // Int8 = 2
        std::int16_t, // Int16 = 3
        std::int32_t, // Int32 = 4
        std::int64_t, // Int64 = 5
        float, // Float = 6
        double, // Double = 7
        big_decimal, // Decimal = 8
        ignite_date, // Date = 9
        ignite_time, // Time = 10
        ignite_date_time, // Datetime = 11
        ignite_timestamp, // Timestamp = 12
        uuid, // UUID = 13
        std::string, // String = 15
        std::vector<std::byte>, // Bytes = 16
        ignite_period, // Period = 17
        ignite_duration // Duration = 18
        >
        value_type;

    value_type m_value;
};
 
} // namespace ignite