template<class Class>
aes70::device::OcaGrouper class

Template parameters
Class - Class to wrap.

Contents

This class template detects the methods and events defined for the class OcaGrouper in the AES70 specification and exposes them through AES70. Note that all AES70 methods and event handlers need to be public in order to be detected.

Detects the following symbols with the corresponding detector classes:

Detects the following event handlers:

Detects the following event handlers for property changes (of type aes70::property_change_event ):

From the AES70 standard:

Concept A grouper is an object responsible for aggregating property values. An actuator grouper allows control of many actuator objects from a single input value; a sensor grouper allows observing many sensor objects via a single output value. Actuator groupers are described below; sensor groupers are TBD. In a working media system, many actuator objects (we will call them citizens) will be members of multiple groups. For example, in a multiway stereo sound reinforcement system, the left woofer power amplifier might be controlled by a master gain group, a left-side gain group, and a woofer gain group. To manage the interactions of these multiple memberships, we need a single entity that manages all three of these groups, anticipating the interactions and taking appropriate action. An actuator grouper is such an entity. The grouper:

  • Registers all the groups and all the citizens.
  • Remembers which citizens belong to which groups.
  • Computes new property values when group settings change.
  • Manages overrange and underrange conditions proactively, so that citizens are never asked to assume out of range values. For any given grouper instance, all of its citizens will all be of the same class. Applications may have a number of grouper instances, one for each citizen class – an OcaGain grouper, an OcaFrequency grouper, etc. For controlling each group, the grouper creates a proxy object of the same class as its citizens, so that the same controller logic can be used for either a group or an individual worker. It may be helpful to visualize a grouper as a matrix whose rows are groups, columns are citizens, and each cell contains information relating to the membership of the citizen in the group. This information is called the citizen's enrollment in the group. Mechanism Each Grouper is an instance of this class (OcaGrouper). A group is a collection of citizens. A citizen that belongs to a group is called a member of that group. There is a many-to-many relationship between groups and citizens – any citizen can be a member of any number of groups. The purpose of the Grouper is to contain the set of groups and the set of citizens, to remember which citizens belong to which groups, and to compute new aggregate values when settings or readings change. The Grouper itself does not provide direct access to parameter data values. That access is provided by group proxies or by peer to peer mastering – see below. It is useful to think of a Grouper as a matrix in which groups are rows and citizens are columns. A cell of the matrix is nonempty whenever its column (=citizen) belongs to its row (=group). Such a cell is called an enrollment. Classes of Grouped Objects Group members can be actuator or sensor objects. A group whose members are actuators is called an actuator group. A group whose members are sensors is called a sensor group. All the citizens of a given Grouper must be of the same worker class (sounds communistic, doesn't it :) called the citizen class. Typically an application will have multiple Groupers, each one supporting a different citizen class. Adding Groups New groups can be added to the Grouper at any time, using OcaGrouper's AddGroup method. Group Proxies; Peer to Peer Mastering Depending on the setting of its mode property, a grouper may be in master-slave mode or peer to peer mode. In master-slave mode, each time a caller adds a group to a Grouper instance, the Grouper instance creates an object known as a group proxy. Thus, there is one group proxy instance per group. The class of the group proxy is the same as the Grouper's citizen class. For example, for a group of OcaGain actuators, the group proxy is an OcaGain object. The purpose of the group proxy is to allow controllers to access the group's setpoint (for actuator groups) or reading (for sensor groups) in the same way as they would access individual workers of the citizen class. In peer-to-peer mode, no group proxy is created. Instead, the group setpoint is changed whenever any member's setpoint is changed. In effect, all the group's members behave as though they were group proxies. Adding Citizens New citizens may be added to a Grouper instance at any time, using OcaGrouper's AddCitizen method. Newly-added citizens are by default not members of any group. Citizens may be enrolled in groups at any time using OcaGrouper's SetEnrollment method. Deleting The Grouper allows deletion of groups and citizens at any time, although excessive deletion may lead to sparse memory use, depending on Grouper implementation.Setpoints, Readings, and Aggregation Setpoints and Rules Each group has a setpoint (for actuator groups) or reading (for sensor groups) whose value is related to its members' setpoints or readings by the combination of two rules:
  • The group's saturation rules, which control handling of overrange conditions; and
  • Each member's aggregation rules, which determine the algorithms by which aggregate values are computed. Scope of the OcaGrouper Class Many aspects of groupers will vary from product to product. OcaGrouper is an abstract class that defines common concepts and terms for groupers, a canonical control interface, and most aspects of membership management . However it but stops short of specifying actual semantics. Implementations will need to define (at least):
  • Saturation rules
  • Aggregation rules
  • Error-handling mechanisms (e.g. what happens when a grouper loses its connection to a citizen, and what happens when it later re-attaches)

Base classes

template<class Class>
class OcaAgent

Public static variables

static const OcaClassVersionNumber ClassVersion
static const classid_tpl<3> ClassId
static const size_t count_events

Public static functions

static auto get_event_index(OcaEventID id, size_t index) -> AES70_ALWAYS_INLINE ptrdiff_t

Constructors, destructors, conversion operators

template<typename ... TN>
OcaGrouper(TN && ... args)

Public functions

auto get_class_version() const -> uint16_t virtual
auto get_classid() const -> const classid& virtual
void init(aes70::device::device* d, uint32_t n) virtual
auto call(const OcaMethodID id, const uint8_t* src, const uint8_t* src_end, uint8_t parameterCount, const aes70::response_generator& response) -> bool virtual
auto get_event_index(const OcaEventID OcaEventID) const -> ptrdiff_t virtual

Function documentation

template<classClass>
static AES70_ALWAYS_INLINE ptrdiff_t aes70::device::OcaGrouper<Class>::get_event_index(OcaEventID id, size_t index)

Internal class for finding the event index of a given EventID. Returns -1 if the given event is not defined.

template<classClass> template<typename ... TN>
aes70::device::OcaGrouper<Class>::OcaGrouper(TN && ... args)

Constructor which calls the constructor of Class with args forwarded.

template<classClass>
uint16_t aes70::device::OcaGrouper<Class>::get_class_version() const virtual

Returns the AES70 class version of this object.

template<classClass>
const classid& aes70::device::OcaGrouper<Class>::get_classid() const virtual

Returns the AES70 class id of this object.

template<classClass>
void aes70::device::OcaGrouper<Class>::init(aes70::device::device* d, uint32_t n) virtual

Called when this object is added to a device.

template<classClass>
bool aes70::device::OcaGrouper<Class>::call(const OcaMethodID id, const uint8_t* src, const uint8_t* src_end, uint8_t parameterCount, const aes70::response_generator& response) virtual

Internal method used to call AES70 methods in this object.

template<classClass>
ptrdiff_t aes70::device::OcaGrouper<Class>::get_event_index(const OcaEventID OcaEventID) const virtual

Returns the index of a given event. The idea is that all events defined on a aes70 class can be enumerated. For events which this object does not implement, the value -1 is returned.

Variable documentation

template<classClass>
static const OcaClassVersionNumber aes70::device::OcaGrouper<Class>::ClassVersion

The ClassVersion of this class according to the AES70 standard.

template<classClass>
static const classid_tpl<3> aes70::device::OcaGrouper<Class>::ClassId

The ClassID of this class according to the AES70 standard.

template<classClass>
static const size_t aes70::device::OcaGrouper<Class>::count_events

Number of events defined in this class. This depends on which events are implemented by Class.