class Protobuf::Field::FieldArray

def <<(val) 

def <<(val)
  super(normalize(val)) unless val.nil?
end

def []=(nth, val)


Public Instance Methods
# 
def []=(nth, val)
  super(nth, normalize(val)) unless val.nil?
end

def initialize(field)


Constructor
# 
def initialize(field)
  @field = field
end

def normalize(value)


Private Instance Methods
# 
def normalize(value)
  value = value.to_proto if value.respond_to?(:to_proto)
  raise TypeError unless @field.acceptable?(value)
  if @field.is_a?(::Protobuf::Field::EnumField)
    @field.type.fetch(value)
  elsif @field.is_a?(::Protobuf::Field::MessageField) && value.respond_to?(:to_hash)
    @field.type.new(value.to_hash)
  else
    value
  end
end

def push(val) 

def push(val)
  super(normalize(val)) unless val.nil?
end

def raise_type_error(val) 

def raise_type_error(val)
  error_text = <<-TYPE_ERROR
    Expected value of type '#{@field.type}'
    Got '#{val.class}' for protobuf field #{@field.name}
  TYPE_ERROR
  raise TypeError, error_text
end

def replace(val) 

def replace(val)
  raise_type_error(val) unless val.is_a?(Array)
  val = val.map! { |v| normalize(v) }
  super(val)
end

def to_hash_value

The value in this case would be an array.
Return a hash-representation of the given values for this field type. 
def to_hash_value
  self.map do |value|
    value.respond_to?(:to_hash_value) ? value.to_hash_value : value
  end
end

def to_s 

def to_s
  "[#{@field.name}]"
end

def unshift(val) 

def unshift(val)
  super(normalize(val)) unless val.nil?
end