Helper macros for model definitions. More...

#include "gambit/Models/orphan.hpp"
#include "gambit/Models/claw_singleton.hpp"
#include "gambit/Utils/util_macros.hpp"
#include "gambit/Utils/boost_fallbacks.hpp"
#include "gambit/Elements/ini_functions.hpp"
#include <boost/preprocessor/seq/for_each.hpp>
#include "gambit/Elements/module_macros_inmodule_defs.hpp"

Include dependency graph for model_macros.hpp:

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

Go to the source code of this file.

Macros
#define	START_MODEL MODULE_START_MODEL

#define	DEFINEPARS(...) /* Do nothing */

#define	MAP_TO_CAPABILITY(PARAMETER, CAPABILITY) /* Do nothing */

#define	INTERPRET_AS_X_FUNCTION(MODEL_X, FUNC) MODULE_INTERPRET_AS_X_FUNCTION(MODEL_X,FUNC)

#define	INTERPRET_AS_PARENT_FUNCTION(FUNC) MODULE_INTERPRET_AS_X_FUNCTION(PARENT,FUNC)

#define	INTERPRET_AS_X_DEPENDENCY(MODEL_X, DEP, TYPE) MODULE_INTERPRET_AS_X_DEPENDENCY(MODEL_X, DEP, TYPE)

#define	START_CAPABILITY MODULE_START_CAPABILITY(MODEL)

#define	LONG_START_CAPABILITY(MODULE, C) MODULE_START_CAPABILITY(MODULE)

#define	DECLARE_FUNCTION(TYPE, CAN_MANAGE) MODULE_DECLARE_FUNCTION(MODEL, FUNCTION, TYPE, CAN_MANAGE, IS_MODEL)

#define	LONG_DECLARE_FUNCTION(MODULE, C, FUNCTION, TYPE, CAN_MANAGE) MODULE_DECLARE_FUNCTION(MODULE, FUNCTION, TYPE, CAN_MANAGE, IS_MODEL)

#define	DEPENDENCY(DEP, TYPE) MODULE_DEPENDENCY(DEP, TYPE, MODEL, FUNCTION, IS_MODEL)

#define	LONG_DEPENDENCY(MODULE, FUNCTION, DEP, TYPE) MODULE_DEPENDENCY(DEP, TYPE, MODEL, FUNCTION, IS_MODEL)

#define	NEEDS_MANAGER(...) MODULE_NEEDS_MANAGER_REDIRECT(__VA_ARGS__)

#define	ALLOWED_MODEL(MODULE, FUNCTION, MODEL) MODULE_ALLOWED_MODEL(MODULE,FUNCTION,MODEL,IS_MODEL)

#define	ALLOWED_MODEL_DEPENDENCE(MODULE, FUNCTION, MODEL) MODULE_ALLOWED_MODEL(MODULE,FUNCTION,MODEL,IS_MODEL)

#define	ALLOW_MODEL_COMBINATION(...) DUMMYARG(__VA_ARGS__)

#define	MODEL_GROUP(GROUPNAME, GROUP) DUMMYARG(GROUPNAME, GROUP)

#define	BE_GROUP(GROUP) MODULE_BE_GROUP(GROUP,IS_MODEL)

#define	DECLARE_BACKEND_REQ(GROUP, REQUIREMENT, TAGS, TYPE, ARGS, IS_VARIABLE) MODULE_BACKEND_REQ(MODEL, FUNCTION, GROUP, REQUIREMENT, TAGS, TYPE, ARGS, IS_VARIABLE, IS_MODEL)

#define	LONG_DECLARE_BACKEND_REQ(MODULE, C, FUNCTION, GROUP, REQUIREMENT, TAGS, TYPE, ARGS, IS_VARIABLE) MODULE_BACKEND_REQ(MODULE, FUNCTION, GROUP, REQUIREMENT, TAGS, TYPE, ARGS, IS_VARIABLE, IS_MODEL)

#define	ACTIVATE_BACKEND_REQ_FOR_MODELS(MODELS, TAGS) DUMMYARG(MODELS,TAGS)

#define	START_CONDITIONAL_DEPENDENCY(TYPE) MODULE_DEPENDENCY(CONDITIONAL_DEPENDENCY, TYPE, MODEL, FUNCTION, IS_MODEL)

#define	ACTIVATE_DEP_BE(BACKEND_REQ, BACKEND, VERSTRING) DUMMYARG(BACKEND_REQ, BACKEND, VERSTRING)

#define	ACTIVATE_FOR_MODELS(...) DUMMYARG(__VA_ARGS__)

#define	MODEL_CONDITIONAL_DEPENDENCY(DEP, TYPE, ...) MODULE_DEPENDENCY(DEP, TYPE, MODEL, FUNCTION, IS_MODEL)

#define	BACKEND_OPTION(BACKEND_AND_VERSIONS, TAGS) DUMMYARG(BACKEND_AND_VERSIONS,TAGS)

#define	LONG_BACKEND_OPTION(MODULE, CAPABILITY, FUNCTION, BACKEND_AND_VERSIONS, TAGS) DUMMYARG(BACKEND_AND_VERSIONS,TAGS)

#define	FORCE_SAME_BACKEND(...) DUMMYARG(__VA_ARGS__)

#define	CLASSLOAD_NEEDED(...) DUMMYARG(__VA_ARGS__)

#define	ALLOW_MODELS(...) ALLOW_MODELS_AB(MODEL, FUNCTION, __VA_ARGS__)

#define	MAKE_PRIMARY_MODEL_FUNCTOR(FUNCTION, CAPABILITY, ORIGIN)

#define	MODULE_START_MODEL
	"Rollcall" macros. More...

#define	MODULE_INTERPRET_AS_X_FUNCTION(MODEL_X, FUNC)
	"In module" version of the INTERPRET_AS_X_FUNCTION macro More...

#define	MODULE_INTERPRET_AS_X_DEPENDENCY(MODEL_X, DEP, TYPE) MODULE_DEPENDENCY(DEP, TYPE, MODEL, CAT(MODEL_X,_parameters), IS_MODEL)
	"In module" version of the INTERPRET_AS_X_DEPENDENCY macro More...

#define	CORE_START_MODEL
	Piggybacks off the CORE_START_MODULE_COMMON macro, as we need all the same machinery. More...

#define	CORE_MAP_TO_CAPABILITY(PARAMETER, CAPABILITY)
	Tells the core that the current parameter corresponds to the specified CAPABILITY, so that module functions can then draw upon them like any other capabilities. More...

#define	DEFINEPAR(PARAMETER)
	Macro to define parameter. More...

#define	CORE_INTERPRET_AS_X_FUNCTION(MODEL_X, FUNC) INTERPRET_AS_X_FUNCTION_FULL(MODEL_X,FUNC,1) \
	Real declaration macro for INTERPRET_AS_X functions. More...

#define	INTERPRET_AS_X_FUNCTION_FULL(MODEL_X, FUNC, ADD_FRIEND)
	Generic declaration macro for INTERPRET_AS_ functions. More...

#define	CORE_INTERPRET_AS_X_DEPENDENCY(MODEL_X, DEP, TYPE) CORE_DEPENDENCY(DEP, TYPE, MODEL, CAT(MODEL_X,_parameters), IS_MODEL) \
	Add a dependency to an interpret-as-X function. More...

#define	USE_MODEL_PIPE(MODEL_X) using namespace MODEL_NAMESPACE::Pipes::CAT(MODEL_X,_parameters); \
	Macro to easily get the Pipes for an INTERPRET_AS_X function, for retrieving dependencies. More...


#define	CORE_DEFINEPARS(...) BOOST_PP_SEQ_FOR_EACH(DO_LINK, _, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))
	Define multiple model parameters. More...

#define	DO_LINK(r, data, elem) DEFINEPAR(elem)


#define	INTERPRET_AS_PARENT_DEPENDENCY(DEP, TYPE) INTERPRET_AS_X_DEPENDENCY(PARENT, DEP, TYPE)
	Wrappers to convert INTERPRET_AS_X macros to INTERPRET_AS_PARENT macros. More...

#define	CORE_INTERPRET_AS_PARENT_FUNCTION(FUNC) INTERPRET_AS_X_FUNCTION_FULL(PARENT,FUNC,0)


#define	MODEL_NAMESPACE Gambit::Models::MODEL
	Macro to get to model namespace easily. More...


#define	MAKE_PRIMARY_MODEL_FUNCTOR_MAIN(FUNCTION, CAPABILITY, ORIGIN)
	Macros to create and register primary model functors. More...

#define	MAKE_PRIMARY_MODEL_FUNCTOR_SUPP(FUNCTION)
	Supplementary version of MAKE_FUNCTOR modded for primary_parameters functors. More...

Detailed Description

Helper macros for model definitions.

Authors (add name and date if you modify):

Author: Ben Farmer (benja.nosp@m.min..nosp@m.farme.nosp@m.r@mo.nosp@m.nash..nosp@m.edu..nosp@m.au)

Date: 2013 May, June, July

Author: Pat Scott (patsc.nosp@m.ott@.nosp@m.physi.nosp@m.cs.m.nosp@m.cgill.nosp@m..ca)

Date: 2013 July, Aug; 2014 Jan, Nov; 2015 Feb

Definition in file model_macros.hpp.

Macro Definition Documentation

◆ ACTIVATE_BACKEND_REQ_FOR_MODELS

#define ACTIVATE_BACKEND_REQ_FOR_MODELS	(	MODELS,
		TAGS
	)	DUMMYARG(MODELS,TAGS)

Definition at line 104 of file model_macros.hpp.

◆ ACTIVATE_DEP_BE

#define ACTIVATE_DEP_BE	(	BACKEND_REQ,
		BACKEND,
		VERSTRING
	)	DUMMYARG(BACKEND_REQ, BACKEND, VERSTRING)

Definition at line 106 of file model_macros.hpp.

◆ ACTIVATE_FOR_MODELS

#define ACTIVATE_FOR_MODELS ( ... ) DUMMYARG(__VA_ARGS__)

Definition at line 107 of file model_macros.hpp.

◆ ALLOW_MODEL_COMBINATION

#define ALLOW_MODEL_COMBINATION ( ... ) DUMMYARG(__VA_ARGS__)

Definition at line 96 of file model_macros.hpp.

◆ ALLOW_MODELS

#define ALLOW_MODELS ( ... ) ALLOW_MODELS_AB(MODEL, FUNCTION, __VA_ARGS__)

Definition at line 116 of file model_macros.hpp.

◆ ALLOWED_MODEL

#define ALLOWED_MODEL	(	MODULE,
		FUNCTION,
		MODEL
	)	MODULE_ALLOWED_MODEL(MODULE,FUNCTION,MODEL,IS_MODEL)

Definition at line 94 of file model_macros.hpp.

◆ ALLOWED_MODEL_DEPENDENCE

#define ALLOWED_MODEL_DEPENDENCE	(	MODULE,
		FUNCTION,
		MODEL
	)	MODULE_ALLOWED_MODEL(MODULE,FUNCTION,MODEL,IS_MODEL)

Definition at line 95 of file model_macros.hpp.

◆ BACKEND_OPTION

#define BACKEND_OPTION	(	BACKEND_AND_VERSIONS,
		TAGS
	)	DUMMYARG(BACKEND_AND_VERSIONS,TAGS)

Definition at line 109 of file model_macros.hpp.

◆ BE_GROUP

#define BE_GROUP ( GROUP ) MODULE_BE_GROUP(GROUP,IS_MODEL)

Definition at line 99 of file model_macros.hpp.

◆ CLASSLOAD_NEEDED

#define CLASSLOAD_NEEDED ( ... ) DUMMYARG(__VA_ARGS__)

Definition at line 113 of file model_macros.hpp.

◆ CORE_DEFINEPARS

#define CORE_DEFINEPARS ( ... ) BOOST_PP_SEQ_FOR_EACH(DO_LINK, _, BOOST_PP_TUPLE_TO_SEQ((__VA_ARGS__)))

Define multiple model parameters.

Definition at line 325 of file model_macros.hpp.

◆ CORE_INTERPRET_AS_PARENT_FUNCTION

#define CORE_INTERPRET_AS_PARENT_FUNCTION ( FUNC ) INTERPRET_AS_X_FUNCTION_FULL(PARENT,FUNC,0)

Definition at line 425 of file model_macros.hpp.

◆ CORE_INTERPRET_AS_X_DEPENDENCY

#define CORE_INTERPRET_AS_X_DEPENDENCY	(	MODEL_X,
		DEP,
		TYPE
	)	CORE_DEPENDENCY(DEP, TYPE, MODEL, CAT(MODEL_X,_parameters), IS_MODEL) \

Add a dependency to an interpret-as-X function.

Definition at line 418 of file model_macros.hpp.

◆ CORE_INTERPRET_AS_X_FUNCTION

#define CORE_INTERPRET_AS_X_FUNCTION	(	MODEL_X,
		FUNC
	)	INTERPRET_AS_X_FUNCTION_FULL(MODEL_X,FUNC,1) \

Real declaration macro for INTERPRET_AS_X functions.

Definition at line 331 of file model_macros.hpp.

◆ CORE_MAP_TO_CAPABILITY

#define CORE_MAP_TO_CAPABILITY	(	PARAMETER,
		CAPABILITY
	)

Tells the core that the current parameter corresponds to the specified CAPABILITY, so that module functions can then draw upon them like any other capabilities.

Draws from CORE_START_CAPABILITY macro. So far we only allow parameters of type double (currently the parameter object cannot store anything else anyway). If we really want to allow integer or maybe complex parameters later we could extend some things in here.

Definition at line 237 of file model_macros.hpp.

◆ CORE_START_MODEL

#define CORE_START_MODEL

Piggybacks off the CORE_START_MODULE_COMMON macro, as we need all the same machinery.

Definition at line 189 of file model_macros.hpp.

◆ DECLARE_BACKEND_REQ

#define DECLARE_BACKEND_REQ	(	GROUP,
		REQUIREMENT,
		TAGS,
		TYPE,
		ARGS,
		IS_VARIABLE
	)	MODULE_BACKEND_REQ(MODEL, FUNCTION, GROUP, REQUIREMENT, TAGS, TYPE, ARGS, IS_VARIABLE, IS_MODEL)

Definition at line 100 of file model_macros.hpp.

◆ DECLARE_FUNCTION

#define DECLARE_FUNCTION	(	TYPE,
		CAN_MANAGE
	)	MODULE_DECLARE_FUNCTION(MODEL, FUNCTION, TYPE, CAN_MANAGE, IS_MODEL)

Definition at line 88 of file model_macros.hpp.

◆ DEFINEPAR

#define DEFINEPAR ( PARAMETER )

Value:

namespace Gambit                                                             \
  {                                                                            \
    namespace Models                                                           \
    {                                                                          \
      namespace MODEL                                                          \
      {                                                                        \
        /* Tell the functor holding the ModelParameters object to add the new  \
           parameter to its [parameter name, value] map. */                    \
        int CAT(added_,PARAMETER) =                                            \
         add_parameter(Functown::primary_parameters,STRINGIFY(PARAMETER));     \
      }                                                                        \
    }                                                                          \
  }                                                                            \

Macro to define parameter.

Does not create a corresponding CAPABILITY; use MAP_TO_CAPABILITY to do this after calling DEFINEPAR(S).

Definition at line 308 of file model_macros.hpp.

◆ DEFINEPARS

#define DEFINEPARS ( ... ) /* Do nothing */

Definition at line 80 of file model_macros.hpp.

◆ DEPENDENCY

#define DEPENDENCY	(	DEP,
		TYPE
	)	MODULE_DEPENDENCY(DEP, TYPE, MODEL, FUNCTION, IS_MODEL)

Definition at line 91 of file model_macros.hpp.

◆ DO_LINK

#define DO_LINK	(	r,
		data,
		elem
	)	DEFINEPAR(elem)

Definition at line 327 of file model_macros.hpp.

◆ FORCE_SAME_BACKEND

#define FORCE_SAME_BACKEND ( ... ) DUMMYARG(__VA_ARGS__)

Definition at line 112 of file model_macros.hpp.

◆ INTERPRET_AS_PARENT_DEPENDENCY

#define INTERPRET_AS_PARENT_DEPENDENCY	(	DEP,
		TYPE
	)	INTERPRET_AS_X_DEPENDENCY(PARENT, DEP, TYPE)

Wrappers to convert INTERPRET_AS_X macros to INTERPRET_AS_PARENT macros.

Definition at line 423 of file model_macros.hpp.

◆ INTERPRET_AS_PARENT_FUNCTION

#define INTERPRET_AS_PARENT_FUNCTION ( FUNC ) MODULE_INTERPRET_AS_X_FUNCTION(PARENT,FUNC)

Definition at line 83 of file model_macros.hpp.

◆ INTERPRET_AS_X_DEPENDENCY

#define INTERPRET_AS_X_DEPENDENCY	(	MODEL_X,
		DEP,
		TYPE
	)	MODULE_INTERPRET_AS_X_DEPENDENCY(MODEL_X, DEP, TYPE)

Definition at line 84 of file model_macros.hpp.

◆ INTERPRET_AS_X_FUNCTION

#define INTERPRET_AS_X_FUNCTION	(	MODEL_X,
		FUNC
	)	MODULE_INTERPRET_AS_X_FUNCTION(MODEL_X,FUNC)

Definition at line 82 of file model_macros.hpp.

◆ INTERPRET_AS_X_FUNCTION_FULL

#define INTERPRET_AS_X_FUNCTION_FULL	(	MODEL_X,
		FUNC,
		ADD_FRIEND
	)

Generic declaration macro for INTERPRET_AS_ functions.

Definition at line 335 of file model_macros.hpp.

◆ LONG_BACKEND_OPTION

#define LONG_BACKEND_OPTION	(	MODULE,
		CAPABILITY,
		FUNCTION,
		BACKEND_AND_VERSIONS,
		TAGS
	)	DUMMYARG(BACKEND_AND_VERSIONS,TAGS)

Definition at line 110 of file model_macros.hpp.

◆ LONG_DECLARE_BACKEND_REQ

#define LONG_DECLARE_BACKEND_REQ	(	MODULE,
		C,
		FUNCTION,
		GROUP,
		REQUIREMENT,
		TAGS,
		TYPE,
		ARGS,
		IS_VARIABLE
	)	MODULE_BACKEND_REQ(MODULE, FUNCTION, GROUP, REQUIREMENT, TAGS, TYPE, ARGS, IS_VARIABLE, IS_MODEL)

Definition at line 102 of file model_macros.hpp.

◆ LONG_DECLARE_FUNCTION

#define LONG_DECLARE_FUNCTION	(	MODULE,
		C,
		FUNCTION,
		TYPE,
		CAN_MANAGE
	)	MODULE_DECLARE_FUNCTION(MODULE, FUNCTION, TYPE, CAN_MANAGE, IS_MODEL)

Definition at line 89 of file model_macros.hpp.

◆ LONG_DEPENDENCY

#define LONG_DEPENDENCY	(	MODULE,
		FUNCTION,
		DEP,
		TYPE
	)	MODULE_DEPENDENCY(DEP, TYPE, MODEL, FUNCTION, IS_MODEL)

Definition at line 92 of file model_macros.hpp.

◆ LONG_START_CAPABILITY

#define LONG_START_CAPABILITY	(	MODULE,
		C
	)	MODULE_START_CAPABILITY(MODULE)

Definition at line 87 of file model_macros.hpp.

◆ MAKE_PRIMARY_MODEL_FUNCTOR

#define MAKE_PRIMARY_MODEL_FUNCTOR	(	FUNCTION,
		CAPABILITY,
		ORIGIN
	)

Value:

MAKE_PRIMARY_MODEL_FUNCTOR_MAIN(FUNCTION,CAPABILITY,ORIGIN) \

MAKE_PRIMARY_MODEL_FUNCTOR_SUPP(FUNCTION)

CAPABILITY

#define CAPABILITY

Definition: ColliderBit_Higgs_rollcall.hpp:112

MAKE_PRIMARY_MODEL_FUNCTOR_MAIN

#define MAKE_PRIMARY_MODEL_FUNCTOR_MAIN(FUNCTION, CAPABILITY, ORIGIN)

Macros to create and register primary model functors.

Definition: model_macros.hpp:445

FUNCTION

#define FUNCTION

Definition: ColliderBit_Higgs_rollcall.hpp:114

Definition at line 119 of file model_macros.hpp.

◆ MAKE_PRIMARY_MODEL_FUNCTOR_MAIN

#define MAKE_PRIMARY_MODEL_FUNCTOR_MAIN	(	FUNCTION,
		CAPABILITY,
		ORIGIN
	)

Value:

/* Create the function wrapper object (functor) */                           \
  namespace Functown                                                           \
  {                                                                            \
    primary_model_functor FUNCTION                                             \
     (&ORIGIN::FUNCTION, STRINGIFY(FUNCTION), STRINGIFY(CAPABILITY),           \
     "ModelParameters", STRINGIFY(ORIGIN), ModelDB());                         \
  }                                                                            \

Macros to create and register primary model functors.

We need this extra wrapper in order to define these special functors and add them to the Core's primary model functor list (no other functors allowed here).Main version of MAKE_FUNCTOR modified to build primary_parameters functors.

Definition at line 445 of file model_macros.hpp.

◆ MAKE_PRIMARY_MODEL_FUNCTOR_SUPP

#define MAKE_PRIMARY_MODEL_FUNCTOR_SUPP ( FUNCTION )

Value:

/* Register the functor with the Core. */ \

int CAT(coreg_,FUNCTION) = register_model_functor_core(Functown::FUNCTION); \

Gambit::register_model_functor_core

int register_model_functor_core(primary_model_functor &)

Register a model functor with the Core.

Definition: ini_functions.cpp:51

FUNCTION

#define FUNCTION

Definition: ColliderBit_Higgs_rollcall.hpp:114

CAT

#define CAT(X, Y)

Concatenate macro arguments for 2-7 arguments.

Definition: cats.hpp:22

Supplementary version of MAKE_FUNCTOR modded for primary_parameters functors.

Definition at line 455 of file model_macros.hpp.

◆ MAP_TO_CAPABILITY

#define MAP_TO_CAPABILITY	(	PARAMETER,
		CAPABILITY
	)	/* Do nothing */

Definition at line 81 of file model_macros.hpp.

◆ MODEL_CONDITIONAL_DEPENDENCY

#define MODEL_CONDITIONAL_DEPENDENCY	(	DEP,
		TYPE,
		...
	)	MODULE_DEPENDENCY(DEP, TYPE, MODEL, FUNCTION, IS_MODEL)

Definition at line 108 of file model_macros.hpp.

◆ MODEL_GROUP

#define MODEL_GROUP	(	GROUPNAME,
		GROUP
	)	DUMMYARG(GROUPNAME, GROUP)

Definition at line 97 of file model_macros.hpp.

◆ MODEL_NAMESPACE

void MODEL_NAMESPACE Gambit::Models::MODEL

Macro to get to model namespace easily.

Interpret-as-friend (mA parameterisations to primary parameterisations)

Definition at line 430 of file model_macros.hpp.

◆ MODULE_INTERPRET_AS_X_DEPENDENCY

