autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::vec @ref vec 
namespace mim {
namespace plug::vec {
 
static constexpr plugin_t Plugin_Id = 0x5c61000000000000;
 
/// @name %%vec.fold
///@{
enum class fold : flags_t {
    l = 0x5c61000000000000,
    r = 0x5c61000000000001,
};
 
template<fold>
const Def* normalize_fold(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%vec.zip
///@{
enum class zip : flags_t {
};
 
const Def* normalize_zip(const Def*, const Def*, const Def*);
///@}
 
/// @name %%vec.scan
///@{
enum class scan : flags_t {
    for_all = 0x5c61000000000200,
    exists = 0x5c61000000000201,
};
 
template<scan>
const Def* normalize_scan(const Def*, const Def*, const Def*);
 
///@}
 
/// @name %%vec.first
///@{
enum class first : flags_t {
};
 
///@}
 
/// @name %%vec.last
///@{
enum class last : flags_t {
};
 
///@}
 
/// @name %%vec.len
///@{
enum class len : flags_t {
};
 
///@}
 
/// @name %%vec.is_unique
///@{
enum class is_unique : flags_t {
};
 
const Def* normalize_is_unique(const Def*, const Def*, const Def*);
///@}
 
/// @name %%vec.cat
///@{
enum class cat : flags_t {
};
 
const Def* normalize_cat(const Def*, const Def*, const Def*);
///@}
 
/// @name %%vec.diff
///@{
enum class diff : flags_t {
};
 
const Def* normalize_diff(const Def*, const Def*, const Def*);
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_vec_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(fold::l)] = &normalize_fold<fold::l>; \
        normalizers[flags_t(fold::r)] = &normalize_fold<fold::r>; \
        normalizers[flags_t(Annex::Base<zip>)] = &normalize_zip; \
        normalizers[flags_t(scan::for_all)] = &normalize_scan<scan::for_all>; \
        normalizers[flags_t(scan::exists)] = &normalize_scan<scan::exists>; \
        normalizers[flags_t(Annex::Base<is_unique>)] = &normalize_is_unique; \
        normalizers[flags_t(Annex::Base<cat>)] = &normalize_cat; \
        normalizers[flags_t(Annex::Base<diff>)] = &normalize_diff; \
    }
} // namespace plug::vec
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::vec::fold> = 0x5c61000000000000;
template<> constexpr size_t Annex::Num<plug::vec::fold> = 2;
template<> constexpr flags_t Annex::Base<plug::vec::zip> = 0x5c61000000000100;
template<> constexpr size_t Annex::Num<plug::vec::zip> = 0;
template<> constexpr flags_t Annex::Base<plug::vec::scan> = 0x5c61000000000200;
template<> constexpr size_t Annex::Num<plug::vec::scan> = 2;
template<> constexpr flags_t Annex::Base<plug::vec::first> = 0x5c61000000000300;
template<> constexpr size_t Annex::Num<plug::vec::first> = 0;
template<> constexpr flags_t Annex::Base<plug::vec::last> = 0x5c61000000000400;
template<> constexpr size_t Annex::Num<plug::vec::last> = 0;
template<> constexpr flags_t Annex::Base<plug::vec::len> = 0x5c61000000000500;
template<> constexpr size_t Annex::Num<plug::vec::len> = 0;
template<> constexpr flags_t Annex::Base<plug::vec::is_unique> = 0x5c61000000000600;
template<> constexpr size_t Annex::Num<plug::vec::is_unique> = 0;
template<> constexpr flags_t Annex::Base<plug::vec::cat> = 0x5c61000000000700;
template<> constexpr size_t Annex::Num<plug::vec::cat> = 0;
template<> constexpr flags_t Annex::Base<plug::vec::diff> = 0x5c61000000000800;
template<> constexpr size_t Annex::Num<plug::vec::diff> = 0;
 
template<> struct Axm::IsANode<plug::vec::first> { using type = Axm; };
template<> struct Axm::IsANode<plug::vec::last> { using type = Axm; };
template<> struct Axm::IsANode<plug::vec::len> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::vec::fold> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::vec::scan> : std::true_type {};
 
#endif