About Keywords

This keyword lets you order the evaluation of concepts and rules so that objects are created in the proper order in the tree. It applies to a set of Children or to a List Children. This keyword proves useful when working on modelers for which the execution order is important. For example, the operations you create using the ManufacturingSystemDefinition modelers must be created in a defined order that matches the order in which the operations are performed on the assembly line.

Concept OrderedTriangle : BaseConcept
{
                 Object : Feature;
                 [...]
                 Children
                 {
                         Ordered
                         {
                                    TrianglePoint P1;
                                    TrianglePoint P2;
                                    TrianglePoint P3;
                          }
                  }
                  [...]
}

This keyword lets you organize inputs in different screens and guarantees that the inputs of only one child are displayed at a time. The inputs can be gathered in sets based on their concept. It applies to an unlimited set of Children or List Children like Ordered does and can be combined with Ordered. It ensures that inputs coming from the same set children are displayed in different inputs screens when executing the script.

Concept SplitCompute : BaseConcept
{
                 Object : VoidType;
                 Attributes
                 {
                         Outputs
                         {
                                   Integer globalResult = a1\c + a2\c;
                         }
                 }
                 Children
                 {
                          Split
                          {
                                   Addition a1 = new(“Addition”,”a1”,this);
                                   Addition a2= new(“Addition”,”a2”,this);
                          }
                 }
                 [...]
}
Concept Addition : BaseConcept
{
                 Object : VoidType;
                 Attributes
                 {
                          Inputs
                          {
                                 Integer a;
                                 Integer b;
                          }
                          Outputs
                          {
                                 Integer c = a + b;
                          }
                 }
}

This keyword lets you define attributes that may not be used at execution and that you do not necessarily need to valuate. You define attributes that only require a value when needed. A value is required if the attributes have no evaluator. It operates on attributes only and can be used on Environment Concepts. These concepts have many attributes, a number of which may be used by other concepts. This keyword is of great help at instantiation time by asking for values for the attributes used.

You do not need to valuate the attribute unless it is required to execute a rule.

Concept OnDemandAttr : BaseConcept
{
                 Object : VoidType;
                 Attributes
                 {
                          Inputs
                          {
                                  Integer a OnDemand;
                                  Integer b;
                                  Integer c OnDemand;
                          }
                           Outputs
                          {
                                   Integer d = a + b;
                          }
                  }
}