In the context of dynamic view services, a server-to-component transaction executed within the compDB Linkonent, whereby the server acknowledges editing operations to the component that initiated the interaction cycle. See also component-to-server transaction, notification transaction, rollback transaction.

An object attribute whose value depends on, or is a function of, other attributes. See also derived data member.

API that enables JavaTM data sources to be represented graphically. See also strategy.

In UML, an aggregation is a “whole-part” association within which one element is “part” of the larger “whole” of the other element. See also composition.

Any kind of application, graphical or other, used to handle one or more representations of an instance of an object model. Can be thought of as the client part of the view that runs the representation model. An application component can manage various subsets of a server object model. The Rogue Wave® Server package comes with a predefined application component named swcomp.

See one-to-many relation, one-to-one relation.

In UML, a relationship that defines a set of links between or among objects. An association can have a name that defines the nature of this relationship. You can put a triangle next to this name to indicate the direction in which the name should be read.

In UML, a structural part of an association that defines the participation of a class in that association. The following are the primary aspects of an association end:

An instance of the class IlsObject. Basic objects can be both owned and used. See also entity, owned object, used object.

Rogue Wave Server classes (IlsRepresentation and IlsRpObject) implemented on the component side to make a bridge between the generic representation-object level and the internal-object level of the component.

A standard dynamic view that is set to buffer mode. In this mode, the updates sent by the view to the component are stored on the server side until buffer mode is canceled.

A pair of values representing the minimum and the maximum numbers of items in a list. The minimum value can be null. The maximum value can be an unsigned integer or can be indeterminate. See also multiplicity.

In UML, a model element that describes behavioral and/or structural features.

A representation attribute identifying a set of homogeneous representation objects that belong to another representation object —for example, TreeItem objects in a Tree representation or row objects in a Table representation.

See application component.

In the context of dynamic view services, a transaction that notifies the server of the editing operations initiated by a component on its representations. See also server-to-component transaction.

Or composite aggregation. In UML, refers to an aggregation within which the “parts” and the larger “whole” share lifetimes. A given model element can be part of only one composition relationship at a time.

An object attribute whose value is computed as the result of an evaluation function that depends on other attributes. The derived data member is recomputed only when one of these attributes is updated. This means that a derived data member cannot be edited directly. See also eagerness, entry data member.

A C++ container that stores smart pointers to objects and associates these objects with alphanumeric identifiers of type IlsIdentifier which give direct access to the objects contained in the dictionary. A dictionary can be declared for any subclass of IlsObject or IlsEntity.

An attribute that is added “dynamically” to an instance of a class, either within a static model or within a dynamic model. A dynamic attribute is said to be a “static dynamic attribute” if it affects all instances of the class. See also regular attribute, static attribute.

See modeling services.

A Server application that uses dynamic modeling services and runs a dynamic model. The dynamic server instantiates a dynamic model. See also dynamic view server (for which it should not be mistaken).

High-level interface services implemented at runtime from the application component side. Dynamic views interface server objects with components and perform interaction cycles. Mapping between Server classes and representation types is performed via view specification files processed by a view interpreter. See also buffered dynamic view, dynamic view server, view specification file.

An instance of the class IlsMvServer (or of a derived class) which manages a set of dynamic views on the server object model in a given Server application.

A computation mode for derived data members. By default, a derived data member is said to be lazy, which means that it is recalculated only on demand. However, if it is marked as eager, it is recomputed each time the function IlsReevaluate is called explicitly or during each interaction cycle run by the view server.

An instance of the class IlsEntity. Entities can be used but cannot be owned. An entity is the root of the object model. See also basic object, owned object, used object.

An object attribute whose value can be accessed and modified directly. Unlike derived data members, entry data members are not associated with evaluation functions. The modification of an entry triggers the recomputation of the derived members that depend on it.

A function that has been declared to the server model interpreter either through the ILS_MEMBER_FUNCTION macros or through the dynamic modeling services. Exported member functions are available to a server type manipulated in a script.

A situation where a set of objects point to each other in a circular way, so that none of them is ever deleted by the reference counter because they keep smart pointers to each other. With Rogue Wave® Server, this trap can be avoided by maintaining relations, rather than smart pointers, between the objects.

In the context of dynamic view services, a communication protocol supplied in the Rogue Wave Server libraries (mvserver, mvcomp) and used by dynamic views to notify their associated component representations. On the component side, this protocol is implemented by the classes IlsRpObject and IlsRepresentation, and transmits the requests sent from and to the server.

