Macros.h File Reference

#include "IdAndPerspectiveMacros.h"
#include "ClassMethodMacros.h"
#include "bio/common/macro/Macros.h"

Include dependency graph for physical/macro/Macros.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	BIO_GET_REQUIRED_CLASS_METHODS_FOR_physical()
#define	BIO_GET_OPTIONAL_CLASS_METHODS_FOR_physical()
#define	BIO_CODE_FUNCTION_BODY(functionName)
#define	BIO_STATE_FUNCTION_BODY(functionName)
#define	BIO_PROPERTY_FUNCTION_BODY(functionName)
#define	BIO_SYMMETRY_TYPE_FUNCTION_BODY(functionName)
#define	BIO_FILTER_FUNCTION_BODY(functionName)
#define	BIO_SUPERPOSITION_FUNCTION_BODY(functionName)

Macro Definition Documentation

BIO_CODE_FUNCTION_BODY

#define BIO_CODE_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName,                                                              \
    ::bio::CodePerspective::Instance(),                                        \
    ::bio::Code)

To make defining return codes easier, use this macro to define the function body of your Code Function().
This will assign a value to a string that is identical to your FunctionName e.g. SafelyAccess<CodePerspective>()->GetNameFromId(Success()) would give "Success"
REMINDER: Your Code Function()s should be in the bio::code namespace.

BIO_FILTER_FUNCTION_BODY

#define BIO_FILTER_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName,                                                              \
    ::bio::FilterPerspective::Instance(),                                      \
    ::bio::Filter)

To make defining Filters easier, use this macro to define the function body of your Filter Function().
This will assign a value to a string that is identical to your FunctionName e.g. SafelyAccess<FilterPerspective>()->GetNameFromId(Value()) would give "Value".
REMINDER: Your Filter Function()s should be in the bio::filter namespace.

BIO_GET_OPTIONAL_CLASS_METHODS_FOR_physical

#define BIO_GET_OPTIONAL_CLASS_METHODS_FOR_physical

(

)

Value:

    (                                                                          \
        virtual ::bio::Pointer< ::bio::physical::Wave > Modulate(             \
            ::bio::Pointer< ::bio::physical::Wave > signal),                  \
        Modulate(signal)                                                       \
    ),                                                                         \
    (                                                                          \
        virtual ::bio::Pointer< ::bio::physical::Wave > Demodulate(),         \
        Demodulate()                                                           \
    ),                                                                         \
    (                                                                          \
        virtual ::bio::Pointer< const ::bio::physical::Wave > Demodulate() const,\
        Demodulate()                                                           \
    ),                                                                         \
    (                                                                          \
        BIO_SINGLE_ARG(virtual ::bio::Pointer< ::bio::physical::Wave > Superpose(\
            const ::bio::physical::ConstWaves& displacement,                   \
            ::bio::Pointer< ::bio::physical::Interference > pattern)),        \
        BIO_SINGLE_ARG(Superpose(displacement, pattern))                       \
    ),                                                                         \
    (                                                                          \
        BIO_SINGLE_ARG(virtual bool Superpose(                                 \
            ::bio::Pointer< const ::bio::physical::Wave > displacement,       \
            ::bio::Pointer< ::bio::physical::Interference > pattern)),        \
        BIO_SINGLE_ARG(Superpose(displacement, pattern))                       \
    )

Get all optional virtual methods defined by physical::Class.

Returns

function signatures for use in BIO_DISAMBIGUATE_OPTIONAL_CLASS_METHODS

BIO_GET_REQUIRED_CLASS_METHODS_FOR_physical

#define BIO_GET_REQUIRED_CLASS_METHODS_FOR_physical

(

)

Value:

    (                                                                          \
        virtual ::bio::Pointer< ::bio::physical::Wave > Clone() const,         \
        Clone()                                                                \
    ),                                                                         \
    (                                                                          \
        ::bio::Pointer< ::bio::physical::Wave > AsWave(),                     \
        AsWave()                                                               \
    ),                                                                         \
    (                                                                          \
        ::bio::Pointer< const ::bio::chemical::Atom > AsAtom() const,         \
        AsAtom()                                                               \
    ),                                                                         \
     (                                                                         \
        ::bio::Pointer< ::bio::chemical::Atom > AsAtom(),                     \
        AsAtom()                                                               \
    ),                                                                         \
    (                                                                          \
        ::bio::Pointer< const ::bio::physical::Wave > AsWave() const,         \
        AsWave()                                                               \
    ),                                                                         \
    (                                                                          \
        operator ::bio::Pointer< ::bio::physical::Wave >(),                   \
        operator ::bio::Pointer< ::bio::physical::Wave >()                    \
    )

Get all virtual methods defined by physical::Class.

Returns

function signatures for use in BIO_DISAMBIGUATE_REQUIRED_CLASS_METHODS

BIO_PROPERTY_FUNCTION_BODY

#define BIO_PROPERTY_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName,                                                              \
    ::bio::PropertyPerspective::Instance(),                                    \
    ::bio::Property)

To make defining Properties easier, use this macro to define the function body of your Property Function().
This will assign a value to a string that is identical to your FunctionName e.g. SafelyAccess<PropertyPerspective>()->GetNameFromId(Value()) would give "Value".
REMINDER: Your Property Function()s should be in the bio::property namespace.

BIO_STATE_FUNCTION_BODY

#define BIO_STATE_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName,                                                              \
    ::bio::StatePerspective::Instance(),                                       \
    ::bio::State)

To make defining States easier, use this macro to define the function body of your State Function().
This will assign a value to a string that is identical to your FunctionName e.g. SafelyAccess<StatePerspective>()->GetNameFromId(Value()) would give "Value".
REMINDER: Your State Function()s should be in the bio::state namespace.

BIO_SUPERPOSITION_FUNCTION_BODY

#define BIO_SUPERPOSITION_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName,                                                              \
    ::bio::SuperpositionPerspective::Instance(),                               \
    ::bio::Superposition)

To make defining Interferences easier, use this macro to define the function body of your Interference Function().
This will assign a value to a string that is identical to your FunctionName e.g. SafelyAccess<InterferencePerspective>()->GetNameFromId(Value()) would give "Value".
REMINDER: Your Interference Function()s should be in the ::bio::interference namespace.

BIO_SYMMETRY_TYPE_FUNCTION_BODY

#define BIO_SYMMETRY_TYPE_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName,                                                              \
    ::bio::SymmetryTypePerspective::Instance(),                                \
    ::bio::SymmetryType)

To make defining SymmetryTypes easier, use this macro to define the function body of your SymmetryType Function().
This will assign a value to a string that is identical to your FunctionName e.g. SafelyAccess<SymmetryTypePerspective>()->GetNameFromId(Value()) would give "Value".
REMINDER: Your SymmetryType Function()s should be in the bio::symmetry_type namespace.