connector

Description

The connector interface must be implemented by connector objects. The interface describes the connector and how it can be connected to other connectors. A connector is used for connecting component objects. The connector is just a proxy for the connection, the connector uses the component_connector interface in the components to setup the connection.

The type function returns the connector type as a string. Two connectors can only be connected if the type is identical.

A hotpluggable connector returns true when calling the hotpluggable function, otherwise false. A hotpluggable connector can be connected before or after the component is instantiated, an non hotpluggable connector must be connected before the component is instantiated.

The required function returns true if the connector must be connected before instantiated, otherwise false.

A connector can be connected to many connectors, but it is only supported if the multi function return true. It is not recommended that a connector support multi connections. A component can instead dynamically create connectors when needed.

A connector has a direction; up, down or any. The direction decides in which order the connectors in a component tree are connected and the structure of the tree.

Connections are setup in two steps. The first step is to add the connection, which is done using the add_destination function. Adding a connection can fail for several reasons and it is implementation dependent how the connection can fail. A connection can for instance fail because the destination object requires something that the source component did not pass when checking the connection. Just adding a connection does not mean that the components actually connect. The components have to save the data given with the add_destination function. The actual setup of the connection is made in the second step when the update function is called, which finalizes the connection.

The add_destination and remove_destination functions sets the state of the connection. It is first when the update function is called when the connection is finalized. Both add_destination and remove_destination returns true if the call was successful otherwise they return false.

Parameters to the add_destination function are the own object obj and the destination object dst_obj. The destination object must be a port object and it must implement the connector interface.

The update function is called when the component should update its current connection status. The status of the connection has previously been set using the add_destination or/and remove_destination functions.

The destination function returns a list of port objects that the its connected to. The destination function returns the state of the connection not the finalized state, i.e. the state of the connection before update functional call.

The check, connect, and disconnect functions initiates a connection setup via the connector object. The connector will forward the setup to the components affected by the connection via the component_connector interface.

The deletion_requested function is called after disconnecting components. A dynamic connector might want to return True in order to be deleted just after the disconnection.

typedef enum {
        Sim_Connector_Direction_Up,
        Sim_Connector_Direction_Down,
        Sim_Connector_Direction_Any
} connector_direction_t;

SIM_INTERFACE(connector) {
        char *(*type)(conf_object_t *obj);
        bool (*hotpluggable)(conf_object_t *obj);
        bool (*required)(conf_object_t *obj);
        bool (*multi)(conf_object_t *obj);
        connector_direction_t (*direction)(conf_object_t *obj);

        bool (*add_destination)(conf_object_t *obj, conf_object_t *connector);
        bool (*remove_destination)(conf_object_t *obj,
                                   conf_object_t *connector);
        attr_value_t (*destination)(conf_object_t *obj); /* list of
                                                            connector objects */
        void (*update)(conf_object_t *obj);

        bool (*check)(conf_object_t *obj, attr_value_t attr);
        void (*connect)(conf_object_t *obj, attr_value_t attr);
        void (*disconnect)(conf_object_t *obj);
        bool (*deletion_requested)(conf_object_t *obj);
};
#define CONNECTOR_INTERFACE "connector"

Execution Context

Global Context for all methods.