A relationship in which things associated with a more specialized child are substitutable for a more general parent. The more specific element is fully consistent with the more general element and contains additional information. The phrase “kind of” is often used in connection with generalization: the child is a kind of the parent. Generalization is commonly found in connection with classes.

A representation object attribute that identifies a server object and a view type on this object. Hyper-references are defined in two parts linked by an arrow:

In UML, a named entity that has its own identity and value. Represents a concrete manifestation of an abstraction. Examples of instances include objects (instances of classes) and links.

In the context of view services, a basic execution loop whereby the requests sent by a component trigger modifications on server objects, which in turn trigger notification to the component.

An Rogue Wave Server feature whose purpose is to connect application components to the server object model. They let you both manage the server object model and components independently from each other and maintain mappings between them. See also view, view services.

Inverting a relationship means pointing to the origin of a relation from the target object. See also n-m relation.

See eagerness.

In UML, an instance of an association that represents a connection among two or more objects.

An instance of an association end.

A relation in which target objects can be accessed sequentially. There are simple list-relations and sorted list-relations.

A set of associations between server model classes and representation classes. See also representation, view.

The Rogue Wave Server feature that enables you to design an object model to describe the underlying information system that is to be shared by application components. Classical modeling services are supplied as a C++ class and class-template library, whose API you use to build a static object model. Dynamic modeling services let you describe your object model (for example, in an XML model file) instead of coding it; the structure of the server objects is built at runtime from their description. See also view services.

In UML, refers to a specification of the number of values that can be present with regard to a given element.

An object that provides mutually exclusive access to a resource in a multithread context.

See association.

See one-to-many relation.

An n-ary relation whose inverse relation is also an n‑ary relation.
See also inverse relation.

A link or an association is said to be navigable if given an object or a class, respectively, at one end, one can easily and directly get to the object(s) or class(es) at the other end.

A mechanism responsible for maintaining consistency between server objects and their representations. See also interaction cycle.

A member function of a view type which defines how to notify components about a Server object of a given type with respect to a notification state. See also notification, notification state, view.

The logical state of a server object at a given time. A server object can have one of four different notification states: creation, deletion, modification, or default. The state of an object at a given time depends on the latest action performed on that object and on the state of the static view with respect to this object (that is, whether or not the view subscribes to the object).

A server-to-component transaction whereby a component updates its representations after server objects have been edited.
See also acknowledgement transaction, rollback transaction.

A set of objects and their associated logic. These objects are instances of C++ classes that derive from the Rogue Wave Server classes IlsObject and IlsEntity. These classes can declare entry data members, derived data members, and relations. See also modeling services, Server application.

A relation in which one object owns or uses several objects that form an array, a list, or a set of objects. Also called n-ary relation. See also one-to-one relation, ownership relation, use relation

A relation in which one object owns or uses only one other object. Also called unary relation. See also one-to-many relation, ownership relation, use relation.

A server object to which a view subscribes as the starting point from which events will be propagated to related server objects. See also subscribe, view.

The target of an ownership relation. See also owner object, ownership relation, use relation.

The origin of an ownership relation. See also owned object, ownership relation, use relation.

A relation where a given object, called the owner object, owns one or more other objects, called owned objects. Conversely, however, a given object cannot be owned by more than one other object.

A reactive and incremental process by which the notification engine navigates from one server object to other server objects, starting from one or more objects previously designated as the origin(s), and recursively through the relations interconnecting the server objects. During this process, representation objects are created and associated with some of the server objects met on the notification path. See also notification.

An Rogue Wave Script class that gives access to a C++ object from a script function. In the Rogue Wave Server context, a proxy to a server object holds this object through a smart pointer.

A counter that is automatically incremented whenever a new smart pointer references a given object and, conversely, decremented each time the number of smart pointers to that object decreases. The reference counter is a data member of the object. The object is deleted when its reference counter drops to zero. See also floating reference cycle.

An attribute that triggers no notification when its value is changed. See also dynamic attribute, static attribute.

An instance of the class IlsRepresentation (or of a subclass), that is, a component object associated with one server view. There is a single representation for each view.

A target object model—handled by an application component— to which all or part of a server object model is mapped at runtime by dynamic views. The static part consists in implementing a subclass of IlsRpObject with all its modifiers and declaring the representation objects to the representation model interpreter. The dynamic part uses the View Specification Language to specify the representation associated with the server object.

