puddle/doc/concepts.hpp

Go to the documentation of this file.

#ifndef PUDDLE_DOC_CONCEPTS_1104071043_HPP
#define PUDDLE_DOC_CONCEPTS_1104071043_HPP

#include <puddle/config.hpp>

// This section is here for documentation purposes only
#ifdef MIRROR_DOCUMENTATION_ONLY

PUDDLE_NAMESPACE_BEGIN

struct Integer;
struct Boolean;
struct MetaObject;
struct MetaNamedObject;
struct MetaScopedObject;
struct MetaNamedScopedObject;
struct MetaScope;
struct MetaNamespace;
struct MetaType;
struct MetaClass;
struct MetaEnum;
struct MetaVariable;
struct MetaClassMember;
struct MetaConstructor;
struct MetaContainer;

template <typename IntType>
struct IntConst
{
    IntType value(void) const;


    operator IntType (void) const;

    friend Boolean operator == (IntConst, IntConst);

    friend Boolean operator != (IntConst, IntConst);

    friend Boolean operator <= (IntConst, IntConst);

    friend Boolean operator >= (IntConst, IntConst);

    friend Boolean operator <  (IntConst, IntConst);

    friend Boolean operator >  (IntConst, IntConst);

    IntConst operator ! (void) const;

    friend IntConst operator + (IntConst, IntConst);

    friend IntConst operator - (IntConst, IntConst);

    friend IntConst operator * (IntConst, IntConst);

    friend IntConst operator / (IntConst, IntConst);

    friend IntConst operator & (IntConst, IntConst);

    friend IntConst operator | (IntConst, IntConst);

    friend IntConst operator && (IntConst, IntConst);

    friend IntConst operator || (IntConst, IntConst);
};

struct Integer : IntConst<int> { };

struct Boolean : IntConst<bool> { };

struct Character : IntConst<char> { };



struct CompileTimeString
{
    const char* c_str(void) const;

    friend Boolean operator == (CompileTimeString, CompileTimeString);

    friend Boolean operator != (CompileTimeString, CompileTimeString);

    friend CompileTimeString operator + (
        CompileTimeString,
        CompileTimeString
    );

    Boolean empty(void) const;

    Integer size(void) const;

    Character front(void) const;

    Character at(Integer index) const;

    template <int Index>
    Character at_c(void) const;

    Boolean starts_with(CompileTimeString str) const;

    Boolean ends_with(CompileTimeString str) const;

    Boolean contains(CompileTimeString str) const;

    CompileTimeString step_front(void) const;

    CompileTimeString skip_front(Integer n) const;

    template <int N>
    CompileTimeString skip_front_c(void) const;

    CompileTimeString head(Integer n) const;

    template <int N>
    CompileTimeString head_c(void) const;

    CompileTimeString tail(Integer n) const;

    template <int N>
    CompileTimeString tail_c(void) const;

    CompileTimeString find(CompileTimeString str) const;
};


template <typename Element>
struct Range
{
    Boolean empty(void) const;

    Integer size(void) const;


    Range step_front(void) const;

    Element front(void) const;

    Element at(Index) const;

    template <int Index>
    Element at_c(void) const;

    template <class UnaryPredicate>
    Range only_if(UnaryPredicate pred) const;


    template <class Functor>
    void for_each(Functor func) const;


    template <typename ResultType, class Functor, typename ValueType>
    ResultType accumulate(Functor func, ValueType init=ResultType()) const;
};

struct Tag
{
    friend Boolean operator == (Specifier, Specifier);

    friend Boolean operator != (Specifier, Specifier);

    friend Boolean operator <= (Specifier, Specifier);

    friend Boolean operator >= (Specifier, Specifier);

    friend Boolean operator <  (Specifier, Specifier);

    friend Boolean operator >  (Specifier, Specifier);

    operator bool (void) const;

    bool operator ! (void) const;
};

struct Specifier : Tag
{
    std::string keyword(void) const;
};


struct ContainerKind : Tag
{
};



struct MetaInstance
{

    MetaVariable variable(void) const;


    Range<MetaInstance> attributes(void) const;

    Type get(void) const;

