# class PG::BasicTypeRegistry::CoderMap

An instance of this class stores the coders that should be used for a given wire format (text or binary) and type cast direction (encoder or decoder).

### Constants

DONT_QUOTE_TYPES

  Hash of text types that don't require quotation, when used within composite types.

      type.name => true

### Attributes

coders[R]
coders_by_name[R]
coders_by_oid[R]
typenames_by_oid[R]

### Public Class Methods

new(result, coders_by_name, format, arraycoder) click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 38
    def initialize(result, coders_by_name, format, arraycoder)
            coder_map = {}

            _ranges, nodes = result.partition { |row| row['typinput'] == 'range_in' }
            leaves, nodes = nodes.partition { |row| row['typelem'].to_i == 0 }
            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }

            # populate the enum types
            _enums, leaves = leaves.partition { |row| row['typinput'] == 'enum_in' }
            # enums.each do |row|
            #    coder_map[row['oid'].to_i] = OID::Enum.new
            # end

            # populate the base types
            leaves.find_all { |row| coders_by_name.key?(row['typname']) }.each do |row|
                    coder = coders_by_name[row['typname']].dup
                    coder.oid = row['oid'].to_i
                    coder.name = row['typname']
                    coder.format = format
                    coder_map[coder.oid] = coder
            end

            _records_by_oid = result.group_by { |row| row['oid'] }

            # populate composite types
            # nodes.each do |row|
            #    add_oid row, records_by_oid, coder_map
            # end

            if arraycoder
                    # populate array types
                    arrays.each do |row|
                            elements_coder = coder_map[row['typelem'].to_i]
                            next unless elements_coder

                            coder = arraycoder.new
                            coder.oid = row['oid'].to_i
                            coder.name = row['typname']
                            coder.format = format
                            coder.elements_type = elements_coder
                            coder.needs_quotation = !DONT_QUOTE_TYPES[elements_coder.name]
                            coder_map[coder.oid] = coder
                    end
            end

            # populate range types
            # ranges.find_all { |row| coder_map.key? row['rngsubtype'].to_i }.each do |row|
            #    subcoder = coder_map[row['rngsubtype'].to_i]
            #    range = OID::Range.new subcoder
            #    coder_map[row['oid'].to_i] = range
            # end

            @coders = coder_map.values
            @coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }
            @coders_by_oid = @coders.inject({}){|h, t| h[t.oid] = t; h }
            @typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }
    end

### Public Instance Methods

coder_by_name(name) click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 101
    def coder_by_name(name)
            @coders_by_name[name]
    end

coder_by_oid(oid) click to toggle source

    # File lib/pg/basic_type_mapping.rb, line 105
    def coder_by_oid(oid)
            @coders_by_oid[oid]
    end