expressir 1.3.3-aarch64-linux-musl

data/lib/expressir/model/cache.rb

@@ -0,0 +1,17 @@
+module Expressir
+  module Model
+    # Cache content object with Expressir version
+    class Cache < ModelElement
+      model_attr_accessor :version, 'String'
+      model_attr_accessor :content, 'ModelElement'
+
+      # @param [Hash] options
+      # @option options [String] :version
+      # @option options [ModelElement] :content
+      def initialize(options = {})
+        @version = options[:version]
+        @content = options[:content]
+      end
+    end
+  end
+end

data/lib/expressir/model/data_type.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Model
+    # Specified in ISO 10303-11:2004
+    # - section 8 Data types
+    # @abstract
+    class DataType < ModelElement
+    end
+  end
+end

data/lib/expressir/model/data_types/aggregate.rb

@@ -0,0 +1,31 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.3.1 Aggregate data type
+      class Aggregate < DataType
+        include Identifier
+
+        model_attr_accessor :base_type, 'Type'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Type] :base_type
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @base_type = options[:base_type]
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/array.rb

@@ -0,0 +1,31 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.2.1 Array data type
+      class Array < DataType
+        model_attr_accessor :bound1, 'Expression'
+        model_attr_accessor :bound2, 'Expression'
+        model_attr_accessor :optional, '::Boolean'
+        model_attr_accessor :unique, '::Boolean'
+        model_attr_accessor :base_type, 'DataType'
+
+        # @param [Hash] options
+        # @option options [Expression] :bound1
+        # @option options [Expression] :bound2
+        # @option options [::Boolean] :optional
+        # @option options [::Boolean] :unique
+        # @option options [DataType] :base_type
+        def initialize(options = {})
+          @bound1 = options[:bound1]
+          @bound2 = options[:bound2]
+          @optional = options[:optional]
+          @unique = options[:unique]
+          @base_type = options[:base_type]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/bag.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.2.3 Bag data type
+      class Bag < DataType
+        model_attr_accessor :bound1, 'Expression'
+        model_attr_accessor :bound2, 'Expression'
+        model_attr_accessor :base_type, 'DataType'
+
+        # @param [Hash] options
+        # @option options [Expression] :bound1
+        # @option options [Expression] :bound2
+        # @option options [DataType] :base_type
+        def initialize(options = {})
+          @bound1 = options[:bound1]
+          @bound2 = options[:bound2]
+          @base_type = options[:base_type]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/binary.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.7 Binary data type
+      class Binary < DataType
+        model_attr_accessor :width, 'Expression'
+        model_attr_accessor :fixed, '::Boolean'
+
+        # @param [Hash] options
+        # @option options [Expression] :width
+        # @option options [::Boolean] :fixed
+        def initialize(options = {})
+          @width = options[:width]
+          @fixed = options[:fixed]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/boolean.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.5 Boolean data type
+      class Boolean < DataType
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/enumeration.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.4.1 Enumeration data type
+      class Enumeration < DataType
+        model_attr_accessor :extensible, '::Boolean'
+        model_attr_accessor :based_on, 'Reference'
+        model_attr_accessor :items, '::Array<EnumerationItem>'
+
+        # @param [Hash] options
+        # @option options [::Boolean] :extensible
+        # @option options [Reference] :based_on
+        # @option options [::Array<EnumerationItem>] :items
+        def initialize(options = {})
+          @extensible = options[:extensible]
+          @based_on = options[:based_on]
+          @items = options[:items] || []
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/enumeration_item.rb

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.4.1 Enumeration data type
+      class EnumerationItem < ModelElement
+        include Identifier
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/generic.rb

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.3.2 Generic data type
+      class Generic < DataType
+        include Identifier
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/generic_entity.rb

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.3.3 Generic entity data type
+      class GenericEntity < DataType
+        include Identifier
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          super
+        end
+      end
+
+      # @return [Array<Declaration>]
+      def children
+        [
+          *remark_items
+        ]
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/integer.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.3 Integer data type
+      class Integer < DataType
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/list.rb

@@ -0,0 +1,28 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.2.2 List data type
+      class List < DataType
+        model_attr_accessor :bound1, 'Expression'
+        model_attr_accessor :bound2, 'Expression'
+        model_attr_accessor :unique, '::Boolean'
+        model_attr_accessor :base_type, 'DataType'
+
+        # @param [Hash] options
+        # @option options [Expression] :bound1
+        # @option options [Expression] :bound2
+        # @option options [::Boolean] :unique
+        # @option options [DataType] :base_type
+        def initialize(options = {})
+          @bound1 = options[:bound1]
+          @bound2 = options[:bound2]
+          @unique = options[:unique]
+          @base_type = options[:base_type]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/logical.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.4 Logical data type
+      class Logical < DataType
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/number.rb

@@ -0,0 +1,10 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.1 Number data type
+      class Number < DataType
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/real.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.2 Real data type
+      class Real < DataType
+        model_attr_accessor :precision, 'Expression'
+
+        # @param [Hash] options
+        # @option options [Expression] :precision
+        def initialize(options = {})
+          @precision = options[:precision]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/select.rb

@@ -0,0 +1,28 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.4.2 Select data type
+      class Select < DataType
+        model_attr_accessor :extensible, '::Boolean'
+        model_attr_accessor :generic_entity, '::Boolean'
+        model_attr_accessor :based_on, 'Reference'
+        model_attr_accessor :items, '::Array<Reference>'
+
+        # @param [Hash] options
+        # @option options [::Boolean] :extensible
+        # @option options [::Boolean] :generic_entity
+        # @option options [Reference] :based_on
+        # @option options [::Array<Reference>] :items
+        def initialize(options = {})
+          @extensible = options[:extensible]
+          @generic_entity = options[:generic_entity]
+          @based_on = options[:based_on]
+          @items = options[:items] || []
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/set.rb

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.2.4 Set data type
+      class Set < DataType
+        model_attr_accessor :bound1, 'Expression'
+        model_attr_accessor :bound2, 'Expression'
+        model_attr_accessor :base_type, 'DataType'
+
+        # @param [Hash] options
+        # @option options [Expression] :bound1
+        # @option options [Expression] :bound2
+        # @option options [DataType] :base_type
+        def initialize(options = {})
+          @bound1 = options[:bound1]
+          @bound2 = options[:bound2]
+          @base_type = options[:base_type]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/data_types/string.rb

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module DataTypes
+      # Specified in ISO 10303-11:2004
+      # - section 8.1.6 String data type
+      class String < DataType
+        model_attr_accessor :width, 'Expression'
+        model_attr_accessor :fixed, '::Boolean'
+
+        # @param [Hash] options
+        # @option options [Expression] :width
+        # @option options [::Boolean] :fixed
+        def initialize(options = {})
+          @width = options[:width]
+          @fixed = options[:fixed]
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declaration.rb

@@ -0,0 +1,9 @@
+module Expressir
+  module Model
+    # Specified in ISO 10303-11:2004
+    # - section 9 Declarations
+    # @abstract
+    class Declaration < ModelElement
+    end
+  end
+end

data/lib/expressir/model/declarations/attribute.rb

@@ -0,0 +1,47 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.1 Attributes
+      class Attribute < Declaration
+        include Identifier
+
+        EXPLICIT = :EXPLICIT
+        DERIVED = :DERIVED
+        INVERSE = :INVERSE
+
+        model_attr_accessor :kind, ':EXPLICIT, :DERIVED, :INVERSE'
+        model_attr_accessor :supertype_attribute, 'Reference'
+        model_attr_accessor :optional, 'Boolean'
+        model_attr_accessor :type, 'DataType'
+        model_attr_accessor :expression, 'Expression'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [:EXPLICIT, :DERIVED, :INVERSE] :kind
+        # @option options [Reference] :supertype_attribute
+        # @option options [Boolean] :optional
+        # @option options [DataType] :type
+        # @option options [Expression] :operand
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @kind = options[:kind]
+          @supertype_attribute = options[:supertype_attribute]
+          @optional = options[:optional]
+          @type = options[:type]
+          @expression = options[:expression]
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/constant.rb

@@ -0,0 +1,34 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.4 Constant
+      class Constant < Declaration
+        include Identifier
+
+        model_attr_accessor :type, 'DataType'
+        model_attr_accessor :expression, 'Expression'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [DataType] :type
+        # @option options [Expression] :expression
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @type = options[:type]
+          @expression = options[:expression]
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/entity.rb