An interpreter implemented on the component side of an Rogue Wave Server application that uses dynamic view types. Its purpose is to map the bridge classes of the generic representation protocol to the representation model of a specific application component. In particular, it translates server requests made in the generic representation protocol into calls to constructors, modifiers, and destructors of the specific representation objects. See also server model interpreter, view interpreter.

An instance of IlsRpObject, that is, a component object associated with a unique server object, whose purpose is to bridge the generic representation object level of the protocol to the internal-object level of the component. See also representation model, view.

See generic representation protocol.

In UML, represents the behavior, or “face”, of a model element that participates in a given context.

A server-to-component transaction whereby the component executes a set of updates sent by the server when a component-to-server transaction fails and is rolled back, so as to restore consistency among the edited representations. See also acknowledgement transaction, notification transaction.

See server model interpreter.

The set of processes that execute the Server object model and its application component(s), which interact with each other through a view server. A Server application can be linked or distributed. See also dynamic view server.

An instance of the class IlsSwServerDataSource and, as such, an invisible runtime graphic object used by the Server/Views component to generate Rogue Wave Views data sources.

An interpreter implemented on the server side of an Rogue Wave Server application that uses dynamic view types. It allows the view interpreter to:

An instance of a class defined in an Rogue Wave Server object model.

See object model.

A transaction that performs a subset of modifications on server objects with the capability to undo, or roll back, these changes. When a transaction is successful, the changes are committed —that is, made permanent. See also component-to-server transaction, server-to-component transaction.

In the context of a dynamic view services, a transaction sent by the server to a component to acknowledge, notify, or roll back updates on representation objects. See also component-to-server transaction.

A relation in which target objects are grouped in a non-ordered set and can be accessed by a key. See also list relation, ownership relation, use relation.

A pointer that maintains a reference counter for the object it points to. When the object is no longer pointed to, that is, when the reference counter equals zero, the object is deleted automatically. See also floating reference cycle.

An attribute whose values for a class are shared by all instances of that class. Static attributes exist in the context of both static modeling and dynamic modeling. See also dynamic attribute.

In the context of Java data source adapter, strategies are enhanced listeners of their adapter. Generally, a strategy is dedicated to manage specific properties, such as the foreground and background colors of table rows, for example.

To establish a relation between a view and a server object that you designate as the view origin. Through propagation, a view automatically subscribes to every object that bears a relation to its origin.

In UML, an extensibility mechanism that allows you to create new information about model elements and presentation elements. (Note that this information applies to the element itself, not its instances). A tagged value consists of a tag, which is the name of a property, and a value. Tagged values can appear alone or within lists. The following tags are predefined within UML:

See component-to-server transaction, server object transaction, server-to-component transaction.

Acronym of Unified Modeling Language.

See one-to-one relation.

A hyper-reference that has been specified with no associated view by providing void as the view type. An unbound hyper-reference cannot be dereferenced.

A relation where a given object, called the user object, uses one or more other objects, called used objects. Conversely, a given object can be used by an arbitrary number of other objects.

The target of a use relation.

The origin of a use relation.

An instance of IlsMvView (or of a subtype) that notifies its associated application component about the update of any object or relation to which the view subscribes, so as to ensure consistency between an instance of a server object model and a representation of this object as handled by the component.

An interpreter implemented on the server side of an Rogue Wave Server application that uses dynamic view types. Its purpose is to create dynamic view types from view specification files and, for each instance of those types, to create and maintain mappings between server objects and their component representations. See also representation model interpreter, server model interpreter.

A parameter that is local to a view and whose values can therefore change from one view to the other. Each time a new view is opened, it receives view parameters that can alter its representation. The Server/Views mapping uses two predefined view parameters: a Server data source and a panel.

An .ils file in which you define dynamic view types and which will be processed at runtime by a view server.

Implements a business model and a set of views, and runs an interaction cycle See also dynamic view server.

A two-way interface ensuring consistency between a set of server objects and their representations as handled by an application component. See also dynamic view, interaction cycle, view.

An instance of the class IlsViewed, a viewed object is any server object to which a view subscribes, either directly or through propagation.

In UML, refers to an enumeration whose values specify the various possibilities in which a given feature can be used by a particular classifier. Visibility may assume one of the following values: public, protected, and private.