class HexaPDF::DictionaryFields::Field

A dictionary field contains information about one field of a structured PDF object and this information comes directly from the PDF specification.

By incorporating this field information into HexaPDF it is possible to do many things automatically, like checking for the correct minimum PDF version to use or converting a date from its string representation to a Time object.

Attributes

allowed_values[R]

Returns an array with the allowed values for this field, or nil if the values are not constrained.

indirect[R]

Returns true if the value for this field needs to be an indirect object, false if it needs to be a direct object or nil if it can be either.

version[R]

Returns the PDF version that is required for this field.

Public Class Methods

converter_for(type) click to toggle source

Returns the converter for the given type specification.

The converter list is checked for a suitable converter from the front to the back. So if two converters could potentially be used for the same type, the one that appears earlier is used.

# File lib/hexapdf/dictionary_fields.rb, line 96
def self.converter_for(type)
  @converters.find {|converter| converter.usable_for?(type) }
end
converters() click to toggle source

Returns the list of available converter objects.

See ::converter_for for information on how this list is used.

# File lib/hexapdf/dictionary_fields.rb, line 87
def self.converters
  @converters ||= []
end
new(type, required: false, default: nil, indirect: nil, allowed_values: nil, version: nil) click to toggle source

Create a new Field object. See Dictionary::define_field for information on the arguments.

Depending on the type entry an appropriate field converter object is chosen from the available converters.

# File lib/hexapdf/dictionary_fields.rb, line 115
def initialize(type, required: false, default: nil, indirect: nil, allowed_values: nil,
               version: nil)
  @type = [type].flatten
  @type_mapped = false
  @required, @default, @indirect, @version = required, default, indirect, version
  @allowed_values = allowed_values && [allowed_values].flatten
  @converters = @type.map {|t| self.class.converter_for(t) }.compact
end

Public Instance Methods

convert(data, document) click to toggle source

Converts the data into a useful object if possible. Otherwise returns nil.

# File lib/hexapdf/dictionary_fields.rb, line 163
def convert(data, document)
  @converters.each do |converter|
    result = converter.convert(data, type, document)
    return result unless result.nil?
  end
  nil
end
default() click to toggle source

Returns a duplicated default value, automatically taking unduplicatable classes into account.

# File lib/hexapdf/dictionary_fields.rb, line 152
def default
  @default.dup
end
default?() click to toggle source

Returns true if a default value is available.

# File lib/hexapdf/dictionary_fields.rb, line 146
def default?
  !@default.nil?
end
required?() click to toggle source

Returns true if this field is required.

# File lib/hexapdf/dictionary_fields.rb, line 141
def required?
  @required
end
type() click to toggle source

Returns the array with valid types for this field.

# File lib/hexapdf/dictionary_fields.rb, line 125
def type
  return @type if @type_mapped
  @type.concat(@converters.flat_map(&:additional_types).compact)
  @type.map! do |type|
    if type.kind_of?(Symbol)
      HexaPDF::GlobalConfiguration.constantize('object.type_map', type)
    else
      type
    end
  end
  @type.uniq!
  @type_mapped = true
  @type
end
valid_object?(obj) click to toggle source

Returns true if the given object is valid for this field.

# File lib/hexapdf/dictionary_fields.rb, line 157
def valid_object?(obj)
  type.any? {|t| obj.kind_of?(t) } ||
    (obj.kind_of?(HexaPDF::Object) && type.any? {|t| obj.value.kind_of?(t) })
end