openHAB

Module: OpenHAB::Core::ValueCache

Defined in:
lib/openhab/core/value_cache.rb

Overview

Note:

Only the sharedCache is exposed in Ruby. For a private cache, simply use an instance variable. See Instance Variables.

Note:

Because every script or UI rule gets its own JRuby engine instance, you cannot rely on being able to access Ruby objects between them. Only objects that implement a Java interface that's part of Java or openHAB Core (such as Hash implements java.util.Map, or other basic datatypes) can be reliably stored and accessed from the shared cache. Likewise, you can use the cache to access data from other scripting languages, but they'll be all but useless in Ruby. It's best to stick to simple data types. If you're having troubles, serializing to_json before storing may help.

ValueCache is the interface used to access a shared cache available between scripts and/or rule executions.

While ValueCache looks somewhat like a Hash, it does not support iteration of the contained elements. So it's limited to strictly storing, fetching, or removing known elements.

Shared caches are not persisted between openHAB restarts. And in fact, if all scripts are unloaded that reference a particular key, that key is removed.

Examples:

shared_cache.compute_if_absent(:execution_count) { 0 }
shared_cache[:execution_count] += 1

See Also:

Instance Method Summary collapse

Instance Method Details

#[](key) ⇒ Object Also known as: store

See Also:



49
50
51
 
# File 'lib/openhab/core/value_cache.rb', line 49

def [](key)
  get(key)
end

#[]=(key, value) ⇒ Object

See Also:



65
66
67
 
# File 'lib/openhab/core/value_cache.rb', line 65

def []=(key, value)
  put(key, value)
end

#assoc(key) ⇒ Object

See Also:



109
110
111
112
113
114
115
 
# File 'lib/openhab/core/value_cache.rb', line 109

def assoc(key)
  [key,
   fetch(key) do
     # return nil directly, without storing a value to the cache
     return nil
   end]
end

#compute_if_absent(key) ⇒ Object

Compute and store new value for key if the key is absent. This method is atomic.

Parameters:

  • key (String)

Yield Returns:

  • (Object) —

    new value

Returns:

  • (Object) —

    new value or current value



60
61
62
 
# File 'lib/openhab/core/value_cache.rb', line 60

def compute_if_absent(key, &)
  get(key, &)
end

#delete(key) ⇒ Object

See Also:



71
72
73
74
75
76
77
78
79
 
# File 'lib/openhab/core/value_cache.rb', line 71

def delete(key)
  key = key.to_s # needed for remove below
  if block_given?
    fetch(key) do
      return yield(key)
    end
  end
  remove(key)
end

#dig(key, *identifiers) ⇒ Object

See Also:



118
119
120
121
 
# File 'lib/openhab/core/value_cache.rb', line 118

def dig(key, *identifiers)
  r = fetch(key) { return nil }
  r&.dig(*identifiers)
end

#fetch(key, *default_value) ⇒ Object

Examples:

shared_cache.fetch(:key_from_another_script) # raises NoKeyError

See Also:



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/openhab/core/value_cache.rb', line 86

def fetch(key, *default_value)
  if default_value.length > 1
    raise ArgumentError,
          "wrong number of arguments (given #{default_value.length + 1}, expected 0..1)"
  end

  if default_value.empty?
    key = key.to_s
    if block_given?
      get(key) do
        return yield(key)
      end
    else
      get(key) do
        raise KeyError.new("key not found: #{key.inspect}", key:)
      end
    end
  else
    get(key) { return default_value.first }
  end
end

#fetch_values(*keys, &block) ⇒ Object

See Also:



124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/openhab/core/value_cache.rb', line 124

def fetch_values(*keys, &block)
  result = []
  keys.each do |key|
    if block
      result << fetch(key, &block)
    else
      has_value = true
      value = fetch(key) { has_value = false }
      result << value if has_value
    end
  end
  result
end

#key?(key) ⇒ Boolean Also known as: has_key?, include?, member?

Returns:

  • (Boolean)

See Also:



139
140
141
 
# File 'lib/openhab/core/value_cache.rb', line 139

def key?(key)
  !!fetch(key) { return false }
end

#merge!(*other_hashes) ⇒ Object Also known as: update

See Also:



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/openhab/core/value_cache.rb', line 147

def merge!(*other_hashes)
  other_hashes.each do |hash|
    hash.each do |(k, v)|
      k = k.to_s
      if block_given?
        dup = true
        old_value = fetch(k) do
          dup = false
        end
        self[k] = dup ? yield(k, old_value, v) : v
      else
        self[k] = v
      end
    end
  end
  self
end

#slice(*keys) ⇒ Object

See Also:



167
168
169
170
171
172
173
174
 
# File 'lib/openhab/core/value_cache.rb', line 167

def slice(*keys)
  result = {}
  keys.each do |k|
    k = k.to_s
    result[k] = self[k] if key?(k)
  end
  result
end

#to_proc ⇒ Object

See Also:



177
178
179
 
# File 'lib/openhab/core/value_cache.rb', line 177

def to_proc
  ->(k) { self[k] }
end

#values_at(*keys) ⇒ Object

See Also:



182
183
184
185
186
 
# File 'lib/openhab/core/value_cache.rb', line 182

def values_at(*keys)
  keys.map do |k|
    self[k]
  end
end