class Gambit::backend_functor_common

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

#include <functors.hpp>

Protected Types

	Name
typedef PTR_TYPE	funcPtrType 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.
void	updatePointer(funcPtrType inputFunction) Update the internal function pointer wrapped by the functor.
funcPtrType	handoutFunctionPointer() 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 str	version() const Getter for the version of the wrapped function’s backend.
virtual str	safe_version() const Getter for the ‘safe’ incarnation of the version of the wrapped function’s backend.

Protected Functions

	Name
virtual void	setInUse(bool flag) Set the inUse flag.

Protected Attributes

	Name
funcPtrType	myFunction Internal storage of function pointer.
int	myLogTag Integer LogTag, for tagging log messages.
str	myVersion Internal storage of the version of the backend to which the function belongs.
str	mySafeVersion Internal storage of the ‘safe’ version of the version (for use in namespaces, variable names, etc).
bool	inUse 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 double	getRuntimeAverage()
virtual double	getInvalidationRate()
virtual void	setFadeRate(double )
virtual void	notifyOfInvalidation(const str & )
virtual void	reset()
	functor(str func_name, str func_capability, str result_type, str origin_name, Models::ModelFunctorClaw & claw) Constructor.
virtual	~functor() Destructor.
virtual void	calculate() Virtual calculate(); needs to be redefined in daughters.
virtual void	reset_and_calculate() Reset-then-recalculate method.
void	setStatus(FunctorStatus stat) Setter for status.
void	setPurpose(str purpose) Setter for purpose (relevant only for next-to-output functors)
void	setVertexID(int ID) Setter for vertex ID (used in printer system)
void	setTimingVertexID(int ID) Set ID for timing ‘vertex’ (used in printer system)
str	name() const Getter for the wrapped function’s name.
str	capability() const Getter for the wrapped function’s reported capability.
str	type() const Getter for the wrapped function’s reported return type.
str	origin() const Getter for the wrapped function’s origin (module or backend name)
FunctorStatus	status() const Getter for the functors current status.
bool	isAvailable() const Checks whether the functor is available (or even already activated)
bool	isActive() const Checks whether the functor is active.
bool	isDisabled() const Checks whether the functor is disabled (discriminant is negative)
bool	isEnabled() const Checks whether the functor is enabled (discriminant is non negative)
sspair	quantity() const Getter for the overall quantity provided by the wrapped function (capability-type pair)
str	purpose() const Getter for purpose (relevant for output nodes, aka helper structures for the dep. resolution)
str	citationKey() const Getter for the citation key.
int	vertexID() const Getter for vertex ID.
int	timingVertexID() const Getter for timing vertex ID.
str	label() const Getter for string label.
str	timingLabel() const Getter for the printer timing label.
virtual bool	requiresPrinting() const Getter indicating if the wrapped function’s result should to be printed.
virtual bool	requiresTimingPrinting() const Getter indicating if the timing data for this function’s execution should be printed.
virtual void	setPrintRequirement(bool flag) Setter for indicating if the wrapped function’s result should to be printed.
virtual void	setTimingPrintRequirement(bool flag) Setter for indicating if the timing data for this function’s execution should be printed.
virtual void	setNestedList(std::vector< functor * > & ) Set the ordered list of pointers to other functors that should run nested in a loop managed by this one.
virtual void	setIteration(long long ) Set the iteration number in a loop in which this functor runs.
virtual bool	canBeLoopManager() Getter for revealing whether this is permitted to be a manager functor.
virtual bool	needsLoopManager() Getter for revealing whether this functor needs a loop manager.
virtual str	loopManagerCapability() Getter for revealing the required capability of the wrapped function’s loop manager.
virtual str	loopManagerType() Getter for revealing the required type of the wrapped function’s loop manager.
virtual str	loopManagerName() Getter for revealing the name of the wrapped function’s assigned loop manager.
virtual str	loopManagerOrigin() Getter for revealing the module of the wrapped function’s assigned loop manager.
virtual void	breakLoop() 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 void	resolveDependency(functor * ) Resolve a dependency using a pointer to another functor object.
virtual void	resolveLoopManager(functor * ) Set this functor’s loop manager (if it has one)
virtual void	resolveBackendReq(functor * ) Resolve a backend requirement using a pointer to another functor object.
virtual void	notifyOfModel(str ) Notify the functor that a certain model is being scanned, so that it can activate itself accordingly.
virtual void	notifyOfDependee(functor * ) Notify the functor that it is being used to fill a dependency of another functor.
virtual void	notifyOfBackends(std::map< str, std::set< str > > ) Indicate to the functor which backends are actually loaded and working.
virtual void	print(Printers::BasePrinter * printer, const int pointID, int thread_num) Printer function.
virtual void	print(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.
void	notifyOfIniOptions(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).
void	notifyOfSubCaps(const str & subcap_string) Notify the functor about a string in YAML that contains the sub-capability information (for use in standalones)
void	notifyOfSubCaps(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.
bool	allModelsAllowed() Test whether the functor is allowed to be used with all models.
bool	modelAllowed(str model) Test whether the functor is always allowed (either explicitly or implicitly) to be used with a given model.
bool	modelExplicitlyAllowed(str model) Test whether the functor is explictly always allowed to be used with a given model.
void	setAllowedModel(str model) Add a model to the internal list of models for which this functor is allowed to be used.
bool	modelComboAllowed(std::set< str > combo) Test whether the functor is allowed (either explicitly or implicitly) to be used with a given combination of models.
bool	modelComboExplicitlyAllowed(std::set< str > combo) Test whether the functor has been explictly allowed to be used with a given combination of models.
void	setModelGroup(str group, str contents) Add a model group definition to the internal list of model groups.
void	setAllowedModelGroupCombo(str groups) Add a combination of model groups to the internal list of combinations for which this functor is allowed to be used.
void	addMatchedObservable(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.
void	addMatchedModuleRule(const DRes::ModuleRule * r) Add a module rule to the set of those against which this functor has been tested and found to match.
void	addMatchedBackendRule(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 void	reset(int ) Reset functor for one thread only.
void	failBigTime(str method) Attempt to retrieve a dependency or model parameter that has not been resolved.
bool	allowed_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.
bool	in_allowed_combo(str model) Check that a model is actually part of a combination that is allowed to be used with this functor.
bool	contains_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.
bool	has_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.
str	find_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
str	myName Internal storage of the function name.
str	myCapability Internal storage of exactly what the function calculates.
str	myType Internal storage of the type of what the function calculates.
str	myOrigin Internal storage of the name of the module or backend to which the function belongs.
str	myPurpose Purpose of the function (relevant for output and next-to-output functors)
str	myCitationKey Citation key: BibTex key of the reference.
const Models::ModelFunctorClaw *	myClaw Bound model functor claw, for checking relationships between models.
const str	myLabel String label, used to label functor results for printer system.
const str	myTimingLabel String label, used to label functor timing data for printer system.
FunctorStatus	myStatus Status:
int	myVertexID Internal storage of the vertex ID number used by the printer system to identify functors.
int	myTimingVertexID ID assigned by printers to the timing data output stream.
bool	verbose Debug flag.
Options	myOptions Internal storage of function options, as a YAML node.
Options	mySubCaps 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

class Gambit::backend_functor_common #

Protected Types #

Public Functions #

Protected Functions #

Protected Attributes #

Additional inherited members #

Detailed Description #

Protected Types Documentation #

typedef funcPtrType #

Public Functions Documentation #

function backend_functor_common #

function ~backend_functor_common #

function updatePointer #

function handoutFunctionPointer #

function inUsePtr #

function version #

function safe_version #

Protected Functions Documentation #

function setInUse #

Protected Attributes Documentation #

variable myFunction #

variable myLogTag #

variable myVersion #

variable mySafeVersion #

variable inUse #