Go to the source code of this file.
◆ BIO_CALL_LOOP
| #define BIO_CALL_LOOP |
( |
|
loopName, |
|
|
|
iterations, |
|
|
|
... |
|
) |
| loopName##_##iterations(__VA_ARGS__) |
Call a macro-based loop. These are hard-coded with a certain iteration count. Expands loopName from something like MY_LOOP with iterations of, say, 5 to MY_LOOP_5(...). Requires that MY_LOOP_5 be implemented.
- Parameters
-
| loopName | the base name of the macro to call |
| iterations | the number of times to call the given macro |
| ... | all arguments to give to the loop, including iterations. |
Definition at line 85 of file Macros.h.
◆ BIO_CALL_NS_MACRO
| #define BIO_CALL_NS_MACRO |
( |
|
macroName, |
|
|
|
ns, |
|
|
|
... |
|
) |
| macroName##_##ns(__VA_ARGS__) |
Calls a namespaced macro. NOTE: These deviate from the traditional naming scheme because namespaces are lowercase and, for ease of use, we will not require the namespace be written in both capitals and lower case. Will expand MY_MACRO, cellular to MY_MACRO_cellular(...)
- Parameters
-
| macroName | the name of the macro to call |
| ns | the namespace in which to call the macro. |
Definition at line 75 of file Macros.h.
◆ BIO_DEFINE_MAP
| #define BIO_DEFINE_MAP |
( |
|
mapName, |
|
|
|
keyType, |
|
|
|
valueType |
|
) |
| |
Value:typedef std::map<keyType, valueType> mapName; \
typedef std::pair<keyType, valueType> mapName##Pair;
Create a consistent map and pair.
Definition at line 115 of file Macros.h.
◆ BIO_EXPAND_TUPLE
| #define BIO_EXPAND_TUPLE |
( |
|
... | ) |
__VA_ARGS__ |
Used to remove fhe parentheses from around an expression. Should be invoked as: BIO_EXPAND_TUPLE tuple where tuple is (something, like, this) which expands to BIO_EXPAND_TUPLE (something, like, this) => something, like, this
Definition at line 49 of file Macros.h.
◆ BIO_SINGLE_ARG
| #define BIO_SINGLE_ARG |
( |
|
... | ) |
__VA_ARGS__ |
Encapsulates an expression containing commas, allowing it to be safely passed as a single macro argument. Should be invoked as: SOME_OTHER_MACRO(
BIO_SINGLE_ARG(
something,
that,
would,
normally,
be,
many,
args
), whatever, other, arguments, are, needed) While this is currently exactly the same as BIO_EXPAND_TUPLE, the use case is different, so duplicate code is maintained.
Definition at line 66 of file Macros.h.
◆ BIO_SINGLETON
| #define BIO_SINGLETON |
( |
|
className, |
|
|
|
baseClass |
|
) |
| |
Value:class className : \
public baseClass \
{ \
public: \
static className& Instance() \
{ \
static className instance; \
return instance; \
} \
private: \
className() \
{ \
} \
className(className const &); \
void operator=(className const &); \
};
Singleton interface makes the constructor private so that there is only one instance ever created, which is by Instance() we also override default copy constructor and assignment operator so that nobody can make a copy of the singleton (otherwise it wouldn't be a singleton). We don't define them, so these methods will give a link error if used.
- Parameters
-
| className | the name of the new singleton |
| baseClass | the name of the class the new singleton will inherit from (i.e. what to make into a singleton). |
Definition at line 94 of file Macros.h.
◆ BIO_WRAP_MACRO
| #define BIO_WRAP_MACRO |
( |
|
macro | ) |
macro |
This file contains all common preprocessor macros. Additional macros may be specified in files they more specifically pertain to All bio macros start with BIO_ Wrapping macros is used to evaluate them within other macros, rather than being passed as a string.
Definition at line 41 of file Macros.h.
Include dependency graph for Macros.h: