autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::tuple @ref tuple 
namespace mim {
namespace plug::tuple {
 
static constexpr plugin_t Plugin_Id = 0x55644d1800000000;
 
/// @name %%tuple.cat
///@{
enum class cat : flags_t {
};
 
const Def* normalize_cat(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tuple.cat_uniform
///@{
enum class cat_uniform : flags_t {
};
 
const Def* normalize_cat_uniform(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tuple.append
///@{
enum class append : flags_t {
};
 
///@}
 
/// @name %%tuple.prepend
///@{
enum class prepend : flags_t {
};
 
///@}
 
/// @name %%tuple.contains
///@{
enum class contains : flags_t {
};
 
const Def* normalize_contains(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tuple.zip
///@{
enum class zip : flags_t {
};
 
const Def* normalize_zip(const Def*, const Def*, const Def*);
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_tuple_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<cat>)] = &normalize_cat; \
        normalizers[flags_t(Annex::Base<cat_uniform>)] = &normalize_cat_uniform; \
        normalizers[flags_t(Annex::Base<contains>)] = &normalize_contains; \
        normalizers[flags_t(Annex::Base<zip>)] = &normalize_zip; \
    }
} // namespace plug::tuple
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::tuple::cat> = 0x55644d1800000000;
template<> constexpr size_t Annex::Num<plug::tuple::cat> = 0;
template<> constexpr flags_t Annex::Base<plug::tuple::cat_uniform> = 0x55644d1800000100;
template<> constexpr size_t Annex::Num<plug::tuple::cat_uniform> = 0;
template<> constexpr flags_t Annex::Base<plug::tuple::append> = 0x55644d1800000200;
template<> constexpr size_t Annex::Num<plug::tuple::append> = 0;
template<> constexpr flags_t Annex::Base<plug::tuple::prepend> = 0x55644d1800000300;
template<> constexpr size_t Annex::Num<plug::tuple::prepend> = 0;
template<> constexpr flags_t Annex::Base<plug::tuple::contains> = 0x55644d1800000400;
template<> constexpr size_t Annex::Num<plug::tuple::contains> = 0;
template<> constexpr flags_t Annex::Base<plug::tuple::zip> = 0x55644d1800000500;
template<> constexpr size_t Annex::Num<plug::tuple::zip> = 0;
 
template<> struct Axm::IsANode<plug::tuple::append> { using type = Axm; };
template<> struct Axm::IsANode<plug::tuple::prepend> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif