class Gambit::backend_functor_common

Backend functor class for functions with result type TYPE and argumentlist ARGS. More…

#include <functors.hpp>

Inherits from Gambit::functor

Protected Types

Name
typedef PTR_TYPEfuncPtrType
Type of the function pointer being encapsulated.

Public Functions

Name
backend_functor_common(funcPtrType inputFunction, str func_name, str func_capability, str result_type, str origin_name, str origin_version, str origin_safe_version, str citation_key, Models::ModelFunctorClaw & claw)
Constructor.
virtual~backend_functor_common()
Destructor.
voidupdatePointer(funcPtrType inputFunction)
Update the internal function pointer wrapped by the functor.
funcPtrTypehandoutFunctionPointer()
Hand out the internal function pointer wrapped by the functor.
safe_ptr< bool >inUsePtr()
Hand out a safe pointer to this backend functor’s inUse flag.
virtual strversion() const
Getter for the version of the wrapped function’s backend.
virtual strsafe_version() const
Getter for the ‘safe’ incarnation of the version of the wrapped function’s backend.

Protected Functions

Name
virtual voidsetInUse(bool flag)
Set the inUse flag.

Protected Attributes

Name
funcPtrTypemyFunction
Internal storage of function pointer.
intmyLogTag
Integer LogTag, for tagging log messages.
strmyVersion
Internal storage of the version of the backend to which the function belongs.
strmySafeVersion
Internal storage of the ‘safe’ version of the version (for use in namespaces, variable names, etc).
boolinUse
Flag indicating if this backend functor is actually in use in a given scan.

Additional inherited members

Public Functions inherited from Gambit::functor

Name
virtual doublegetRuntimeAverage()
virtual doublegetInvalidationRate()
virtual voidsetFadeRate(double )
virtual voidnotifyOfInvalidation(const str & )
virtual voidreset()
functor(str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw)
Constructor.
virtual~functor()
Destructor.
virtual voidcalculate()
Virtual calculate(); needs to be redefined in daughters.
virtual voidreset_and_calculate()
Reset-then-recalculate method.
voidsetStatus(FunctorStatus stat)
Setter for status.
voidsetPurpose(str purpose)
Setter for purpose (relevant only for next-to-output functors)
voidsetVertexID(int ID)
Setter for vertex ID (used in printer system)
voidsetTimingVertexID(int ID)
Set ID for timing ‘vertex’ (used in printer system)
strname() const
Getter for the wrapped function’s name.
strcapability() const
Getter for the wrapped function’s reported capability.
strtype() const
Getter for the wrapped function’s reported return type.
strorigin() const
Getter for the wrapped function’s origin (module or backend name)
FunctorStatusstatus() const
Getter for the functors current status.
boolisAvailable() const
Checks whether the functor is available (or even already activated)
boolisActive() const
Checks whether the functor is active.
boolisDisabled() const
Checks whether the functor is disabled (discriminant is negative)
boolisEnabled() const
Checks whether the functor is enabled (discriminant is non negative)
sspairquantity() const
Getter for the overall quantity provided by the wrapped function (capability-type pair)
strpurpose() const
Getter for purpose (relevant for output nodes, aka helper structures for the dep. resolution)
strcitationKey() const
Getter for the citation key.
intvertexID() const
Getter for vertex ID.
inttimingVertexID() const
Getter for timing vertex ID.
strlabel() const
Getter for string label.
strtimingLabel() const
Getter for the printer timing label.
virtual boolrequiresPrinting() const
Getter indicating if the wrapped function’s result should to be printed.
virtual boolrequiresTimingPrinting() const
Getter indicating if the timing data for this function’s execution should be printed.
virtual voidsetPrintRequirement(bool flag)
Setter for indicating if the wrapped function’s result should to be printed.
virtual voidsetTimingPrintRequirement(bool flag)
Setter for indicating if the timing data for this function’s execution should be printed.
virtual voidsetNestedList(std::vector< functor * > & )
Set the ordered list of pointers to other functors that should run nested in a loop managed by this one.
virtual voidsetIteration(long long )
Set the iteration number in a loop in which this functor runs.
virtual boolcanBeLoopManager()
Getter for revealing whether this is permitted to be a manager functor.
virtual boolneedsLoopManager()
Getter for revealing whether this functor needs a loop manager.
virtual strloopManagerCapability()
Getter for revealing the required capability of the wrapped function’s loop manager.
virtual strloopManagerType()
Getter for revealing the required type of the wrapped function’s loop manager.
virtual strloopManagerName()
Getter for revealing the name of the wrapped function’s assigned loop manager.
virtual strloopManagerOrigin()
Getter for revealing the module of the wrapped function’s assigned loop manager.
virtual voidbreakLoop()
Tell the functor that the loop it manages should break now.
virtual std::set< sspair >dependencies()
Getter for listing currently activated dependencies.
virtual std::set< sspair >backendclassloading()
Getter for listing backends that require class loading.
virtual std::set< str >backendgroups()
Getter for listing backend requirement groups.
virtual std::set< sspair >backendreqs()
Getter for listing all backend requirements.
virtual std::set< sspair >backendreqs(str )
Getter for listing backend requirements from a specific group.
virtual std::set< sspair >backendspermitted(sspair )
Getter for listing permitted backends.
virtual std::set< str >backendreq_tags(sspair )
Getter for listing tags associated with backend requirements.
virtual std::set< sspair >forcematchingbackend(str )
Getter for listing backend requirements that must be resolved from the same backend.
virtual std::set< sspair >backend_conditional_dependencies(str , str , str , str )
Getter for listing backend-specific conditional dependencies (4-string version)
virtual std::set< sspair >backend_conditional_dependencies(str req, str type, str be)
Getter for backend-specific conditional dependencies (3-string version)
virtual std::set< sspair >backend_conditional_dependencies(functor * be_functor)
Getter for backend-specific conditional dependencies (backend functor pointer version)
virtual std::set< sspair >model_conditional_dependencies(str model)
Getter for listing model-specific conditional dependencies (matches also on parents and friends)
virtual std::set< sspair >model_conditional_dependencies_exact(str model)
Getter for listing model-specific conditional dependencies (matches on the exact model)
virtual std::set< sspair >model_conditional_backend_reqs(str model)
Getter for listing model-specific conditional backend requirements (matches also on parents and friends)
virtual std::set< sspair >model_conditional_backend_reqs_exact(str model)
Getter for listing model-specific conditional backend requirements (matches on the exact model)
virtual voidresolveDependency(functor * )
Resolve a dependency using a pointer to another functor object.
virtual voidresolveLoopManager(functor * )
Set this functor’s loop manager (if it has one)
virtual voidresolveBackendReq(functor * )
Resolve a backend requirement using a pointer to another functor object.
virtual voidnotifyOfModel(str )
Notify the functor that a certain model is being scanned, so that it can activate itself accordingly.
virtual voidnotifyOfDependee(functor * )
Notify the functor that it is being used to fill a dependency of another functor.
virtual voidnotifyOfBackends(std::map< str, std::set< str > > )
Indicate to the functor which backends are actually loaded and working.
virtual voidprint(Printers::BasePrinter * printer, const int pointID, int thread_num)
Printer function.
virtual voidprint(Printers::BasePrinter * printer, const int pointID)
Printer function (no-thread-index short-circuit)
virtual invalid_point_exception *retrieve_invalid_point_exception()
Retrieve the previously saved exception generated when this functor invalidated the current point in model space.
voidnotifyOfIniOptions(const Options & opt)
template <typename TYPE >
void
setOption(const str & key, const TYPE val)
Set an option for the functor directly (for use in standalone executables).
safe_ptr< Options >getOptions()
Return a safe pointer to the options that this functor is supposed to run with (e.g. from the ini file).
voidnotifyOfSubCaps(const str & subcap_string)
Notify the functor about a string in YAML that contains the sub-capability information (for use in standalones)
voidnotifyOfSubCaps(const Options & subcaps)
Notify the functor about an instance of the options class that contains sub-capability information.
template <typename TYPE >
void
setSubCap(const str & key, const TYPE val)
Set a sub-capability (subcap)for the functor directly (for use in standalone executables).
safe_ptr< Options >getSubCaps()
Return a safe pointer to the subcaps that this functor realises it is supposed to facilitate downstream calculation of.
safe_ptr< std::set< sspair > >getDependees()
Return a safe pointer to the vector of all capability,type pairs of functors arranged downstream of this one in the dependency tree.
const std::set< str > &getAllowedModels()
Getter for listing allowed models.
const std::set< str > &getConditionalModels()
Getter for listing conditional models.
const std::map< str, std::set< str > > &getModelGroups()
Getter for map of model groups and the set of models in each group.
boolallModelsAllowed()
Test whether the functor is allowed to be used with all models.
boolmodelAllowed(str model)
Test whether the functor is always allowed (either explicitly or implicitly) to be used with a given model.
boolmodelExplicitlyAllowed(str model)
Test whether the functor is explictly always allowed to be used with a given model.
voidsetAllowedModel(str model)
Add a model to the internal list of models for which this functor is allowed to be used.
boolmodelComboAllowed(std::set< str > combo)
Test whether the functor is allowed (either explicitly or implicitly) to be used with a given combination of models.
boolmodelComboExplicitlyAllowed(std::set< str > combo)
Test whether the functor has been explictly allowed to be used with a given combination of models.
voidsetModelGroup(str group, str contents)
Add a model group definition to the internal list of model groups.
voidsetAllowedModelGroupCombo(str groups)
Add a combination of model groups to the internal list of combinations for which this functor is allowed to be used.
voidaddMatchedObservable(const DRes::Observable * obs)
Add an observable to the set of those that this functor matches.
const std::set< const DRes::Observable * > &getMatchedObservables()
Retrieve the set of observables that this functor matches.
voidaddMatchedModuleRule(const DRes::ModuleRule * r)
Add a module rule to the set of those against which this functor has been tested and found to match.
voidaddMatchedBackendRule(const DRes::BackendRule * r)
Add a backend rule to the set of those against which this functor has been tested and found to match.
const std::set< const DRes::ModuleRule * > &getMatchedModuleRules()
Retrieve the set of module rules against which this functor has been tested and found to match.
const std::set< const DRes::BackendRule * > &getMatchedBackendRules()
Retrieve the set of backend rules against which this functor has been tested and found to match.
template <class RuleT >
const std::set< RuleT * > &
getMatchedRules()
Retrieve matched rules by type.
const std::set< const DRes::ModuleRule * > &getMatchedRules()

Protected Functions inherited from Gambit::functor

Name
virtual voidreset(int )
Reset functor for one thread only.
voidfailBigTime(str method)
Attempt to retrieve a dependency or model parameter that has not been resolved.
boolallowed_parent_or_friend_exists(str model)
Test if there is a model in the functor’s allowedModels list as which this model can be interpreted.
boolin_allowed_combo(str model)
Check that a model is actually part of a combination that is allowed to be used with this functor.
boolcontains_anything_interpretable_as_member_of(std::set< str > combo, str group)
Test whether any of the entries in a given model group is a valid interpretation of any members in a given combination.
boolhas_common_elements(std::set< str > combo, str group)
Work out whether a given combination of models and a model group have any elements in common.
strfind_friend_or_parent_model_in_map(str model, std::map< str, std::set< sspair > > karta)
Try to find a parent or friend model in some user-supplied map from models to sspair vectors.

Protected Attributes inherited from Gambit::functor

Name
strmyName
Internal storage of the function name.
strmyCapability
Internal storage of exactly what the function calculates.
strmyType
Internal storage of the type of what the function calculates.
strmyOrigin
Internal storage of the name of the module or backend to which the function belongs.
strmyPurpose
Purpose of the function (relevant for output and next-to-output functors)
strmyCitationKey
Citation key: BibTex key of the reference.
const Models::ModelFunctorClaw *myClaw
Bound model functor claw, for checking relationships between models.
const strmyLabel
String label, used to label functor results for printer system.
const strmyTimingLabel
String label, used to label functor timing data for printer system.
FunctorStatusmyStatus
Status:
intmyVertexID
Internal storage of the vertex ID number used by the printer system to identify functors.
intmyTimingVertexID
ID assigned by printers to the timing data output stream.
boolverbose
Debug flag.
OptionsmyOptions
Internal storage of function options, as a YAML node.
OptionsmySubCaps
Internal storage of function sub-capabilities, as a YAML node.
std::set< sspair >myDependees
List of all capability,type pairs of functors downstream of this one in the dependency tree.
std::set< str >allowedModels
List of allowed models.
std::set< str >conditionalModels
List of conditional models.
std::set< std::set< str > >allowedGroupCombos
List of allowed model group combinations.
std::map< str, std::set< str > >modelGroups
Map from model group names to group contents.
std::set< const DRes::Observable * >matched_observables
The set of observables that this functor matches.
std::set< const DRes::ModuleRule * >matched_module_rules
Set of module rules against which this functor has been tested and found to match.
std::set< const DRes::BackendRule * >matched_backend_rules
Set of backend rules against which this functor has been tested and found to match.

Detailed Description

template <typename PTR_TYPE ,
typename TYPE ,
typename... ARGS>
class Gambit::backend_functor_common;

Backend functor class for functions with result type TYPE and argumentlist ARGS.

Protected Types Documentation

typedef funcPtrType

typedef PTR_TYPE Gambit::backend_functor_common< PTR_TYPE, TYPE, ARGS >::funcPtrType;

Type of the function pointer being encapsulated.

Public Functions Documentation

function backend_functor_common

backend_functor_common(
    funcPtrType inputFunction,
    str func_name,
    str func_capability,
    str result_type,
    str origin_name,
    str origin_version,
    str origin_safe_version,
    str citation_key,
    Models::ModelFunctorClaw & claw
)

Constructor.

function ~backend_functor_common

inline virtual ~backend_functor_common()

Destructor.

function updatePointer

void updatePointer(
    funcPtrType inputFunction
)

Update the internal function pointer wrapped by the functor.

function handoutFunctionPointer

funcPtrType handoutFunctionPointer()

Hand out the internal function pointer wrapped by the functor.

function inUsePtr

safe_ptr< bool > inUsePtr()

Hand out a safe pointer to this backend functor’s inUse flag.

function version

virtual str version() const

Getter for the version of the wrapped function’s backend.

Reimplements: Gambit::functor::version

function safe_version

virtual str safe_version() const

Getter for the ‘safe’ incarnation of the version of the wrapped function’s backend.

Reimplements: Gambit::functor::safe_version

Protected Functions Documentation

function setInUse

virtual void setInUse(
    bool flag
)

Set the inUse flag.

Reimplements: Gambit::functor::setInUse

Protected Attributes Documentation

variable myFunction

funcPtrType myFunction;

Internal storage of function pointer.

variable myLogTag

int myLogTag;

Integer LogTag, for tagging log messages.

variable myVersion

str myVersion;

Internal storage of the version of the backend to which the function belongs.

variable mySafeVersion

str mySafeVersion;

Internal storage of the ‘safe’ version of the version (for use in namespaces, variable names, etc).

variable inUse

bool inUse;

Flag indicating if this backend functor is actually in use in a given scan.


Updated on 2024-07-18 at 13:53:30 +0000