autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::ord @ref ord
namespace mim {
namespace plug::ord {
 
static constexpr plugin_t Plugin_Id = 0x4131400000000000;
 
/// @name `ord.Key`
///@{
enum class Key : flags_t {
};
 
/// The fields of `ord.Key`, by index.
struct Key_field { enum : nat_t { T = 0, lt = 1, }; };
 
///@}
 
/// @name `ord.Set`
///@{
enum class Set : flags_t {
};
 
///@}
 
/// @name `ord.Map`
///@{
enum class Map : flags_t {
};
 
///@}
 
/// @name `ord.init`
///@{
enum class init : flags_t {
    set = 0x4131400000000300,
    map = 0x4131400000000301,
};
 
template<init>
const Def* normalize_init(const Def*, const Def*, const Def*);
 
///@}
 
/// @name `ord.create_set`
///@{
enum class create_set : flags_t {
};
 
///@}
 
/// @name `ord.create_map`
///@{
enum class create_map : flags_t {
};
 
///@}
 
/// @name `ord.size`
///@{
enum class size : flags_t {
    set = 0x4131400000000600,
    map = 0x4131400000000601,
};
 
template<size>
const Def* normalize_size(const Def*, const Def*, const Def*);
 
///@}
 
/// @name `ord.is_empty_set`
///@{
enum class is_empty_set : flags_t {
};
 
///@}
 
/// @name `ord.is_empty_map`
///@{
enum class is_empty_map : flags_t {
};
 
///@}
 
/// @name `ord.get`
///@{
enum class get : flags_t {
};
 
const Def* normalize_get(const Def*, const Def*, const Def*);
///@}
 
/// @name `ord.contains`
///@{
enum class contains : flags_t {
    set = 0x4131400000000a00,
    map = 0x4131400000000a01,
};
 
template<contains>
const Def* normalize_contains(const Def*, const Def*, const Def*);
 
///@}
 
/// @name `ord.insert`
///@{
enum class insert : flags_t {
    set = 0x4131400000000b00,
    map = 0x4131400000000b01,
};
 
template<insert>
const Def* normalize_insert(const Def*, const Def*, const Def*);
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_ord_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(init::set)] = &normalize_init<init::set>; \
        normalizers[flags_t(init::map)] = &normalize_init<init::map>; \
        normalizers[flags_t(size::set)] = &normalize_size<size::set>; \
        normalizers[flags_t(size::map)] = &normalize_size<size::map>; \
        normalizers[flags_t(Annex::Base<get>)] = &normalize_get; \
        normalizers[flags_t(contains::set)] = &normalize_contains<contains::set>; \
        normalizers[flags_t(contains::map)] = &normalize_contains<contains::map>; \
        normalizers[flags_t(insert::set)] = &normalize_insert<insert::set>; \
        normalizers[flags_t(insert::map)] = &normalize_insert<insert::map>; \
    }
} // namespace plug::ord
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::ord::Key> = 0x4131400000000000;
template<> constexpr size_t Annex::Num<plug::ord::Key> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::Set> = 0x4131400000000100;
template<> constexpr size_t Annex::Num<plug::ord::Set> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::Map> = 0x4131400000000200;
template<> constexpr size_t Annex::Num<plug::ord::Map> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::init> = 0x4131400000000300;
template<> constexpr size_t Annex::Num<plug::ord::init> = 2;
template<> constexpr flags_t Annex::Base<plug::ord::create_set> = 0x4131400000000400;
template<> constexpr size_t Annex::Num<plug::ord::create_set> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::create_map> = 0x4131400000000500;
template<> constexpr size_t Annex::Num<plug::ord::create_map> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::size> = 0x4131400000000600;
template<> constexpr size_t Annex::Num<plug::ord::size> = 2;
template<> constexpr flags_t Annex::Base<plug::ord::is_empty_set> = 0x4131400000000700;
template<> constexpr size_t Annex::Num<plug::ord::is_empty_set> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::is_empty_map> = 0x4131400000000800;
template<> constexpr size_t Annex::Num<plug::ord::is_empty_map> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::get> = 0x4131400000000900;
template<> constexpr size_t Annex::Num<plug::ord::get> = 0;
template<> constexpr flags_t Annex::Base<plug::ord::contains> = 0x4131400000000a00;
template<> constexpr size_t Annex::Num<plug::ord::contains> = 2;
template<> constexpr flags_t Annex::Base<plug::ord::insert> = 0x4131400000000b00;
template<> constexpr size_t Annex::Num<plug::ord::insert> = 2;
 
template<> struct Axm::IsANode<plug::ord::Key> { using type = Axm; };
template<> struct Axm::IsANode<plug::ord::create_set> { using type = Axm; };
template<> struct Axm::IsANode<plug::ord::create_map> { using type = Axm; };
template<> struct Axm::IsANode<plug::ord::is_empty_set> { using type = Axm; };
template<> struct Axm::IsANode<plug::ord::is_empty_map> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::ord::init> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::ord::size> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::ord::contains> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::ord::insert> : std::true_type {};
 
#endif