class GObject::GValue

Represent a GValue. Example use:

“‘ruby gvalue = GValue::alloc gvalue.init GObject::GDOUBLE_TYPE gvalue.set 3.1415 value = gvalue.get # optional – drop any ref the gvalue had gvalue.unset “`

Lifetime is managed automatically. It doesn’t know about all GType values, but it does know the ones that libvips uses.

Public Class Methods

alloc ()

Source

# File lib/vips/gvalue.rb, line 100
def self.alloc
  # allocate memory
  memory = FFI::MemoryPointer.new GValue

  # make this alloc autorelease ... we mustn't release in
  # GValue::release, since we are used to wrap GValue pointers
  # made by other people
  pointer = FFI::Pointer.new GValue, memory

  # ... and wrap in a GValue
  GValue.new pointer
end

Allocate memory for a GValue and return a class wrapper. Memory will be freed automatically when it goes out of scope. The GValue is inited to 0, use {GValue.init} to set a type.

@return [GValue] a new gvalue set to 0

enum_from_nick (gtype, value)

Source

# File lib/vips/gvalue.rb, line 28
def self.enum_from_nick(gtype, value)
  value = value.to_s if value.is_a? Symbol

  if value.is_a? String
    # libvips expects "-" as a separator in enum names, but "_" is more
    # convenient for ruby, eg. :b_w
    value = Vips.vips_enum_from_nick "ruby-vips", gtype, value.tr("_", "-")
    if value == -1
      raise Vips::Error
    end
  end

  value
end

convert an enum value (str/symb/int) into an int ready for libvips

flags_from_nick (gtype, value)

Source

# File lib/vips/gvalue.rb, line 51
def self.flags_from_nick(gtype, value)
  if value.is_a? String
    # libvips will parse strings like "sub|up" etc.
    name = value.tr("_", "-")
    value = Vips.vips_flags_from_nick "ruby-vips", gtype, name
  else
    value = [value] if !value.is_a? Array

    # convert each item to a set of bits, OR them together
    result = 0
    value.map do |item|
      item = item.to_s if item.is_a? Symbol
      if item.is_a? String
        name = item.tr("_", "-")
        item = Vips.vips_flags_from_nick "ruby-vips", gtype, name
        if item == -1
          raise Vips::Error
        end
      end

      result |= item
    end

    value = result
  end

  value
end

convert an flags value (array | str/symb/int) into an int ready for libvips

from_nick (gtype, value)

Source

# File lib/vips/gvalue.rb, line 45
def self.from_nick(gtype, value)
  GValue.enum_from_nick(gtype, value)
end

compatibility … we used to call it this, perhaps someone has used this internal method

release (ptr)

Source

# File lib/vips/gvalue.rb, line 90
def self.release ptr
  # GLib::logger.debug("GObject::GValue::release") {"ptr = #{ptr}"}
  ::GObject.g_value_unset ptr
end

to_nick (gtype, enum_value)

Source

# File lib/vips/gvalue.rb, line 81
def self.to_nick(gtype, enum_value)
  enum_name = Vips.vips_enum_nick gtype, enum_value
  if enum_name.nil?
    raise Vips::Error
  end

  enum_name.to_sym
end

convert an int enum back into a symbol

Public Instance Methods

get ()

Source

# File lib/vips/gvalue.rb, line 209
def get
  gtype = self[:gtype]
  fundamental = ::GObject.g_type_fundamental gtype
  result = nil

  case gtype
  when GBOOL_TYPE
    result = ::GObject.g_value_get_boolean(self) != 0

  when GINT_TYPE
    result = ::GObject.g_value_get_int self

  when GUINT64_TYPE
    result = ::GObject.g_value_get_uint64 self

  when GDOUBLE_TYPE
    result = ::GObject.g_value_get_double self

  when GSTR_TYPE
    result = ::GObject.g_value_get_string self

  when Vips::REFSTR_TYPE
    len = Vips::SizeStruct.new
    result = ::Vips.vips_value_get_ref_string self, len

  when Vips::ARRAY_INT_TYPE
    len = Vips::IntStruct.new
    array = Vips.vips_value_get_array_int self, len
    result = array.get_array_of_int32 0, len[:value]

  when Vips::ARRAY_DOUBLE_TYPE
    len = Vips::IntStruct.new
    array = Vips.vips_value_get_array_double self, len
    result = array.get_array_of_double 0, len[:value]

  when Vips::ARRAY_IMAGE_TYPE
    len = Vips::IntStruct.new
    array = Vips.vips_value_get_array_image self, len
    result = array.get_array_of_pointer 0, len[:value]
    result.map! do |pointer|
      ::GObject.g_object_ref pointer
      Vips::Image.new pointer
    end

  when Vips::BLOB_TYPE
    len = Vips::SizeStruct.new
    array = Vips.vips_value_get_blob self, len
    result = array.get_bytes 0, len[:value]

  else
    case fundamental
    when GFLAGS_TYPE
      result = ::GObject.g_value_get_flags self

    when GENUM_TYPE
      enum_value = ::GObject.g_value_get_enum(self)
      result = GValue.to_nick self[:gtype], enum_value

    when GOBJECT_TYPE
      obj = ::GObject.g_value_get_object self
      # g_value_get_object() does not add a ref ... we need to add
      # one to match the unref in gobject release
      ::GObject.g_object_ref obj
      result = Vips::Image.new obj

    else
      raise Vips::Error, "unimplemented gtype for get: " \
        "#{::GObject.g_type_name gtype} (#{gtype})"
    end
  end

  # GLib::logger.debug("GObject::GValue.get") {
  #     "result = #{result.inspect[0..50]}"
  # }

  result
end

Get the value of a GValue. The value is converted to a Ruby type in the obvious way.

@return [Any] the value held by the GValue

init (gtype)

Source

# File lib/vips/gvalue.rb, line 116
def init gtype
  ::GObject.g_value_init self, gtype
end

Set the type of thing a gvalue can hold.

@param gtype [GType] the type of thing this GValue can hold.

set (value)

Source

# File lib/vips/gvalue.rb, line 124
def set value
  # GLib::logger.debug("GObject::GValue.set") {
  #     "value = #{value.inspect[0..50]}"
  # }

  gtype = self[:gtype]
  fundamental = ::GObject.g_type_fundamental gtype

  case gtype
  when GBOOL_TYPE
    ::GObject.g_value_set_boolean self, (value ? 1 : 0)

  when GINT_TYPE
    ::GObject.g_value_set_int self, value

  when GUINT64_TYPE
    ::GObject.g_value_set_uint64 self, value

  when GDOUBLE_TYPE
    ::GObject.g_value_set_double self, value

  when GSTR_TYPE
    ::GObject.g_value_set_string self, value

  when Vips::REFSTR_TYPE
    ::Vips.vips_value_set_ref_string self, value

  when Vips::ARRAY_INT_TYPE
    value = [value] unless value.is_a? Array

    Vips.vips_value_set_array_int self, nil, value.length
    ptr = Vips.vips_value_get_array_int self, nil
    ptr.write_array_of_int32 value

  when Vips::ARRAY_DOUBLE_TYPE
    value = [value] unless value.is_a? Array

    # this will allocate an array in the gvalue
    Vips.vips_value_set_array_double self, nil, value.length

    # pull the array out and fill it
    ptr = Vips.vips_value_get_array_double self, nil

    ptr.write_array_of_double value

  when Vips::ARRAY_IMAGE_TYPE
    value = [value] unless value.is_a? Array

    Vips.vips_value_set_array_image self, value.length
    ptr = Vips.vips_value_get_array_image self, nil
    ptr.write_array_of_pointer value

    # the gvalue needs a ref on each of the images
    value.each { |image| ::GObject.g_object_ref image }

  when Vips::BLOB_TYPE
    len = value.bytesize
    ptr = GLib.g_malloc len
    Vips.vips_value_set_blob self, GLib::G_FREE, ptr, len
    ptr.write_bytes value

  else
    case fundamental
    when GFLAGS_TYPE
      flags_value = GValue.flags_from_nick(self[:gtype], value)
      ::GObject.g_value_set_flags self, flags_value

    when GENUM_TYPE
      enum_value = GValue.enum_from_nick(self[:gtype], value)
      ::GObject.g_value_set_enum self, enum_value

    when GOBJECT_TYPE
      ::GObject.g_value_set_object self, value

    else
      raise Vips::Error, "unimplemented gtype for set: " \
        "#{::GObject.g_type_name gtype} (#{gtype})"
    end
  end
end

Set the value of a GValue. The value is converted to the type of the GValue, if possible.

@param value [Any] The value to set

unset ()

Source

# File lib/vips/gvalue.rb, line 291
def unset
  ::GObject.g_value_unset self
end

Clear the thing held by a GValue.

This happens automatically when a GValue is GCed, but this method can be handy if you need to drop a reference explicitly for some reason.