Class: EPIC::HandleValue

Inherits:

Object

• Object
• EPIC::HandleValue

show all

Defined in:

src/epic_handlevalue.rb

Overview

Instance Attribute Summary (collapse)

• - (Boolean) admin_read

  Is the administrator allowed to read this handle value?.

• - (Boolean) admin_write

  Is the administrator allowed to overwrite this handle value?.

• - (String with Encoding::ASCII_8BIT) data

  The binary data in this handle value.

• - (HDLLIB::HandleValue) handle_value readonly

  The Java Object wrapped by self.

• - (Integer) idx

  The index of this handle value.

• - (Array, ...) parsed_data

  Accesses the data in this handle value, just like #data.

• - (Boolean) pub_read

  Is the world allowed to read this handle value?.

• - (Boolean) pub_write

  Is the world allowed to overwrite this handle value?.

• - (Array< Hash{ :idx => Integer, :handle => Integer } >) refs

  References in this handle value.

• - (Integer) timestamp

  The timestamp of the last modification of this handle value, in seconds since epoch.

• - (Integer) ttl

  The time-to-live of this handle value.

• - (0 or 1) ttl_type

  Type of attribute #ttl.

• - (String) type

  The type of this handle value.

Class Method Summary (collapse)

• + (void) map_java(ruby_name, java_name)

  Meta programming helper method.

• + (void) map_java_bytes(ruby_name, java_name, encoding = Encoding::UTF_8)

  Meta programming helper method.

Instance Method Summary (collapse)

• - (HandleValue) initialize(dbrow = nil) constructor

  A new instance of HandleValue.

164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

# File 'src/epic_handlevalue.rb', line 164

def initialize dbrow = nil
  # super path
  # matches = %r{/([^/]+/[^/]+)/(\d+)\z}.match path
  # raise "Unexpected path: #{path}" unless matches
  # @handle = matches[1].to_path.unescape
  # @idx = matches[2].to_i
  @handle_value = HS::HDLLIB::HandleValue.new
  if dbrow
    self.idx       = dbrow[:idx].to_i
    self.type      = dbrow[:type].to_s
    self.data      = dbrow[:data].to_s
    self.ttl_type  = dbrow[:ttl_type].to_i
    self.ttl       = dbrow[:ttl].to_i
    self.timestamp = dbrow[:timestamp].to_i
    @handle_value.setReferences(
      dbrow[ :refs ].split("\t").collect do
        |ref|
        ref = ref.split ':', 2
        HS::HDLLIB::ValueReference.new(
          ref[1].to_java_bytes,
          ref[0].to_i
        )
      end.to_java HS::HDLLIB::ValueReference
    )
    self.admin_read  = dbrow[:admin_read]  && 0 != dbrow[:admin_read]
    self.admin_write = dbrow[:admin_write] && 0 != dbrow[:admin_write]
    self.pub_read    = dbrow[:pub_read]    && 0 != dbrow[:pub_read]
    self.pub_write   = dbrow[:pub_write]   && 0 != dbrow[:pub_write]
  else
    self.timestamp = Time.new.to_i
  end
end

117

# File 'src/epic_handlevalue.rb', line 117

map_java :admin_read,  :AdminCanRead

121

# File 'src/epic_handlevalue.rb', line 121

map_java :admin_write, :AdminCanWrite

94

# File 'src/epic_handlevalue.rb', line 94

map_java_bytes :data, :Data, Encoding::ASCII_8BIT

134
135
136

# File 'src/epic_handlevalue.rb', line 134

def handle_value
  @handle_value
end

97

# File 'src/epic_handlevalue.rb', line 97

map_java :idx, :Index

228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

# File 'src/epic_handlevalue.rb', line 228

def parsed_data
  nicetype = type.gsub /\W+/, '_'
  if HS.respond_to? :unpack_#{nicetype}"
    HS.send :unpack_#{nicetype}", self.data
  else
    begin
      retval = self.data.encode( Encoding::UTF_8, Encoding::UTF_8 )
      if %r{[\x00-\x08\x0B\x0C\x0E-\x1F]}.match(retval) ||
         self.data != retval.encode( Encoding::ASCII_8BIT, Encoding::ASCII_8BIT )
        nil
      else
        retval
      end
    rescue
      nil
    end
  end
end

125

# File 'src/epic_handlevalue.rb', line 125

map_java :pub_read,    :AnyoneCanRead

129

# File 'src/epic_handlevalue.rb', line 129

map_java :pub_write,   :AnyoneCanWrite

140
141
142
143
144
145

# File 'src/epic_handlevalue.rb', line 140

def refs
  @handle_value.getReferences.to_a.collect do
    |ref|
    { :idx => ref.index, :handle => String.from_java_bytes( ref.handle ) }
  end
end

113

# File 'src/epic_handlevalue.rb', line 113

map_java :timestamp, :Timestamp

100

# File 'src/epic_handlevalue.rb', line 100

map_java :ttl, :TTL

108

# File 'src/epic_handlevalue.rb', line 108

map_java :ttl_type, :TTLType

91

# File 'src/epic_handlevalue.rb', line 91

map_java_bytes :type, :Type

# Create a Ruby attribute "timestamp" which is mapped
# to Java methods getTimestamp() and setTimestamp():
map_java_bytes :timestamp, :Timestamp

42
43
44
45
46
47
48
49
50
51

# File 'src/epic_handlevalue.rb', line 42

def self.map_java ruby_name, java_name
  define_method ruby_name do
    @handle_value.send( :get#{java_name}" )
  end
  define_method :#{ruby_name}=" do
    |value|
    @handle_value.send( :set#{java_name}", value )
    value
  end
end

# Create a Ruby attribute "data" which is mapped
# to Java methods getData() and setData():
map_java_bytes :data, :Data, Encoding::BINARY

72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

# File 'src/epic_handlevalue.rb', line 72

def self.map_java_bytes ruby_name, java_name, encoding = Encoding::UTF_8
  define_method ruby_name do
    String.from_java_bytes(
      @handle_value.send( :get#{java_name}" )
    ).force_encoding(encoding)
  end
  define_method :#{ruby_name}=" do
    |value|
    @handle_value.send(
      :set#{java_name}",
      value.force_encoding(Encoding::ASCII_8BIT).to_java_bytes
    )
    value
  end
end