Class: Lutaml::Model::Sequence

Inherits:
Object
  • Object
show all
Includes:
DeepDupable
Defined in:
lib/lutaml/model/sequence.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(model, format: nil) ⇒ Sequence

Returns a new instance of Sequence.



11
12
13
14
15
 
# File 'lib/lutaml/model/sequence.rb', line 11

def initialize(model, format: nil)
  @attributes = []
  @model = model
  @format = format
end

Instance Attribute Details

#attributes ⇒ Object

Returns the value of attribute attributes.



8
9
10
 
# File 'lib/lutaml/model/sequence.rb', line 8

def attributes
  @attributes
end

#format ⇒ Object (readonly)

Returns the value of attribute format.



9
10
11
 
# File 'lib/lutaml/model/sequence.rb', line 9

def format
  @format
end

#model ⇒ Object

Returns the value of attribute model.



8
9
10
 
# File 'lib/lutaml/model/sequence.rb', line 8

def model
  @model
end

Instance Method Details

#attribute(name, type, options = {}) ⇒ Object 



25
26
27
28
 
# File 'lib/lutaml/model/sequence.rb', line 25

def attribute(name, type, options = {})
  options[:sequence] = self
  @model.attribute(name, type, options)
end

#deep_dup(new_model = nil) ⇒ Object

Deep copy a sequence, creating independent copies of attributes The model reference is updated to point to the new parent mapping



19
20
21
22
23
 
# File 'lib/lutaml/model/sequence.rb', line 19

def deep_dup(new_model = nil)
  dup_seq = Sequence.new(new_model || @model, format: @format)
  dup_seq.attributes = Utils.deep_dup(@attributes)
  dup_seq
end

#import_model_mappings(model, register = nil) ⇒ Object

Raises:



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/lutaml/model/sequence.rb', line 38

def import_model_mappings(model, register = nil)
  if later_importable?(model)
    return import_mappings_later(model,
                                 register)
  end
  raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?(register)

  register ||= Lutaml::Model::Config.default_register

  # When importing a model into a sequence, we need BOTH:
  # 1. Object model (attributes/structure) - what data exists
  # 2. Serialization mappings (how to serialize) - how data maps to XML
  # This mimics XSD where using a complexType in a sequence means
  # adopting both its structure and its serialization rules

  # Import serialization mappings first (element names → model attributes)
  @model.import_model_mappings(model, register)
  if @format
    @attributes.concat(Utils.deep_dup(model.mappings_for(@format,
                                                         register).elements(register)))
  end
end

#map_all ⇒ Object

Raises:



69
70
71
 
# File 'lib/lutaml/model/sequence.rb', line 69

def map_all(*)
  raise Lutaml::Model::UnknownSequenceMappingError.new("map_all")
end

#map_attribute ⇒ Object

Raises:



61
62
63
 
# File 'lib/lutaml/model/sequence.rb', line 61

def map_attribute(*)
  raise Lutaml::Model::UnknownSequenceMappingError.new("map_attribute")
end

#map_content ⇒ Object

Raises:



65
66
67
 
# File 'lib/lutaml/model/sequence.rb', line 65

def map_content(*)
  raise Lutaml::Model::UnknownSequenceMappingError.new("map_content")
end

#map_element(name) ⇒ Object 



34
35
36
 
# File 'lib/lutaml/model/sequence.rb', line 34

def map_element(name, **)
  @attributes << @model.map_element(name, **)
end

#sequence ⇒ Object 



30
31
32
 
# File 'lib/lutaml/model/sequence.rb', line 30

def sequence(&)
  instance_eval(&)
end

#validate_content!(element_order, instance, register = nil) ⇒ Object 



73
74
75
76
77
78
79
80
 
# File 'lib/lutaml/model/sequence.rb', line 73

def validate_content!(element_order, instance, register = nil)
  validate_sequence!(
    extract_defined_order(instance.class.attributes(register).transform_keys(&:to_s)),
    element_order,
    register,
  )
  validate_child_content(instance, register)
end