--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/configurationengine/source/cone/storage/persistentdictionary.py Thu Mar 11 17:04:37 2010 +0200
@@ -0,0 +1,222 @@
+#
+# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+# All rights reserved.
+# This component and the accompanying materials are made available
+# under the terms of "Eclipse Public License v1.0"
+# which accompanies this distribution, and is available
+# at the URL "http://www.eclipse.org/legal/epl-v10.html".
+#
+# Initial Contributors:
+# Nokia Corporation - initial contribution.
+#
+# Contributors:
+#
+# Description:
+#
+
+from cone.public import persistence, exceptions, api, utils
+
+def dumps(obj):
+ return DictWriter().dumps(obj)
+
+def loads(dictstr):
+ # convert the dict string with eval to actual dict
+ return DictReader().loads(eval(dictstr))
+
+class DictWriter(persistence.ConeWriter):
+ """
+ """
+
+ def dumps(self, obj):
+ """
+ @param obj: The object
+ """
+ writer = get_writer_for_class(obj.__class__.__name__)
+ return {obj.__class__.__name__: writer.dumps(obj)}
+
+
+class DictReader(persistence.ConeReader):
+ """
+ """
+ class_type = "Dict"
+
+ def loads(self, dict):
+ """
+ @param dict: The dictianary which to read. reads only the first object.
+ """
+ classname = dict.keys()[0]
+ reader = get_reader_for_elem(classname)
+ return reader.loads(dict)
+
+
+class GenericWriter(DictWriter):
+ """
+ """
+
+ def dumps(self, obj):
+ """
+ @param obj: The Configuration object
+ """
+ dict = {'dict': todict(obj)}
+ for child in obj._objects():
+ writer = get_writer_for_class(child.__class__.__name__)
+ chd = writer.dumps(child)
+ if not dict.has_key('children'):
+ dict['children'] = []
+ dict['children'].append({child.__class__.__name__: chd})
+ return dict
+
+ @classmethod
+ def supported_class(cls, classname):
+ """
+ Class method to determine if this DictWriter supports writing
+ of the given class name
+ """
+ try:
+ cls = get_class(classname)
+ return True
+ except exceptions.IncorrectClassError:
+ return False
+
+
+class GenericReader(DictReader):
+ """
+ """
+
+ @classmethod
+ def supported_elem(cls, elemname, parent=None):
+ """
+ Class method to determine if this DictWriter supports reading
+ of the given elem name
+ """
+ try:
+ cls = get_class(elemname)
+ return True
+ except exceptions.IncorrectClassError:
+ return False
+
+ def __init__(self):
+ pass
+
+ def loads(self, dict):
+ """
+ @param obj: The Configuration object
+ """
+
+ (classname,objdata) = dict.popitem()
+ obj = get_class(classname)()
+ objdict = objdata.get('dict',{})
+ for membername in objdict.keys():
+ try:
+ setattr(obj, membername, objdict[membername])
+ except AttributeError:
+ # read only attributes cannot be set
+ pass
+ obj._name = utils.resourceref.to_objref(obj.ref)
+
+ #container.ObjectContainer.__init__(obj,utils.resourceref.to_dottedref(obj.ref))
+ for child in objdata.get('children',[]):
+ classname = child.keys()[0]
+ reader = get_reader_for_elem(classname)
+ childobj = reader.loads(child)
+ obj.add(childobj)
+ return obj
+
+
+class ConfigurationProxyWriter(DictWriter):
+ """
+ """
+ def dumps(self, obj):
+ """
+ @param obj: The Configuration object
+ """
+ dict = {'dict': todict(obj)}
+ return dict
+
+ @classmethod
+ def supported_class(cls, classname):
+ """
+ Class method to determine if this DictWriter supports writing
+ of the given class name
+ """
+ if classname=="ConfigurationProxy":
+ return True
+ else:
+ return False
+
+
+class ConfigurationProxyReader(DictReader):
+ """
+ """
+ def loads(self, dict):
+ """
+ @param obj: The Configuration object
+ """
+ (classname,objdata) = dict.popitem()
+ obj = api.ConfigurationProxy("")
+ obj.__dict__.update(objdata.get('dict',{}))
+ obj.set('_name',utils.resourceref.to_objref(obj.path))
+ return obj
+
+ @classmethod
+ def supported_elem(cls, elemname, parent=None):
+ """
+ Class method to determine if this DictWriter supports reading
+ of the given elem name
+ """
+ if elemname=="ConfigurationProxy":
+ return True
+ else:
+ return False
+
+
+def get_class(elemname):
+ """
+ Get a correct class from a element name.
+ """
+ if elemname=="Configuration":
+ return api.Configuration
+ elif elemname=="CompositeConfiguration":
+ return api.CompositeConfiguration
+ elif elemname=="Feature":
+ return api.Feature
+ elif elemname=="Data":
+ return api.Data
+ elif elemname=="DataContainer":
+ return api.DataContainer
+ elif elemname=="Base":
+ return api.Base
+ else:
+ raise exceptions.IncorrectClassError("Could not find a class for name %s!" % elemname)
+
+def get_reader_for_elem(classname):
+ for reader in DictReader.__subclasses__():
+ if reader.supported_elem(classname):
+ return reader()
+ raise exceptions.ConePersistenceError("No reader for given class found!")
+
+def get_writer_for_class(classname):
+ for writer in DictWriter.__subclasses__():
+ if writer.supported_class(classname):
+ return writer ()
+ raise exceptions.ConePersistenceError("No writer for given class found! %s" % classname)
+
+def todict(obj):
+ """
+ Helper function to push all non internal data to a dictionary
+ """
+ dict = {}
+ fromdict = obj._dict()
+ for member in fromdict:
+ if member.startswith("_"):
+ # skip internals
+ continue
+ value = getattr(obj,member)
+ if isinstance(value,str):
+ dict[member] = value
+ continue
+ if isinstance(value,int):
+ dict[member] = value
+ continue
+ return dict
+