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.

Parameters:

  • writer (AbstractWriter) —

    the writer that is used for writing primitive values

  • options ({String, Object}) (defaults to: EMPTY_HASH) —

    serialization options

Options Hash (options):

  • :type_by_reference (Boolean) —

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



19
20
21
22
23
24
25
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 19

def initialize(writer, options = EMPTY_HASH)
  # Hash#compare_by_identity is intentionally not used since we only need to map
  # object ids to their size and we don't want to store entire objects in memory
  @written = {}
  @writer = writer
  @options = options
end

Instance Attribute Details

#writer ⇒ Object (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.



13
14
15
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 13

def writer
  @writer
end

Instance Method Details

#finish ⇒ Object

Tell the underlying writer to finish



29
30
31
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 29

def finish
  @writer.finish
end

#inspect ⇒ Object 



99
100
101
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 99

def inspect
  to_s
end

#push_written(value) ⇒ Object 



81
82
83
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 81

def push_written(value)
  @written[value.object_id] = @written.size # rubocop:disable Lint/HashCompareByIdentity
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.

Parameters:

  • size (Integer) —

    the size of the array



55
56
57
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 55

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).

Parameters:

  • size (Integer) —

    the number of entries in the map



62
63
64
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 62

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

Parameters:

  • attr_count (Integer) —

    the number of attributes in the object



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

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

Parameters:

  • type_ref (String) —

    the name of the type

  • attr_count (Integer) —

    the number of attributes in the object



70
71
72
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 70

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

#start_sensitive ⇒ 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 sensitive object



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

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

#to_s ⇒ Object 



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

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

#type_by_reference? ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#write(value) ⇒ Object

Write an object

Parameters:

  • value (Object) —

    the object to write



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 36

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] # rubocop:disable Lint/HashCompareByIdentity
    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.

Parameters:

  • value (Object) —

    the value to write



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
138
139
140
141
 
# File 'lib/puppet/pops/serialization/serializer.rb', line 107

def write_tabulated_first_time(value)
  if 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)
  elsif value.instance_of?(Array)
    push_written(value)
    start_array(value.size)
    value.each { |elem| write(elem) }
  elsif value.instance_of?(Hash)
    push_written(value)
    start_map(value.size)
    value.each_pair { |key, val| write(key); write(val) }
  elsif value.instance_of?(Types::PSensitiveType::Sensitive)
    start_sensitive
    write(value.unwrap)
  elsif value.instance_of?(Types::PTypeReferenceType)
    push_written(value)
    @writer.write(value)
  elsif 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