#include "steam/mobject/output-mapping.hpp"

Description

template<class DEF>
class steam::mobject::OutputMapping< DEF >

OutputMapping is a facility to resolve output designations.

The session/model uses preliminary or partial output specifications, which are to be resolved to an actual system output while building and preparing a render network for operation (playback/rendering). For a given specification, resolution to the desired target spec may be derived by querying the OutputMapping. Here, the kind of the target specification is defined through the type parameter.

definition of specific mapping behaviour

This is an generic map-like container, acting as Interface to be used in the signature of API functions either providing or requiring a Mapping. For each distinct usage situation, an instantiation of this template should be created, providing a definition context as template parameter. Instances of this concrete mapping type may then be default constructed and copied freely. The definition context is supposed to provide

a functor DEF::output usable as function pipe-ID –> Target
the concrete output-functor also defines the concrete Target type, which will be returned when accessing the OutputMapping
a function DEF::buildQuery (sourcePipeID,seqNr) yielding a (defaults) query to be issued in case of accessing a non existent mapping
Template Parameters

DEF static (compile-time) definition/configuration context

Definition at line 130 of file output-mapping.hpp.

Public Types
using	Target = typename Setup::Target

Public Member Functions
void	clear ()

bool	contains (PId mapping4sourcePipeID)

bool	contains (PPipe sourcePipe)

bool	empty () const

Resolver	operator[] (PId sourcePipeID)
	standard map-style access to an OutputMapping. More...

Resolver	operator[] (PPipe const &pipe)
	similar to the standard map-style access, but accepts a source pipe object instead of just a pipe-ID

Resolver	operator[] (Query< asset::Pipe > query4pipe)
	determine an OutputMapping by resolving a complex query, instead of just picking a mapped pipe (which is the default usage). More...

size_t	size () const

Classes
class	Resolver

Private Types
using	PId = asset::ID< asset::Pipe >

using	PPipe = asset::PPipe

typedef _def< DEF >	Setup

Private Member Functions
Resolver	buildResolutionWrapper (HashVal tableSlot)

Target	resolveTarget (PId mappedPipeID)

Private Attributes
std::map< HashVal, HashVal >	table_

Member Function Documentation

◆ operator[]() [1/2]

OutputMapping< DEF >::Resolver operator[] ( PId sourcePipeID )

inline

standard map-style access to an OutputMapping.

For the given source pipe-ID the mapped target pipe-ID is fetched and then handed over to the configured DEF::output functor, which is assumed to calculate or retrieve the actual result object.

default mappings: whenever accessing an yet non-existent mapping, a query is issued behind the scenes to establish a suitable default mapping. The actual query is built from a query template by the DEF::buildQuery function and thus can be configured for the concrete usage situation of the mapping.

Warning: depending on the actually configured defaults query, there might be no solution, in which case an unconnected marker is retrieved and stored. Thus the yielded Resolver should be checked, if in doubt.

Definition at line 329 of file output-mapping.hpp.

◆ operator[]() [2/2]

OutputMapping< DEF >::Resolver operator[] ( Query< asset::Pipe > query4pipe )

inline

determine an OutputMapping by resolving a complex query, instead of just picking a mapped pipe (which is the default usage).

Accessing the OutputMapping this way by query enables all kinds of extended usages: It suffices that the given query somehow yields a Pipe, which then is considered the mapped result and handed over to the DEF::output functor for resolution to a result object to be returned.

Query for the Nth default instance: OutputMapping provides a special behaviour for retrieving "the Nth default pipe". The rationale being the request for connection to the Nth bus of a given kind, like e.g. the 3rd audio subgroup or the 2nd video master. This special behaviour is triggered by the predicate "ord(##)" in the query. The remainder of the query is supposed to designate a default in this case, rather then querying directly for the result of the mapping. Thus this remainder of the query is used to retrieve a source pipe, which then is treated as if accessing a non-existent mapping: a suitable default solution for this mapping is retrieved, but in this special case, we append the given sequence number to the ID of the retrieved pipe, i.e. we get the Nth (identical) solution to the aforementioned query for a default pipe.

Note: the mapped result is remembered within this mapping. Further invocations with the same query will just fetch this stored pipe-ID and hand it to the functor, without resolving the query again. You might want to remove this specific mapping in order to force re-evaluation of the query.

Parameters

Query for a pipe, which is handed over as-is to the rules engine.

Warning: depending on the actual query, there might be no solution, in which case an unconnected marker is retrieved and stored. Thus the yielded Resolver should be checked, if in doubt.

Definition at line 384 of file output-mapping.hpp.

References Struct::retrieve.

Inheritance diagram for OutputMapping< DEF >: