Enumerated Lists - Integration - Update 44 - Help - Hexagon

Integration Help

Language
English
Product
Integration
Search by Category
Help
Smart 3D Version
12.1 (2019)
Smart Construction Version
2019(7.0)
SmartPlant Foundation / SDx Version
10
Smart Electrical Version
2019 (9.0)
Smart Materials/Smart Reference Data Version
2020 (10.0)
Smart P&ID Version
9 (2019)
Smart Review Version
2020 (15.0)
Smart Engineering Manager Version
10 (2019)
Smart Interop Publisher Version
13.1 (2019 R1)
Smart Isometrics Version
7.0(2019)
Spoolgen Version
9.0(2019)

In the SmartPlant schema, some property definitions are of the enumerated list type (EnumListType). These property definitions have a list of possible string property values defined for them in an enumerated list (sometimes called a "picklist" or "lookup"). Any value for a property definition of this type must match an entry in the list of enumerated property values defined for the property type.

Each enumerated list contains one or more enumerated entries (EnumEnum). Each enumerated entry represents a possible value for a property scoped by that enumerated list.

Enumeration Hierarchies

Enumerated lists can contain all the possible enumerated entries for a property definition, or they can be combined to form an enumeration hierarchy. When you combine enumerated lists this way, you create child enumerated lists that are referenced by other enumerated lists. When this happens, a special property type (enumerated list level type) can be used to describe all enumerations at a given level in the enumeration hierarchy. When a property definition has an associated enumerated list level type, it effectively allows dependent picklists to be defined.

All nodes in the hierarchy that are EnumListTypes are enumerated entries for the EnumListType above them. All EnumListTypes must contain EnumEnums (list entries) or other EnumListTypes (enumerated lists).

The following UML diagram presents the SmartPlant schema model for enumerated lists and enumerated entries.

SchemaEd_EnumListUML

The EnumListType class definition is used for enumerated list property types. EnumListType realizes IPropertyType. EnumListType also realizes IEnumListType, the interface definition that supports enumerated list behavior. IEnumListType has a Contains relationship definition to IEnumEnum. Instances of this relationship are used to indicate the enumerated entries contained within the enumerated list.

Leaf nodes within an enumerated list hierarchy are instances of the EnumEnum class definition. This class definition realizes IEnumEnum, the interface definition that supports enumerated entry behavior, and IObject, the interface that contains the short (Name) and long (Description) text values for the enumerated entry. Branch nodes within an enumerated list hierarchy are instances of the EnumListType class. EnumListType has an optional realizes relationship to IEnumEnum, which means that an enumerated list may or may not be an enumerated entry as well. For branch nodes within an enumerated list hierarchy, the EnumListType object will realize this optional interface.

By adding support for IEnumEnum to the EnumListType class definition, the need for the ConstrainsList between IEnumListType and IEnumListType and ConstrainsEntry between IEnumEnum and IEnumEnum relationship definitions has been eliminated. Therefore, these relationship definitions are no longer part of the SmartPlant meta- schema.

EnumMetadata Relationship

Sometimes enumerated entries are not just short and long text strings. In some cases enumerated entries have additional properties and/or additional behavior associated with them.

The EnumMetadata relationship definition is used to relate an enumerated entry (or an enumerated list that also supports the IEnumEnum interface) to other objects that provide additional properties and/or additional behavior to the enumerated entry.

Each level in an enumerated list hierarchy is a specialization of the level above it. For example, pumps and compressors are specializations of mechanical equipment and reciprocating and centrifugal pumps are specializations of pumps. Therefore, type specialization can be considered to be an enumerated list hierarchy.

At each level of specialization in the type hierarchy, there can be EnumMetadata relationships to other objects that provide additional information and behavior about that enumerated entry.

One of the class definitions that supports IEnumMetadata is InterfaceDef. This means that an enumerated entry (or enumerated list that supports IEnumEnum) can have as EnumMetadata relationship to an interface definition that defines additional properties and behavior for that enumerated entry. For example, the Pump enumerated list could have an EnumMetadata relationship to IPump, which would then define additional properties and behavior common to pumps.

Since the various nodes in the type specialization hierarchy can have corresponding roles (interface definitions), the type specialization can have a corresponding role specialization. For the type specialization, each node in the enumerated list hierarchy would have a Contains relationship to its more generalized parent whereas the corresponding role specialization would have similar Implies relationships between the interface definitions.

The interface definition involved in the EnumMetadata relationship will normally have (unless it corresponds to a leaf node) an exposed property definition that is scoped by the related enumerated list. Therefore, IPump exposes a property PumpType that is scoped by the Pump enumerated list.

See Also

Property Definitions
Schema modification rules
Create an Enumerated List
Import Enumerated List Entries from a Spreadsheet