    void set(Type value) const;


    meta_instance_tag category(void) const;


    template <typename Category>
    Boolean is_a(Category) const;
};


struct MetaPlainInstance
{
    Type* address(void) const;

    meta_plain_instance_tag category(void) const;
};


struct MetaObject
{
    friend Boolean operator == (MetaObject, MetaObject);

    friend Boolean operator != (MetaObject, MetaObject);


    mirror::meta_object_tag category(void) const;


    template <typename Category>
    Boolean is_a(Category) const;

};


struct MetaNamedObject
 : virtual public MetaObject
{

    std::string base_name(void) const;

    CompileTimeString static_name(void) const;

    mirror::meta_named_object_tag category(void) const;
};


struct MetaMetaObject
 : virtual public MetaNamedObject
{

    std::string construct_name(void) const;


    Range<MetaMetaObject> generalizations(void) const;

    mirror::meta_meta_object_tag category(void) const;
};



struct MetaScopedObject
 : virtual public MetaObject
{

    MetaScope scope(void) const;

    mirror::meta_scoped_object_tag category(void) const;
};


struct MetaNamedScopedObject
 : virtual public MetaNamedObject
 , virtual public MetaScopedObject
{

    std::string full_name(void) const;


    std::string local_name(void) const;

    mirror::meta_named_scoped_object_tag category(void) const;
};


struct MetaScope
 : virtual public MetaNamedScopedObject
{
    Range<MetaNamedScopedObject> members(void) const;

    mirror::meta_scope_tag category(void) const;
};


struct MetaNamespace
 : virtual public MetaScope
{

    Range<MetaNamespace> namespaces(void) const;


    Range<MetaFreeVariable> free_variables(void) const;


    unspecified free_variables_by_name(void) const;


    unspecified* operator -> (void) const;


    Range<MetaOverloadedFunctions> free_functions(void) const;

    mirror::meta_namespace_tag category(void) const;
};


struct MetaType
 : virtual public MetaNamedScopedObject
{

    static unspecified original_type(void);


    Range<MetaConstructor> constructors(void) const;


    ContainerKind container_kind(void) const;


    Range<MetaContainer> containers(void) const;

    template <template <class> class UnaryTrait>
    unspecified apply(void) const;

    mirror::meta_type_tag category(void) const;
};


struct MetaTypedef
 : virtual public MetaType
{
    MetaType type(void) const;

    mirror::meta_typedef_tag category(void) const;
};


struct MetaTemplatedType
 : virtual public MetaType
{
    typedef MetaTypeTemplate type_template;


    MetaTemplatedType type_template(void) const;


    Range<MetaType> template_parameters(void) const;

    mirror::meta_templated_type_tag category(void) const;
};


struct MetaTypeTemplate
 : virtual public MetaNamedScopedObject
{

    mirror::meta_type_template_tag category(void) const;
};


struct MetaClass
 : virtual public MetaType
 , virtual public MetaScope
{

    Specifier elaborated_type(void) const;


    Range<MetaInheritance> base_classes(void) const;


    Range<MetaMemberVariable> member_variables(void) const;


    Range<MetaMemberVariable> all_member_variables(void) const;


    unspecified member_variables_by_name(void) const;


    unspecified* operator -> (void) const;


    Range<MetaContainer> all_containers(void) const;

    mirror::meta_class_tag category(void) const;
};


struct MetaClassMember
 : virtual public MetaNamedScopedObject
{
    MetaClass scope(void) const;


    Specifier access_type(void) const;

    mirror::meta_class_member_tag category(void) const;
};


struct MetaTemplatedClass
 : virtual public MetaTemplatedType
 , virtual public MetaClass
{

    mirror::meta_templated_class_tag category(void) const;
};


struct MetaEnum
 : virtual public MetaType
 , virtual public MetaScope
{
    Integer size(void) const;


    Range<MetaEnumValue> enum_values(void) const;

    UnspecifiedEnumType value(Integer index) const;

    UnspecifiedEnumType value(int index) const;

    std::string value_name(Integer index) const;

    std::string value_name(int index) const;

    std::string name_by_value(Enum x) const;

    mirror::meta_enum_tag category(void) const;
};


struct MetaEnumValue
 : virtual public MetaNamedScopedObject
{
    MetaEnum scope(void) const;

    Integer value(void) const;

    mirror::meta_enum_value_tag category(void) const;
};


struct MetaInheritance
 : virtual public MetaObject
{
    MetaClass derived_class(void) const;


    Specifier inheritance_type(void) const;


    Specifier access_type(void) const;

    MetaClass base_class(void) const;

    mirror::meta_inheritance_tag category(void) const;
};



struct MetaVariable
 : virtual public MetaNamedScopedObject
{

    Specifier storage_class(void) const;

    MetaType type(void) const;

    mirror::meta_variable_tag category(void) const;
};


struct MetaFreeVariable
 : virtual public MetaVariable
{
    MetaNamespace scope(void) const;


    Type get(void) const;


    void set(Type new_value) const;

    mirror::meta_free_variable_tag category(void) const;
};


struct MetaPlainFreeVariable
 : virtual public MetaFreeVariable
{

    Type* address(void);

    mirror::meta_plain_free_variable_tag category(void) const;
};


struct MetaMemberVariable
 : virtual public MetaClassMember
 , virtual public MetaVariable
{

    Type get(const Class& instance) const;


    void set(Class& instance, Type new_value) const;

    mirror::meta_member_variable_tag category(void) const;
};


struct MetaPlainMemberVariable
 : virtual public MetaMemberVariable
{
    ptrdiff_t offset(void) const;


    Type* address(Class& instance) const;

    const Type* address(const Class& instance) const;

    MemberVariablePointer member_pointer(void) const;

    mirror::meta_plain_member_variable_tag category(void) const;
};


struct MetaParameter
 : virtual public MetaVariable
{
    Integer position(void) const;

    mirror::meta_parameter_tag category(void) const;
};


struct MetaFunction
 : virtual public MetaScope
{
    MetaType result_type(void) const;


    Specifier storage_class(void) const;

    Specifier linkage(void) const;

    Range<MetaParameter> parameters(void) const;

    mirror::meta_function_tag category(void) const;
};


struct MetaMemberFunction
 : virtual public MetaClassMember
 , virtual public MetaFunction
{
    Specifier constness(void) const;

    mirror::meta_member_function_tag category(void) const;
};


struct MetaConstructor
 : virtual public MetaFunction
 , virtual public MetaClassMember
{
    mirror::meta_constructor_tag category(void) const;
};


struct MetaConversionOperator
 : virtual public MetaMemberFunction
{
    mirror::meta_conversion_operator_tag category(void) const;
};


struct MetaOverloadedFunctions
 : virtual public MetaNamedScopedObject
{
    Range<MetaFunction> overloads(void) const;

    mirror::meta_overloaded_functions_tag category(void) const;
};


struct MetaTraversal
 : virtual public MetaNamedObject
{
    MetaContainer container(void) const;

    mirror::Traversal start(Container container) const;

    mirror::meta_traversal_tag category(void) const;
};


struct MetaLocator
 : virtual public MetaNamedObject
{
    MetaContainer container(void) const;

    // TODO: signature
    mirror::Locator go_to(Container container, ...) const;

    mirror::meta_traversal_tag category(void) const;
};


struct MetaInserter
 : virtual public MetaNamedObject
{
    MetaContainer container(void) const;

    // TODO: signature, insert

    mirror::meta_inserter_tag category(void) const;
};


struct MetaEraser
 : virtual public MetaNamedObject
{
    MetaContainer container(void) const;

    // TODO: signature, erase

    mirror::meta_eraser_tag category(void) const;
};


struct MetaContainer
 : virtual public MetaScopedObject
{

    MetaScope scope(void) const;

    MetaType element_type(void) const;

    MetaTraversal default_traversal(void) const;

    Range<MetaTraversal> traversals(void) const;

    Range<MetaInserter> inserters(void) const;

    Range<MetaEraser> erasers(void) const;

    mirror::meta_container_tag category(void) const;
};

PUDDLE_NAMESPACE_END

#endif // MIRROR_DOCUMENTATION_ONLY

#endif //include guard