Macros.h File Reference

#include "IdAndPerspectiveMacros.h"
#include "ClassMethodMacros.h"
#include "bio/common/macros/Macros.h"
#include "bio/physical/Perspective.h"

Include dependency graph for Macros.h:

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

Go to the source code of this file.

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

Macro Definition Documentation

BIO_CODE_FUNCTION_BODY

#define BIO_CODE_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName##Code,                                                        \
    ::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. CodePerspective::Instance().GetNameFromId(Success()) would give "Success" REMINDER: Your Code Function()s should be in the bio::code namespace.

Definition at line 78 of file Macros.h.

BIO_FILTER_FUNCTION_BODY

#define BIO_FILTER_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName##Filter,                                                      \
    ::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. FilterPerspective::Instance().GetNameFromId(Value()) would give "Value". REMINDER: Your Filter Function()s should be in the bio::filter namespace.

Definition at line 123 of file Macros.h.

BIO_GET_OPTIONAL_CLASS_METHODS_FOR_physical

#define BIO_GET_OPTIONAL_CLASS_METHODS_FOR_physical

(

)

Value:

    (                                                                          \
        virtual ::bio::physical::Wave* Modulate(::bio::physical::Wave* signal),\
        Modulate(signal)                                                       \
    ),                                                                         \
    (                                                                          \
        virtual ::bio::physical::Wave* Demodulate(),                           \
        Demodulate()                                                           \
    ),                                                                         \
    (                                                                          \
        virtual const ::bio::physical::Wave* Demodulate() const,               \
        Demodulate()                                                           \
    )

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

Returns

function signatures for use in BIO_DISAMBIGUATE_OPTIONAL_CLASS_METHODS

Definition at line 58 of file Macros.h.

BIO_GET_REQUIRED_CLASS_METHODS_FOR_physical

#define BIO_GET_REQUIRED_CLASS_METHODS_FOR_physical

(

)

Value:

    (                                                                          \
        virtual ::bio::physical::Wave* Clone() const,                          \
        Clone()                                                                \
    ),                                                                         \
    (                                                                          \
        virtual ::bio::physical::Wave* AsWave(),                               \
        AsWave()                                                               \
    ),                                                                         \
    (                                                                          \
        virtual const ::bio::physical::Wave* AsWave() const,                   \
        AsWave()                                                               \
    ),                                                                         \
    (                                                                          \
        virtual operator ::bio::physical::Wave*(),                             \
        operator ::bio::physical::Wave*()                                      \
    )

Get all virtual methods defined by physical::Class.

Returns

function signatures for use in BIO_DISAMBIGUATE_REQUIRED_CLASS_METHODS

Definition at line 36 of file Macros.h.

BIO_PROPERTY_FUNCTION_BODY

#define BIO_PROPERTY_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName##Property,                                                    \
    ::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. PropertyPerspective::Instance().GetNameFromId(Value()) would give "Value". REMINDER: Your Property Function()s should be in the bio::property namespace.

Definition at line 101 of file Macros.h.

BIO_STATE_FUNCTION_BODY

#define BIO_STATE_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName##State,                                                       \
    ::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. StatePerspective::Instance().GetNameFromId(Value()) would give "Value". REMINDER: Your State Function()s should be in the bio::state namespace.

Definition at line 89 of file Macros.h.

BIO_SYMMETRY_TYPE_FUNCTION_BODY

#define BIO_SYMMETRY_TYPE_FUNCTION_BODY

(

functionName

)

Value:

BIO_ID_FUNCTION_BODY(                                                          \
    functionName##SymmetryType,                                                \
    ::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. SymmetryTypePerspective::Instance().GetNameFromId(Value()) would give "Value". REMINDER: Your SymmetryType Function()s should be in the bio::symmetry_type namespace.

Definition at line 112 of file Macros.h.