Class: Puppet::Pops::Serialization::Serializer

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet/pops/serialization/serializer.rb

Overview

The serializer is capable of writing, arrays, maps, and complex objects using an underlying protocol writer. It takes care of tabulating and disassembling complex objects.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(writer, options = EMPTY_HASH) ⇒ Serializer

Returns a new instance of Serializer

Options Hash (options):

  • :type_by_reference (Boolean)

    `true` if Object types are serialized by name only.


17
18
19
20
21
# File 'lib/puppet/pops/serialization/serializer.rb', line 17

def initialize(writer, options = EMPTY_HASH)
  @written = {}
  @writer = writer
  @options = options
end

Instance Attribute Details

#writerObject (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Provides access to the writer.


11
12
13
# File 'lib/puppet/pops/serialization/serializer.rb', line 11

def writer
  @writer
end

Instance Method Details

#finishObject

Tell the underlying writer to finish


25
26
27
# File 'lib/puppet/pops/serialization/serializer.rb', line 25

def finish
  @writer.finish
end

#inspectObject


95
96
97
# File 'lib/puppet/pops/serialization/serializer.rb', line 95

def inspect
  to_s
end

#push_written(value) ⇒ Object


77
78
79
# File 'lib/puppet/pops/serialization/serializer.rb', line 77

def push_written(value)
  @written[value.object_id] = @written.size
end

#start_array(size) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Write the start of an array.


51
52
53
# File 'lib/puppet/pops/serialization/serializer.rb', line 51

def start_array(size)
  @writer.write(Extension::ArrayStart.new(size))
end

#start_map(size) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Write the start of a map (hash).


58
59
60
# File 'lib/puppet/pops/serialization/serializer.rb', line 58

def start_map(size)
  @writer.write(Extension::MapStart.new(size))
end

#start_object(attr_count) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Write the start of a complex object


73
74
75
# File 'lib/puppet/pops/serialization/serializer.rb', line 73

def start_object(attr_count)
  @writer.write(Extension::ObjectStart.new(attr_count))
end

#start_pcore_object(type_ref, attr_count) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Write the start of a complex pcore object


66
67
68
# File 'lib/puppet/pops/serialization/serializer.rb', line 66

def start_pcore_object(type_ref, attr_count)
  @writer.write(Extension::PcoreObjectStart.new(type_ref, attr_count))
end

#start_sensitiveObject

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Write the start of a sensitive object


83
84
85
# File 'lib/puppet/pops/serialization/serializer.rb', line 83

def start_sensitive
  @writer.write(Extension::SensitiveStart::INSTANCE)
end

#to_sObject


91
92
93
# File 'lib/puppet/pops/serialization/serializer.rb', line 91

def to_s
  "#{self.class.name} with #{@writer}"
end

#type_by_reference?Boolean


87
88
89
# File 'lib/puppet/pops/serialization/serializer.rb', line 87

def type_by_reference?
  @options[:type_by_reference] == true
end

#write(value) ⇒ Object

Write an object


32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# File 'lib/puppet/pops/serialization/serializer.rb', line 32

def write(value)
  case value
  when Integer, Float, String, true, false, nil
    @writer.write(value)
  when :default
    @writer.write(Extension::Default::INSTANCE)
  else
    index = @written[value.object_id]
    if index.nil?
      write_tabulated_first_time(value)
    else
      @writer.write(Extension::Tabulation.new(index))
    end
  end
end

#write_tabulated_first_time(value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

First time write of a tabulated object. This means that the object is written and then remembered. Subsequent writes of the same object will yield a write of a tabulation index instead.


103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
# File 'lib/puppet/pops/serialization/serializer.rb', line 103

def write_tabulated_first_time(value)
  case
  when value.instance_of?(Symbol),
      value.instance_of?(Regexp),
      value.instance_of?(SemanticPuppet::Version),
      value.instance_of?(SemanticPuppet::VersionRange),
      value.instance_of?(Time::Timestamp),
      value.instance_of?(Time::Timespan),
      value.instance_of?(Types::PBinaryType::Binary),
      value.is_a?(URI)
    push_written(value)
    @writer.write(value)
  when value.instance_of?(Array)
    push_written(value)
    start_array(value.size)
    value.each { |elem| write(elem) }
  when value.instance_of?(Hash)
    push_written(value)
    start_map(value.size)
    value.each_pair { |key, val| write(key); write(val) }
  when value.instance_of?(Types::PSensitiveType::Sensitive)
    start_sensitive
    write(value.unwrap)
  when value.instance_of?(Types::PTypeReferenceType)
    push_written(value)
    @writer.write(value)
  when value.is_a?(Types::PuppetObject)
    value._pcore_type.write(value, self)
  else
    impl_class = value.class
    type = Loaders.implementation_registry.type_for_module(impl_class)
    raise SerializationError, _("No Puppet Type found for %{klass}") % { klass: impl_class.name } unless type.is_a?(Types::PObjectType)
    type.write(value, self)
  end
end