ACMETypespace* getTypespace ();

System* getDescription ();

void setDescription (System *sys);

ACMETypeManager* getTypeManager ();

Family* lookupFamily (char *name);

void addFamily (Family *fam);

FamilyEnumeration* getFamilies ();

ACMEDesignObject* getScope ();

};

ACME.Elements.ACMEElement

ACMEElement is an abstract base class which corresponds to a one of the basic building blocks of a design; an ACMEElement belongs to the category corresponding to System, Component, Connector, Port, or Role. Every ACMEElement has a set of instances of the Property class and a set of Representations.

class ACMEElement : public ACMEDesignObject {

ACMEElement ();

void exportACME (ACMEOutputStream *s );

char* getCategoryName ();

void setProperty (char *name, PropertyValue *val);

void exportACME (FILE *fp);

Design* getParentDesign ();

void setParentDesign (Design *design);

Representation* getParentRepresentation ();

PropertyEnumeration* getProperties ();

PropertyValue* getProperty (char *name);

void addProperty (char *name, PropertyType *t, PropertyValue *val);

void deleteProperty (char *name);

void doSetProperty (char *name, PropertyValue *val);

void doAddProperty (Property *p);

void doDeleteProperty (char *name);

RepresentationEnumeration* getRepresentations ();

Representation* getRepresentation (char *name );

void addRepresentation (Representation *rep);

void removeRepresentation (char *name);

};

ACME.Elements.System

A System defines a configuration of elements of ACME, and contains instances of ACMEElements: Components, Connectors, Ports and Roles. It also contains a set of Attachments.

class System : public ACMEElement {

// Constructors

System (char *name, Family *fam );

System ( );

void setParentRepresentation (Representation *rep);

Representation* getParentRepresentation ();

CategoryT getCategory ( { return ACME_SYSTEM };);
// Family and Types

Family* getFamily ();

void setFamily (Family *fam);

ACMETypespace* getTypespace ();
// Constituents

void addComponent (Component *comp);

Component* getComponent (char *comp_name);

void removeComponent (char *comp_name);

void removeComponent (Component *comp);

ComponentEnumeration* getComponents ();

void addConnector (Connector *conn);

Connector* getConnector (char *conn_name);

void removeConnector (char *name);

void removeConnector (Connector *conn);

ConnectorEnumeration* getConnectors ();

void addPort (Port *port);

Port* getPort (char *port_name);

void removePort (char *port_name);

void removePort (Port *port);

PortEnumeration* getPorts ();

void addRole (Role *role);

Role* getRole (char *role_name);

void removeRole (char *role_name);

void removeRole (Role *role);

RoleEnumeration* getRoles ();

AttachmentEnumeration* getAttachments ();

void addAttachment (Attachment *a);

void addAttachment (Port *p, Role *r);

ACMEDesignObject* getScope ();
// Templates

//void expandTemplates ();

//void resolveAttachments ();

};

ACME.Elements.Attachment

The Attachment class defines an association between a Port and Role which are logically attached in a System. Valid attachments are always a member of an AttachmentMap within a System.

class Attachment : public ACMEDesignObject{

Attachment (Port *p, Role *r);

ACMEDesignObject* getScope ();

void setProperty (char *name, PropertyValue *val);

Port* getPort ();

void setPort (Port *p);

Role* getRole ();

void setRole (Role *r );

};

ACME.Elements.Constituent

A Constituent is an abstract base class derived from ACMEElement which corresponds to the basic constituents of a System: Port, Role, Component, Connector.

class Constituent : public ACMEElement {

Constituent ();

ACMEDesignObject* getScope ();

void addProperty (char *name, PropertyType *t, PropertyValue *val);

void deleteProperty (char *name);

InstantiationMethodT getInstantiationMethod ();

Component (char *name, ComponentType *type);

Representation* getParentRepresentation ();

ACMEElement* getParent ();

void setParent (ACMEElement *parent);

};

ACME.Elements.Component

An ACME Component.

class Component : public Constituent {

//Component (ACMEStream *stream);

void setInstantiation (ComponentTypeInstantiation *inst);

};

void setType (ComponentType *type);

ComponentType* getType ();

void setPort (char *name, Port *p);

void addPort (char *name, Port *p);

Port* getPort (char *name);

void removePort (char *name);

PortEnumeration* getPorts ();

void doRemovePort (char *name);

void doSetPort (char *name, Port *p);

void doAddPort (char *name, Port *p);

ACME.Elements.Connector

An ACME Connector

class Connector : public Constituent {

Connector (char *name, ConnectorType *t);

void setType (ConnectorType *type);

ConnectorType* getType ();

void setInstantiation (ConnectorTypeInstantiation *inst);

};

void setRole (char *name, Role *p);

void addRole (char *name, Role *p);

Role* getRole (char *name);

void removeRole (char *name);

RoleEnumeration* getRoles ();

void doRemoveRole (char *name);

void doSetRole (char *name, Role *p);

void doAddRole (char *name, Role *p);

ACME.Elements.Port

An ACME Port

class Port : public Constituent {

Port* copy ();

Port (char *name, PortType *t);

// Port (ACMEStream *stream);

void setType (PortType *type);

PortType* getType ();

void setInstantiation (PortTypeInstantiation *inst);

};

ACME.Elements.Role

An ACME Role

class Role : public Constituent {

Role (char *name, RoleType *type);

// Role (ACMEStream *stream);

Role* copy ();

void setInstantiation (RoleTypeInstantiation *inst);

};

void setType (RoleType *type);

RoleType* getType ();

ACME.ConstituentTypes.ACMETypeManager

Manages type define in a design. Includes methods for looking up types based upon the scope. Makes use of local/family and global typespace.

class ACMETypeManager : public ACMEObject {

ACMETypeManager ();

void setDesign (Design *d { design d };);

Design* getDesign ( { return design };);

ElementType* getType (CategoryT cat, System *context, char *name);
// Type lookup by name

PropertyType* getPropertyType (System *context, char *name);

ComponentType* getComponentType (System *context, char *name);

ConnectorType* getConnectorType (System *context, char *name);

PortType* getPortType (System *context, char *name);

RoleType* getRoleType (System *context, char *name);

PropertyTypeEnumeration* getPropertyTypes ();

ACME.ConstituentTypes.ACMETypespace

A lookup-table for types. Corresponds to a set of types defined in scope. Bascically, a symbol table for types.

class ACMETypespace : public ACMEObject {

// This should probably be moved to a separate type-manager class // Types // Manipulation of type lists

ComponentTypeEnumeration* getComponentTypes ();

ConnectorTypeEnumeration* getConnectorTypes ();

RoleTypeEnumeration* getRoleTypes ();

PortTypeEnumeration* getPortTypes ();

void addPropertyType (PropertyType *t);

void addComponentType (ComponentType *t);

void addConnectorType (ConnectorType *t);

void addPortType (PortType *t);

void addRoleType (RoleType *t);
// Generic type lookup

ElementType* getType (CategoryT cat, char *name);

void addType (ElementType *type);
// Type lookup by name

PropertyType* getPropertyType (char *name);

ComponentType* getComponentType (char *name);

ConnectorType* getConnectorType (char *name);

PortType* getPortType (char *name);

RoleType* getRoleType (char *name);

char* getClassname ();
// Type instantiation by name. These methods call the corresponding

// instantiate ( methods of the specific type classes.);
/*

Component* instantiateComp (char *comp_type_name);

Component* instantiateComp (char *name, Component *extension);

Component* instantiateCompFromPrototype (char *name, Component *prototype);

Connector* instantiateConn (char *name);

Connector* instantiateConn (char *name, Connector *extension);

Connector* instantiateConnFromPrototype (char *name, Connector *prototype);

Port* instantiatePort (char *name);

Port* instantiatePort (char *name, Port *extension);

Port* instantiatePortFromPrototype (char *name, Port *prototype);

Role* instantiateRole (char *name);

Role* instantiateRole (char *name, Role *extension);

Role* instantiateRoleFromPrototype (char *name, Role *prototype);
*/
};

ACME.ConstituentTypes.Family

This is an ACME Family definition. A Family has a collection of of global types defined for that family that can be used within a System in that Family.

class Family : public ACMEDesignObject {

// Name

Family (char *name);

ACMETypespace* getTypespace ();

ACMEDesignObject* getScope ();

ACME.ConstituentTypes.PropertyDescription

A PropertyDescription defines a set of Properties. Used as Part of an ElementType definition.

class PropertyDescription : public ACMEDesignObject {

PropertyDescription (char *n, PropertyType *t, PropertyValue *val);

PropertyValue* getValue ();

PropertyType* getType ();

char* getName ();

};

ACME.ConstituentTypes.ElementType

ElementType is an abstract base class which corresponds to an ACME constituent type. Has concrete derived classes PortType, RoleType, ConnectorType and ComponentType.

class ElementType : public ACMEDesignObject {

void init_instance (Constituent *e );

void init_instance_properties (ACMEElement *e);

bool typeCheck (Constituent *obj);

bool typeCheckProperties (Constituent *obj);

void exportChildDescriptions (ACMEOutputStream *s, char *label, ACMEMap *map);

void exportPropertyDescriptions (ACMEOutputStream *s);

void exportMetaProperties (ACMEOutputStream *s);

bool chkDeleteProperty (Constituent *c, char *name);

bool chkSetProperty (Constituent *c, char *name, PropertyValue *val);

bool chkAddProperty (Constituent *c, char *name, PropertyValue *val);

bool chkSetProperty (Constituent *c, PropertyValue *val);

bool chkDeleteProperty (Constituent *c, Property *p);

bool chkAddProperty (Constituent *c, Property *p);

void setMetaProperty (char *name, PropertyValue *val);

void addMetaProperty (Property *p);

void addMetaProperty (char *name, PropertyValue *val);

PropertyValue* getMetaProperty (char *name);

PropertyEnumeration* getMetaProperties ();

void exportACME (ACMEOutputStream *s );
// Name of type

PropertyDescriptionEnumeration* getPropertyDescriptions ();

void addPropertyDescription (char *prop_name, PropertyType *t, PropertyValue *value);

void addPropertyDescription (PropertyDescription *t);

void deletePropertyDescription (char *name);

void addSuperType (ElementType *type);

char* getCategoryName ();

ACME.ConstituentTypes.ConstituentDescription

ACMEDesignObject* getScope ();

};

ConstituentDescription is an abstract base class describes a child constituent. Its subclasses, PortDescription and RoleDescription are used to describe valid ports/roles in ComponentTypes/ConnectorTypes.

class ConstituentDescription : public ACMEDesignObject {

ConstituentDescription (char *n);

Constituent* getBody ();

PortDescription (char *n, PortType *t, Port *body);

char* getName ();

};

ACME.ConstituentTypes.PortDescription

Defines a set of Ports. Used in ComponentType.

class PortDescription : public ConstituentDescription {

Constituent* getBody ();

RoleDescription (char *n, RoleType *t, Role *body);

PortType* getType ();

};

ACME.ConstituentTypes.RoleDescription

Defines a set of Roles Used in ConnectorType.

class RoleDescription : public ConstituentDescription {

Constituent* getBody ();

RoleType* getType ();

};

ACME.ConstituentTypes.ComponentType

An ACME component type definition

class ComponentType : public ElementType {

bool chkRemovePort (Component *c, char *name);

void init_instance (Component *comp);

Component* new_instance (char *name);

bool typeCheck (Constituent *obj);

Component* newEmptyInstance ();

Component* newInstance ();

bool typeCheck (Component *obj);

bool chkSetPort (Component *c, char *name, Port *p);

bool chkAddPort (Component *c, char *name, Port *p);

PortDescriptionEnumeration* getPortDescriptions ();

void deletePortDescription (char *name);

void addPortDescription (char *name, PortType *t, Port *body);

ComponentType (char *name);

ComponentTypeEnumeration* getSuperTypes ();

void addSuperType (ComponentType *type );

ACME.ConstituentTypes.ConnectorType

An ACME connector type definition.

class ConnectorType : public ElementType {

RoleDescriptionEnumeration* getRoleDescriptions ();

Connector* new_instance (char *name);

bool typeCheck (Constituent *obj);

bool typeCheck (Connector *obj);

ConnectorType (char *name);

bool chkRemoveRole (Connector *c, char *name);

bool chkSetRole (Connector *c, char *name, Role *r);

bool chkAddRole (Connector *c, char *name, Role *p);

void deleteRoleDescription (char *name);

void addRoleDescription (char *name, RoleType *t, Role *body);

Connector* instantiate ();

Connector* instantiate (Connector *extension);

Connector* instantiateFromPrototype (Connector *prototype);

ConnectorTypeEnumeration* getSuperTypes ();

void addSuperType (ConnectorType *type );

bool validateInstance (Connector *instance);

ACME.ConstituentTypes.PortType

An ACME Port type definition

class PortType : public ElementType {

Port* instantiateFromPrototype (Port *prototype);

Port* new_instance (char *name);

bool typeCheck (Port *p);

PortType (char *name);

Port* instantiate ();

Port* instantiate (Port *extension);

void addSuperType (PortType *type );

PortTypeEnumeration* getSuperTypes ();

void setDescription (Port *body);

Port* getDescription ();

bool validateInstance (Port *instance);

ACME.ConstituentTypes.RoleType

An ACME Role type definition.

class RoleType : public ElementType {

Role* instantiateFromPrototype (Role *prototype);

Role* new_instance (char *name);

RoleType (char *name);

Role* instantiate ();

Role* instantiate (Role *extension);

void addSuperType (RoleType *type );

RoleTypeEnumeration* getSuperTypes ();

void setDescription (Role *body);

Role* getDescription ();

bool validateInstance (Role *instance);

ACME.ConstituentTypes.TypeInstantiation

An instance a TypeInstantnation is referenced by every Consituent. It describes how the Constituent was instantiated (i.e., using "new", as a concrete description or from through a template invocation).

class TypeInstantiation : public ACMEDesignObject {

Constituent* getExtension ( { return NULL };);

ACMEDesignObject* getScope ( { return NULL };);

};

ACME.ConstituentTypes.ComponentTypeInstantiation

class ComponentTypeInstantiation : public TypeInstantiation {

ComponentTypeInstantiation (char *name, Component *extension);

Constituent* getExtension ();

Component* getComponentExtension ();

void setExtension (Component *extension);