Class: GVariant

Inherits:

Object

• Object
• GVariant

Defined in:

lib/gvariant.rb

Class Method Summary

• .next_type(signature, index) ⇒ Object
• .parse_type(typestr) ⇒ Object
• .read(typestr, buf) ⇒ Object
• .write(typestr, value) ⇒ 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 390

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

Class Method Details

.next_type(signature, index) ⇒ Object

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

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', 'h'
    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(typestr) ⇒ Object

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

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

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

  type
end

.read(typestr, buf) ⇒ Object

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

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

.write(typestr, value) ⇒ Object

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

def self.write(typestr, value)
  type = parse_type(typestr)
  type.write(value)
end