This is a helper to make Component.GetState easy to implement. More...
Methods defined here: | |
def | __eq__ |
def | __init__ |
Class methods defined here: | |
def | Ignore |
def | Round |
Data descriptors defined here: | |
def | __dict__ |
dictionary for instance variables (if defined) | |
def | __weakref__ |
list of weak references to the object (if defined) |
This is a helper to make Component.GetState easy to implement.
Simply return a new ComponentState with a key value list of tuples. You may also specify specific options for specific keys. For anything you may specific ComponentState.Ignore to have it not be included in the state. For floating point values you may give a rounding value:
def GetState( self ): return ComponentState( ( ( 'value1', self.value1 ), ( 'value2', self.value2 ) ), value2=ComponentState.Round(1.0/16.0) )
Or, if you use StateAccessor: def GetState( self ): return ComponentState( self, value2=ComponentState.Round(1.0/16.0), value3=ComponentState.Ignore )
Remember that State is all about whether or not process is needed. So don't include things in the state that don't affect process. That's what ComponentState.Ignore is there to help with.
Aside from ComponentState.Round and ComponentState.Ignore you may specify any callable (such as a function or lambda) which takes the value as an argument and returns a value. Examples include:
To ignore something, just always return None. def ignore( x ): return None
To round something: def round_sixteenths( x ): round( val*(1.0/(1.0/16.0)), 0 ) * (1.0/(1.0/16.0))
To make a copy of a class instance, just use python's copy module: import copy copy.copy
The purpose of these callables is to mutate the value such that if you ignore any differences that won't show differences in process.
def ComponentState.ComponentState.__init__ | ( | args | ) |
values - Either 'self' if you used StateAccessor. Or a list of two-tuples. The two-tuples are ( "key", value ), where value can be any python type that can compare it's equality. **options - You can specify keyword arguments where the keyword is a key in your values list (or something you serialize if you used StateAccessor) and its value can be: - A floating point value to round to if it's a float - ComponentState.Ignore if you'd like this value to not be used as a part of the state. This one is especially useful if you use StateAccessor and serialize some properties that won't affect process.
def ComponentState.ComponentState.__dict__ | ( | args | ) |
dictionary for instance variables (if defined)
def ComponentState.ComponentState.__eq__ | ( | args | ) |
__eq__(args)
def ComponentState.ComponentState.__weakref__ | ( | args | ) |
list of weak references to the object (if defined)
def ComponentState.ComponentState.Ignore | ( | args | ) |
Ignore(args)
builtin.type_cls_m Class Methods from builtin.type
def ComponentState.ComponentState.Round | ( | args | ) |
Round(args)
builtin.type_cls_m Class Methods from builtin.type