Class: TEF::ParameterStack::Stack

Inherits:
Object
  • Object
show all
Defined in:
lib/tef/ParameterStack/Stack.rb

Overview

Parameter Stack class.

This class contains all parameters that have been configured by Overrides. It provides a way to retrieve the currently valid coniguration, as well as letting the user (de)regsiter new Overrides.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Stack

Returns a new instance of Stack.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/tef/ParameterStack/Stack.rb', line 29

def initialize()
	@current_values   = {}
	@active_overrides = {}

	@changes = {}

	@override_list_mutex = Mutex.new()
	@override_list = []

	@recompute_blocks    = []
	@value_change_blocks = []

	@default_override = Override.new(self, -1);
end

Instance Attribute Details

#active_overrides ⇒ Hash (readonly)

Returns Hash of the overrides that have control over a given parameter key.

Returns:

  • (Hash) —

    Hash of the overrides that have control over a given parameter key.



27
28
29
 
# File 'lib/tef/ParameterStack/Stack.rb', line 27

def active_overrides
  @active_overrides
end

#changes ⇒ Hash (readonly)

Returns Hash whose keys specify which parameters have been changed since the last recompute cycle.

Returns:

  • (Hash) —

    Hash whose keys specify which parameters have been changed since the last recompute cycle.



23
24
25
 
# File 'lib/tef/ParameterStack/Stack.rb', line 23

def changes
  @changes
end

Instance Method Details

#[](key) ⇒ Object

Returns the currently configured parameter for the given key.

Returns:

  • Returns the currently configured parameter for the given key.



45
46
47
 
# File 'lib/tef/ParameterStack/Stack.rb', line 45

def [](key)
	@current_values[key]
end

#[]=(key, value) ⇒ Object

Set the default parameter for a given key.

Default parameters have a level of -1, meaning that any Override with priority >= 0 (the default) will claim the value.



53
54
55
 
# File 'lib/tef/ParameterStack/Stack.rb', line 53

def []=(key, value)
	@default_override[key] = value
end

#add_override(override) ⇒ Object 



195
196
197
198
199
200
 
# File 'lib/tef/ParameterStack/Stack.rb', line 195

def add_override(override)
	@override_list_mutex.synchronize do
		@override_list << override unless @override_list.include? override
		@override_list.sort!
	end
end

#keys ⇒ Object 



57
58
59
 
# File 'lib/tef/ParameterStack/Stack.rb', line 57

def keys
	@current_values.keys
end

#on_change(*filters, &block) ⇒ Object

Add a callback to be called during #process_changes.

The given block will be called if a change in a key specified by the filters occoured, and will be called during #process_changes.

This lets the user only act on changes, and act on them in bunches, rather than on every individual change.

Parameters:

  • filters (String, Regexp) —

    List of filters to use. Acts like a whitelist, can be a Regexp



87
88
89
90
91
92
93
94
 
# File 'lib/tef/ParameterStack/Stack.rb', line 87

def on_change(*filters, &block)
	filters = nil if filters.empty?

	@value_change_blocks << {
		block: block,
		filters: filters
	}
end

#on_recompute(*keys) {|key, value| ... } ⇒ Object

Add a callback for immediate parameter changes.

The given block will be called for any change of a parameter, so should be used sparingly. Recursive parameter setting should also be carefully avoided!

Parameters:

  • keys (Array) —

    Key whitelist to trigger on.

Yield Parameters:

  • key —

    Key that was changed.

  • value —

    New value of the key



70
71
72
73
74
75
 
# File 'lib/tef/ParameterStack/Stack.rb', line 70

def on_recompute(*keys, &block)
	@recompute_blocks << {
		block: block,
		keys: keys
	}
end

#override_claims(override, key) ⇒ Object

Check if an Override can claim a key.

This is mainly an internal function. It will check if the passed Override has permission to claim the given key, and will change the value accordingly.



110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/tef/ParameterStack/Stack.rb', line 110

def override_claims(override, key)
	return if !(@active_overrides[key].nil?) && (@active_overrides[key] > override)

	@active_overrides[key] = override;
	value = override[key];

	return if @current_values[key] == value

	@current_values[key] = value
	mark_key_change key
end

#process_changes ⇒ Object

Trigger processing of all #on_change callbacks.

Works best when triggered after all changes for a given time-tick have been performed, such as during a Sequencing::Player#after_exec callback.



183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/tef/ParameterStack/Stack.rb', line 183

def process_changes()
	change_list = @changes.keys

	@value_change_blocks.each do |block_cfg|
		next unless keys_match_filters change_list, block_cfg[:filters]

		block_cfg[:block].call()
	end

	@changes = {}
end

#recompute(keys) ⇒ Object

Recompute the owner of the list of keys. Mainly an internal function, used by an Override that is de-registering itself.



157
158
159
160
161
 
# File 'lib/tef/ParameterStack/Stack.rb', line 157

def recompute(keys)
	keys.each do |key|
		recompute_single key
	end
end

#recompute_single(key) ⇒ Object

Re-Calculate which Override is currently claiming a given key.

This method is mainly for internal work. It will iterate through the list of Overrides to find the next in line that wants to claim the given key. May be slow!



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/tef/ParameterStack/Stack.rb', line 128

def recompute_single(key)
	old_value = @current_values[key]

	found_override = false;

	@override_list_mutex.synchronize do
		@override_list.each do |override|
			next unless override.include? key

			@active_overrides[key] = override;
			@current_values[key]   = override[key];

			found_override = true;

			break;
		end
	end

	if !found_override
		@current_values.delete key
		@active_overrides.delete key
	end

	mark_key_change key if old_value != @current_values[key]
end

#remove_override(override) ⇒ Object 



202
203
204
205
206
207
208
209
210
 
# File 'lib/tef/ParameterStack/Stack.rb', line 202

def remove_override(override)
	return unless @override_list.include? override

	@override_list_mutex.synchronize do
		@override_list.delete override
	end

	recompute override.keys
end