class OvirtSDK4::Reader

def self.parse_boolean(text)
  return nil if text.nil?
  case text.downcase
  when 'false', '0'
    false
  when 'true', '1'
    true
  else
    raise Error, "The text '#{text}' isn't a valid boolean value."
  end
end

def self.parse_date(text)
  return nil if text.nil?
  begin
    DateTime.xmlschema(text)
  rescue ArgumentError
    raise Error, "The text '#{text}' isn't a valid date."
  end
end

def self.parse_decimal(text)
  return nil if text.nil?
  begin
    Float(text)
  rescue ArgumentError
    raise Error, "The text '#{text}' isn't a valid decimal value."
  end
end

def self.parse_enum(enum_module, text)
  return nil unless text
  values = enum_module.constants.map { |const| enum_module.const_get(const) }
  values.detect { |value| value.casecmp(text).zero? }
end

def self.parse_integer(text)
  return nil if text.nil?
  begin
    Integer(text, 10)
  rescue ArgumentError
    raise Error, "The text '#{text}' isn't a valid integer value."
  end
end

def self.read(source)
  # If the source is a string or IO object then create a XML reader from it:
  cursor = nil
  if source.is_a?(String) || source.is_a?(IO)
    cursor = XmlReader.new(source)
  elsif source.is_a?(XmlReader)
    cursor = source
  else
    raise ArgumentError, "Expected a 'String' or 'XmlReader', but got '#{source.class}'"
  end
  # Do the actual read, and make sure to always close the XML reader if we created it:
  begin
    # Do nothing if there aren't more tags:
    return nil unless cursor.forward
    # Select the specific reader according to the tag:
    tag = cursor.node_name
    reader = @readers[tag]
    raise Error, "Can't find a reader for tag '#{tag}'" if reader.nil?
    # Read the object using the specific reader:
    reader.call(cursor)
  ensure
    cursor.close if !cursor.nil? && !cursor.equal?(source)
  end
end

def self.read_boolean(reader)
  Reader.parse_boolean(reader.read_element)
end

def self.read_booleans(reader)
  reader.read_elements.map { |text| Reader.parse_boolean(text) }
end

def self.read_date(reader)
  Reader.parse_date(reader.read_element)
end

def self.read_dates(reader)
  reader.read_elements.map { |text| Reader.parse_date(text) }
end

def self.read_decimal(reader)
  Reader.parse_decimal(reader.read_element)
end

def self.read_decimals(reader)
  reader.read_elements.map { |text| Reader.parse_decimal(text) }
end

def self.read_enum(enum_module, reader)
  Reader.parse_enum(enum_module, reader.read_element)
end

def self.read_enums(enum_module, reader)
  reader.read_elements.map { |text| Reader.parse_enum(enum_module, text) }
end

def self.read_integer(reader)
  Reader.parse_integer(reader.read_element)
end

def self.read_integers(reader)
  reader.read_elements.map { |text| Reader.parse_integer(text) }
end

def self.read_string(reader)
  reader.read_element
end

def self.read_strings(reader)
  reader.read_elements
end

def self.register(tag, reader)
  @readers[tag] = reader
end