def setValues(self, address, values, use_as_default=False):
''' Sets the requested values of the datastore
:param address: The starting address
:param values: The new values to be set
:param use_as_default: Use the values as default
'''
if isinstance(values, dict):
new_offsets = list(
set(list(values.keys())) - set(list(self.values.keys())))
if new_offsets and not self.mutable:
raise ParameterException("Offsets {} not "
"in range".format(new_offsets))
self._process_values(values)
else:
if not isinstance(values, list):
values = [values]
for idx, val in enumerate(values):
if address + idx not in self.values and not self.mutable:
raise ParameterException("Offset {} not "
"in range".format(address + idx))
self.values[address + idx] = val
if not self.address:
self.address = get_next(iterkeys(self.values), None)
if use_as_default:
for idx, val in iteritems(self.values):
self.default_value[idx] = val
def validate(self, address, count=1):
''' Checks to see if the request is in range
:param address: The starting address
:param count: The number of values to test for
:returns: True if the request in within range, False otherwise
'''
if count == 0: return False
handle = set(range(address, address + count))
return handle.issubset(set(iterkeys(self.values)))
def validate(self, address, count=1):
''' Checks to see if the request is in range
:param address: The starting address
:param count: The number of values to test for
:returns: True if the request in within range, False otherwise
'''
if count == 0:
return False
handle = set(range(address, address + count))
return handle.issubset(set(iterkeys(self.values)))
def __init__(self, values):
''' Initializes the datastore
Using the input values we create the default
datastore value and the starting address
:param values: Either a list or a dictionary of values
'''
if isinstance(values, dict):
self.values = values
elif hasattr(values, '__iter__'):
self.values = dict(enumerate(values))
else: raise ParameterException(
"Values for datastore must be a list or dictionary")
self.default_value = get_next(itervalues(self.values)).__class__()
self.address = get_next(iterkeys(self.values))
def __init__(self, values):
''' Initializes the datastore
Using the input values we create the default
datastore value and the starting address
:param values: Either a list or a dictionary of values
'''
if isinstance(values, dict):
self.values = values
elif hasattr(values, '__iter__'):
self.values = dict(enumerate(values))
else: raise ParameterException(
"Values for datastore must be a list or dictionary")
self.default_value = get_next(itervalues(self.values)).__class__()
self.address = get_next(iterkeys(self.values))
def __init__(self, values=None, mutable=True):
"""
Initializes a sparse datastore. Will only answer to addresses
registered, either initially here, or later via setValues()
:param values: Either a list or a dictionary of values
:param mutable: The data-block can be altered later with setValues(i.e add more blocks)
If values are list , This is as good as sequential datablock.
Values as dictionary should be in {offset: <values>} format, if values
is a list, a sparse datablock is created starting at offset with the length of values.
If values is a integer, then the value is set for the corresponding offset.
"""
self.values = {}
self._process_values(values)
self.mutable = mutable
self.default_value = self.values.copy()
self.address = get_next(iterkeys(self.values), None)
def __iter__(self):
''' Iterater over the current managed transactions
:returns: An iterator of the managed transactions
'''
return iterkeys(self.transactions)
def testSerializingToString(self):
for request in iterkeys(self.write):
self.assertTrue(str(request) != None)
def __iter__(self):
""" Iterater over the current managed transactions
:returns: An iterator of the managed transactions
"""
return iterkeys(self.transactions)
def testSerializingToString(self):
for request in iterkeys(self.request_read):
self.assertTrue(str(request) != None)
for request in iterkeys(self.response_read):
self.assertTrue(str(request) != None)
def testSerializingToString(self):
for request in iterkeys(self.write):
self.assertTrue(str(request) != None)
def testSerializingToString(self):
for request in iterkeys(self.request_read):
self.assertTrue(str(request) != None)
for request in iterkeys(self.response_read):
self.assertTrue(str(request) != None)
