product_type.hpp

/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * Copyright (C) 2026 Marco Craveiro <marco.craveiro@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 3 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */
#ifndef ORES_TRADING_DOMAIN_PRODUCT_TYPE_HPP
#define ORES_TRADING_DOMAIN_PRODUCT_TYPE_HPP
 
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <stdexcept>
#include <rfl.hpp>
 
namespace ores::trading::domain {
 
enum class product_type : std::uint8_t {
    unknown = 0,
    swap,
    fx,
    bond,
    credit,
    equity,
    commodity,
    composite,
    scripted
};
 
[[nodiscard]] inline std::string_view to_string(product_type pt) {
    switch (pt) {
    case product_type::unknown:   return "";
    case product_type::swap:      return "swap";
    case product_type::fx:        return "fx";
    case product_type::bond:      return "bond";
    case product_type::credit:    return "credit";
    case product_type::equity:    return "equity";
    case product_type::commodity: return "commodity";
    case product_type::composite: return "composite";
    case product_type::scripted:  return "scripted";
    }
    throw std::invalid_argument("Out-of-range product_type");
}
 
[[nodiscard]] inline std::optional<product_type>
product_type_from_string(std::string_view sv) {
    if (sv.empty())        return product_type::unknown;
    if (sv == "swap")      return product_type::swap;
    if (sv == "fx")        return product_type::fx;
    if (sv == "bond")      return product_type::bond;
    if (sv == "credit")    return product_type::credit;
    if (sv == "equity")    return product_type::equity;
    if (sv == "commodity") return product_type::commodity;
    if (sv == "composite") return product_type::composite;
    if (sv == "scripted")  return product_type::scripted;
    return std::nullopt;
}
 
}
 
namespace rfl {
 
template<>
struct Reflector<ores::trading::domain::product_type> {
    using ReflType = std::string;
 
    static ores::trading::domain::product_type to(const ReflType& s) {
        auto parsed = ores::trading::domain::product_type_from_string(s);
        if (!parsed) {
            throw std::invalid_argument("Invalid product_type: '" + s + "'");
        }
        return *parsed;
    }
 
    static ReflType from(const ores::trading::domain::product_type& v) {
        return std::string(ores::trading::domain::to_string(v));
    }
};
 
}
 
#endif