mrdocs::tag_invoke

tag_invoke overloads

Synopses

Map an AttributeKind into a DOM value.

Serialize the auto kind into a DOM value.

Serialize a FundamentalTypeKind into a DOM value.

Map an operator kind to a DOM value (its underlying integer).

Map a QualifierKind into a DOM value.

Return the ReferenceKind as a dom::Value string.

Map a TypeKind into a DOM value.

Return the UsingClass as a dom::Value string.

Return the AccessKind as a dom::Value string.

Return the ConstexprKind as a dom::Value string.

Return the StorageClassKind as a dom::Value string.

Return the ExplicitInfo as a dom::Value string.

Serialize source locations into a DOM value.

Convert SymbolID to dom::Value string in the DOM using toBase16

Convert a NoexceptInfo to a DOM value.

void
tag_invoke(
    dom::ValueFromTag tag,
    dom::Value& v,
    NoexceptInfo const& info);

Map the SourceInfo to a lazy DOM object.

template<class IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO&,
    SourceInfo const&);

Generic ValueFrom for any described enum.

template<typename Enum>
requires describe::has_describe_enumerators<Enum>::value
void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Enum e);

Generic tag_invoke for described types without context.

template<
    typename IO,
    typename T>
requires describe::has_describe_members<T>::value
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    T const& I);

Map an ExprInfo to a dom::Value object.

void
tag_invoke(
    dom::LazyObjectMapTag,
    dom::Value& v,
    ExprInfo const& expr,
    DomCorpus const*);

Serialize an Attribute into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Attribute const& I,
    DomCorpus const* domCorpus);

Serialize a base description into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    BaseInfo const& I,
    DomCorpus const* domCorpus);

Map an ExprInfo to a dom::Value object.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    ExprInfo const& expr,
    DomCorpus const*);

Serialize a name into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Name const& I,
    DomCorpus const* domCorpus);

Return the Param as a dom::Value object.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Param const& p,
    DomCorpus const* domCorpus);

Convert SymbolID to dom::Value object in the DOM using Corpus

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    SymbolID const& id,
    DomCorpus const* domCorpus);

Serialize the argument to a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    TArg const& I,
    DomCorpus const* domCorpus);

Serialize a template parameter into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    TParam const& I,
    DomCorpus const* domCorpus);

Serialize template info into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    TemplateInfo const& I,
    DomCorpus const* domCorpus);

Serialize a Type into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Type const& I,
    DomCorpus const* domCorpus);

Convert an optional SymbolID to dom::Value or null.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Optional<SymbolID> const& id,
    DomCorpus const* domCorpus);

Serialize an optional template info into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Optional<TemplateInfo> const& I,
    DomCorpus const* domCorpus);

Serialize an optional polymorphic name into a DOM value.

Serialize an optional polymorphic type into a DOM value.

Serialize a polymorphic attribute into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Polymorphic<Attribute> const& I,
    DomCorpus const* domCorpus);

Serialize a polymorphic name into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Polymorphic<Name> const& I,
    DomCorpus const* domCorpus);

Serialize a polymorphic template argument into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Polymorphic<TArg> const& I,
    DomCorpus const* domCorpus);

Serialize a polymorphic template parameter.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Polymorphic<TParam> const& I,
    DomCorpus const* domCorpus);

Serialize a polymorphic type into a DOM value.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Polymorphic<Type> const& I,
    DomCorpus const* domCorpus);

Convert SymbolID pointers to dom::Value or null.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    std::unique_ptr<SymbolID> const& t,
    DomCorpus const* domCorpus);

Map a vector of parameters to a dom::Value object.

void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    std::vector<Param> const& params,
    DomCorpus const* domCorpus);

Map an ArrayType to a dom::Object with split bounds properties.

template<typename IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    ArrayType const& I,
    DomCorpus const* domCorpus);

Map a BaseInfo to a dom::Object with computed access booleans.

template<class IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    BaseInfo const& I,
    DomCorpus const* domCorpus);

Map a FriendInfo to a dom::Object with deferred name lookup.

template<typename IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    FriendInfo const& I,
    DomCorpus const* domCorpus);

Map a Name to a dom::Object via visit‐based polymorphic dispatch.

template<class IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    Name const& I,
    DomCorpus const* domCorpus);

Map a RecordSymbol to a dom::Object with computed defaultAccess.

template<typename IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    RecordSymbol const& I,
    DomCorpus const* domCorpus);

Map a Symbol to a dom::Object with computed extraction properties.

template<typename IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    Symbol const& I,
    DomCorpus const* domCorpus);

Map a TemplateInfo to a dom::Object with computed specialization kind.

template<class IO>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    TemplateInfo const& I,
    DomCorpus const* domCorpus);

Generic ValueFrom for any described compound type.

template<typename T>
requires (describe::has_describe_members<T>::value &&
              !describe::has_describe_enumerators<T>::value)
void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    T const& I,
    DomCorpus const* domCorpus);

Map the Polymorphic Symbol to a dom::Object.

template<
    class IO,
    polymorphic_storage_for<Symbol> PolymorphicSymbol>
requires std::derived_from<PolymorphicSymbol, Symbol>
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    PolymorphicSymbol const& I,
    DomCorpus const* domCorpus);

Generic tag_invoke for any described type with DomCorpus context.

template<
    typename IO,
    typename T>
requires describe::has_describe_members<T>::value
void
tag_invoke(
    dom::LazyObjectMapTag,
    IO& io,
    T const& I,
    DomCorpus const* domCorpus);

Generic ValueFrom for described enums, with context.

template<
    typename Enum,
    typename Context>
requires describe::has_describe_enumerators<Enum>::value
void
tag_invoke(
    dom::ValueFromTag,
    dom::Value& v,
    Enum e,
    Context const&);

Parameters

Name

Description

v

The output value.

kind

The UsingClass to convert.

I

The ExplicitInfo to convert.

e

The enumerator to convert to a dom::Value string.

io

The lazy object builder to map fields into.

expr

The expression info to convert.

t

The SymbolID pointer to convert. If null, the dom::Value is set to null.

domCorpus

The DomCorpus to use, or nullptr. If null, the SymbolID is converted to a base16 string.

params

The list of parameters to convert.

Created with MrDocs