@@ -0,0 +1,53 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2 Entity declaration
+      class Entity < Declaration
+        include Identifier
+
+        model_attr_accessor :abstract, 'Boolean'
+        model_attr_accessor :supertype_expression, 'SupertypeExpression'
+        model_attr_accessor :subtype_of, 'Array<Reference>'
+        model_attr_accessor :attributes, 'Array<Attribute>'
+        model_attr_accessor :unique_rules, 'Array<UniqueRule>'
+        model_attr_accessor :where_rules, 'Array<WhereRule>'
+        model_attr_accessor :informal_propositions, 'Array<RemarkItem>'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Boolean] :abstract
+        # @option options [SupertypeExpression] :supertype_expression
+        # @option options [Array<Reference>] :subtype_of
+        # @option options [Array<Attribute>] :attributes
+        # @option options [Array<UniqueRule>] :unique_rules
+        # @option options [Array<WhereRule>] :where_rules
+        # @option options [Array<RemarkItem>] :informal_propositions
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @abstract = options[:abstract]
+          @supertype_expression = options[:supertype_expression]
+          @subtype_of = options[:subtype_of] || []
+          @attributes = options[:attributes] || []
+          @unique_rules = options[:unique_rules] || []
+          @where_rules = options[:where_rules] || []
+          @informal_propositions = options[:informal_propositions] || []
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *attributes,
+            *unique_rules,
+            *where_rules,
+            *informal_propositions,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/function.rb

@@ -0,0 +1,67 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.1 Function
+      class Function < Declaration
+        include Identifier
+
+        model_attr_accessor :parameters, 'Array<Parameter>'
+        model_attr_accessor :return_type, 'DataType'
+        model_attr_accessor :types, 'Array<Type>'
+        model_attr_accessor :entities, 'Array<Entity>'
+        model_attr_accessor :subtype_constraints, 'Array<SubtypeConstraint>'
+        model_attr_accessor :functions, 'Array<Function>'
+        model_attr_accessor :procedures, 'Array<Procedure>'
+        model_attr_accessor :constants, 'Array<Constant>'
+        model_attr_accessor :variables, 'Array<Variable>'
+        model_attr_accessor :statements, 'Array<Statement>'
+
+        # @param [Hash] options
+        # @option (see Identifier#initialize_identifier)
+        # @option options [Array<Parameter>] :parameters
+        # @option options [DataType] :return_type
+        # @option options [Array<Type>] :types
+        # @option options [Array<Entity>] :entities
+        # @option options [Array<SubtypeConstraint>] :subtype_constraints
+        # @option options [Array<Function>] :functions
+        # @option options [Array<Procedure>] :procedures
+        # @option options [Array<Constant>] :constants
+        # @option options [Array<Variable>] :variables
+        # @option options [Array<Statement>] :statements
+        def initialize(options = {})
+          initialize_identifier(options)
+
+          @parameters = options[:parameters] || []
+          @return_type = options[:return_type]
+          @types = options[:types] || []
+          @entities = options[:entities] || []
+          @subtype_constraints = options[:subtype_constraints] || []
+          @functions = options[:functions] || []
+          @procedures = options[:procedures] || []
+          @constants = options[:constants] || []
+          @variables = options[:variables] || []
+          @statements = options[:statements] || []
+
+          super
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *parameters,
+            *types,
+            *types.flat_map{|x| x.enumeration_items},
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *procedures,
+            *constants,
+            *variables,
+            *remark_items
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/interface.rb

@@ -0,0 +1,28 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 11 Interface specification
+      class Interface < Declaration
+        USE = :USE
+        REFERENCE = :REFERENCE
+
+        model_attr_accessor :kind, ':USE, :REFERENCE'
+        model_attr_accessor :schema, 'Reference'
+        model_attr_accessor :items, 'Array<InterfaceItem>'
+
+        # @param [Hash] options
+        # @option options [:USE, :REFERENCE] :kind
+        # @option options [Reference] :schema
+        # @option options [Array<InterfaceItem>] :items
+        def initialize(options = {})
+          @kind = options[:kind]
+          @schema = options[:schema]
+          @items = options[:items] || []
+
+          super
+        end
+      end
+    end
+  end
+end