Class: GVariant

Inherits:

Object

• Object
• GVariant

Defined in:

lib/gvariant.rb

Class Method Summary

• .next_type(signature, index) ⇒ Object
• .parse_type(str) ⇒ Object
• .read(typestr, buffer) ⇒ Object

Instance Method Summary

• #initialize(typestr, buffer) ⇒ GVariant constructor

  A new instance of GVariant.

Constructor Details

#initialize(typestr, buffer) ⇒ GVariant

Returns a new instance of GVariant.

# File 'lib/gvariant.rb', line 277

def initialize(typestr, buffer)
  @typestr, @buffer = typestr, buffer
end

Class Method Details

.next_type(signature, index) ⇒ Object

# File 'lib/gvariant.rb', line 281

def self.next_type(signature, index)

  case signature[index]
  when 'y'
    GVariantByteType.new
  when 'n'
    GVariantSignedShortType.new
  when 'q'
    GVariantUnsignedShortType.new
  when 'i'
    GVariantSignedIntType.new
  when 'u'
    GVariantUnsignedIntType.new
  when 'x'
    GVariantSignedLongType.new
  when 't'
    GVariantUnsignedLongType.new
  when 'd'
    GVariantDoubleType.new
  when 'b'
    GVariantBooleanType.new
  when 's', 'g', 'o'
    GVariantStringType.new(signature[index])
  when 'v'
    GVariantVariantType.new
  when 'm'
    maybe_element = next_type(signature, index + 1)
    raise ArgumentError.new("Invalid type string") unless maybe_element
    GVariantMaybeType.new(signature[index, maybe_element.id.length + 1], maybe_element)
  when 'a'
    array_element = next_type(signature, index + 1)
    raise ArgumentError.new("Invalid type string") unless array_element
    GVariantArrayType.new(signature[index, array_element.id.length + 1], array_element)
  when '{'
    key_element = next_type(signature, index + 1)
    value_element = next_type(signature, index + 1 + key_element.id.length)
    raise ArgumentError.new("Invalid type string") unless key_element && value_element
    GVariantDictionaryType.new(signature[index, key_element.id.length + value_element.id.length + 2], key_element, value_element)
  when '('
    sig_end = index + 1
    elements = []

    while signature[sig_end] != ')' do
      e = next_type(signature, sig_end)
      sig_end += e.id.length
      elements << e
    end

    GVariantTupleType.new(signature[index..sig_end], elements)
  end
end

.parse_type(str) ⇒ Object

# File 'lib/gvariant.rb', line 333

def self.parse_type(str)
  type = next_type(str, 0)

  if type.nil? || type.id.length != str.length
    raise ArgumentError.new("Invalid type string: #{str}")
  end

  type
end

.read(typestr, buffer) ⇒ Object

# File 'lib/gvariant.rb', line 343

def self.read(typestr, buffer)
  buffer = buffer.pack("C*") if buffer.is_a? Array
  buffer.freeze if RUBY_VERSION >= '2.1.0'
  type = parse_type(typestr)
  type.read(buffer)
end