#define MODULE_INTERPRET_AS_X_DEPENDENCY	(	MODEL_X,
		DEP,
		TYPE
	)	MODULE_DEPENDENCY(DEP, TYPE, MODEL, CAT(MODEL_X,_parameters), IS_MODEL)

"In module" version of the INTERPRET_AS_X_DEPENDENCY macro

Definition at line 183 of file model_macros.hpp.

◆ MODULE_INTERPRET_AS_X_FUNCTION

#define MODULE_INTERPRET_AS_X_FUNCTION	(	MODEL_X,
		FUNC
	)

Value:

namespace Gambit                                                             \
  {                                                                            \
    namespace Models                                                           \
    {                                                                          \
      namespace MODEL                                                          \
      {                                                                        \
        /* Declare the user-defined function as defined elsewhere */           \
        extern void FUNC (const ModelParameters&, ModelParameters&);           \
                                                                               \
        /* Let the module source know that this functor is declared*/          \
        namespace Functown { extern module_functor<ModelParameters>            \
                                            CAT(MODEL_X,_parameters); }        \
                                                                               \
        namespace Pipes                                                        \
        {                                                                      \
          namespace CAT(MODEL_X,_parameters)                                   \
          {                                                                    \
            /* Declare the parameters safe-pointer map as external. */         \
            extern std::map<str, safe_ptr<double> > Param;                     \
            /* Declare the safe-pointer to the models vector as external. */   \
            extern safe_ptr< std::vector<str> > Models;                        \
            /* Declare the safe pointer to the run options as external. */     \
            extern safe_ptr<Options> runOptions;                               \
          }                                                                    \
        }                                                                      \
      }                                                                        \
    }                                                                          \
  }                                                                            \

"In module" version of the INTERPRET_AS_X_FUNCTION macro

Definition at line 152 of file model_macros.hpp.

◆ MODULE_START_MODEL

#define MODULE_START_MODEL

Value:

IF_TOKEN_UNDEFINED(MODEL,FAIL("You must define MODEL before calling "        \
   "START_MODEL."))                                                            \
  /*_Pragma("message declaring model...") \
  _Pragma( STRINGIFY(CAT("message Forward declaring model: ",MODEL)) )      */ \
  namespace Gambit                                                             \
  {                                                                            \
   namespace Models                                                            \
   {                                                                           \
    namespace MODEL                                                            \
    {                                                                          \
      /* Module errors */                                                      \
      error& CAT(MODEL,_error)();                                              \
      /* Module warnings */                                                    \
      warning& CAT(MODEL,_warning)();                                          \
    }                                                                          \
   }                                                                           \
  }                                                                            \

"Rollcall" macros.

These are lifted straight from module_macros_incore.hpp but are modified here and there to suit the role of models. "In module" version of the START_MODEL macro

Definition at line 132 of file model_macros.hpp.

◆ NEEDS_MANAGER

#define NEEDS_MANAGER ( ... ) MODULE_NEEDS_MANAGER_REDIRECT(__VA_ARGS__)

Definition at line 93 of file model_macros.hpp.

◆ START_CAPABILITY

#define START_CAPABILITY MODULE_START_CAPABILITY(MODEL)

Definition at line 86 of file model_macros.hpp.

◆ START_CONDITIONAL_DEPENDENCY

#define START_CONDITIONAL_DEPENDENCY ( TYPE ) MODULE_DEPENDENCY(CONDITIONAL_DEPENDENCY, TYPE, MODEL, FUNCTION, IS_MODEL)

Definition at line 105 of file model_macros.hpp.

◆ START_MODEL

#define START_MODEL MODULE_START_MODEL

Definition at line 79 of file model_macros.hpp.

◆ USE_MODEL_PIPE

#define USE_MODEL_PIPE ( MODEL_X ) using namespace MODEL_NAMESPACE::Pipes::CAT(MODEL_X,_parameters); \

Macro to easily get the Pipes for an INTERPRET_AS_X function, for retrieving dependencies.

Definition at line 434 of file model_macros.hpp.

Referenced by Gambit::MSSM_mA_to_MSSM_mhud().