#

# 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: 

#

"""

Container classes.

Mainly internal classed that the public data model uses internally.

"""

import re

import pickle

import logging

def object_container_filter(obj,**kwargs):

    """ Create a list of filter functions for each argument """ 

    filters=[]

    if kwargs.has_key('name'):

        filters.append(lambda x: re.match(kwargs.get('name'), x._name))

    if kwargs.has_key('path'):

        filters.append(lambda x: re.match(kwargs.get('path'), x._path()))

    if kwargs.has_key('type'):

        filters.append(lambda x: isinstance(x, kwargs.get('type')))

    if kwargs.has_key('filters'):

        filters += kwargs.get('filters')

    ret = []

    for sobj in utils.get_list(obj):

        if utils.filter(obj,filters):

            ret.append(sobj)

    return ret

def _apply_filter(obj,filters):

    """ Create a list of filter functions for each argument """ 

    if utils.filter(obj,filters):

        return [obj]

    else:

        return []

""" object container adding policies """

REPLACE = 0

APPEND = 1

PREPEND = 2

ERROR = 3

class DataContainer(object):

    """

    Class for data containers. 

    Container is a data storage that can hold several keys, where each key is unique. Each key however 

    can hold several values, where the active value is the last one added. 

    Example:

    data = {'key1' :[1,2,3,4], 

            'key2' :['foo','bar],

            'key3' :['testing'],

            'path/to/key' :['some','value','in','here','too']}

    The active values for keys are the last ones in the array. E.g. key1 = 4.

    """

    def __init__(self):

        self.data = {}

    def list_keys(self):

        """

        List all keys of the DataStorage.

        """

        return self.data.keys()

    def add_value(self,key,value):

        """

        Add the value as a topmost item for the given key.

        @param key: name for the key to store the data.

        @param value: the value to store.  

        """

        if self.data.has_key(key):

            self.data[key].append(value)

        else:

            self.data[key] = [value]

        return

    def remove_value(self,key,value):

        """

        remove individual value of the key value array

        """

        self.data[key].remove(value)

        return 

    def remove_key(self,key):

        del self.data[key]

        return

    def get_value(self,key):

        """

        self.data = {'key1' :[1,2,3,4], 

                    'key2' :['foo','bar],

                    'key3' :['testing'],

                    'path/to/key' :['some','value','in','here','too']}

        self.get_value('key1')

        4

        """

        return self.data[key][-1]

    def get_values(self,key):

        """

        return a copy of data values inside the container

        """

        values = []

        values.extend(self.data[key])

        return values

    def flatten(self):

        """

        return a new dictionary of the DataContainer data with only single values for each key, 

        instead of the array of values.

        """

        rest = {}

        for key in self.data.keys():

            rest[key] = self.get_value(key)

        return rest

    def clear(self):

        """

        Remove all data from the container.

        """

        return self.data.clear()

class ContainerBase(object):

    def _set_parent(self, newparent):

        """

        @param newparent:  The new parent object

        @return: None

        """

        self._parent = newparent

    def _get_parent(self):

        """

        @return: existing parent object

        """

        return self._parent

    def _del_parent(self):

        """

        Set the current parent to None

        """

        self._parent = None

    parent = property(_get_parent, _set_parent,_del_parent)

class ObjectProxy(ContainerBase):

    """

    An object proxy class. The ObjectProxy overrides the python builtin methdo __getattr__

    to redirect any function/member access to the subobject.  

    """

    def __init__(self,obj=None):

        """

        """

        self._obj  = obj

        self._parent = None

    def __getattr__(self,name):

        """

        direct all not found attribute calls to the sub object getattr

        """

        return getattr(self._obj,name)

#    def _set_parent(self, newparent):

#        """

#        @param newparent:  The new parent object

#        @return: None

#        """

#        self._parent = newparent

#        if isinstance(self._obj, ContainerBase):

#            self._obj._set_parent(newparent)

class LoadInterface(ContainerBase):

    def load(self,ref):

        self._parent = None

        return pickle.load(file)

    def unload(self,ref, obj):

        """

        unload or release

        """

        pickle.dump(obj,file)

        file.close()

    def get_path(self):

        """

        Return the path of the configuration resource

        """

        return ""

class ObjectContainer(ContainerBase):

    """

    An object container class. The ObjectContainer is actually a Tree data structure. Any ObjectContainer 

    instance can include any number of children, that must be instances of ObjectContainer.  

    """

    def __init__(self,name="",**kwargs):

        """

        """

    def __getattr__(self,name):

        """

        direct all not found attribute calls to the sub object getattr

        """

        try:

            return self.__dict__['_children'][name]

        except KeyError:

    def _path(self, toparent=None):

        """

        Get the path to this ObjectContainer.

        @param toparent: the _parent object up to which the path is relative. Default value is None.,

        which gives the fully qualified path

        @return: The path to the ObjectContainer from toparent

        """

        if self == toparent:

            return ""

        elif self._parent and self._parent != toparent:

            # return the path with list index if the given element is in a list

            if utils.is_list(self.parent._get(self._name)):

                return self._parent._path(toparent)+"."+"%s[%s]" % (self._name,self.get_index())

            else:

                return self._parent._path(toparent)+"."+self._name

        else:

            return self._name

        """

        @param policy: The policy which is used when an object with same name exists already  

        """

        # check that the child is a supported type

        if not self._supported_type(child):

            raise exceptions.IncorrectClassError("Cannot add instance of %s to %s." % (child.__class__,self.__class__))

        if policy == REPLACE:

            self._replace(child)

        elif policy == ERROR:

            self._error(child)

        elif policy == APPEND:

            self._append(child)

        elif policy == PREPEND:

            self._prepend(child)

    def _append(self, child):

        """

        Add the given child to the proper key. Create a list entry if necessary

        """

        child._set_parent(self)

        if not self._children.has_key(child._name):

            # skip all internal objects (that start with _)

            if not child._name.startswith('?'):

                self._order.append(child._name)

            self._children[child._name] = child

        else:

            """ Create a list under the child name """

            self._children[child._name] = utils.add_list(self._children[child._name], child)

        return

    def _prepend(self, child):

        """

        Add the given child to the proper key. Create a list entry if necessary

        """

        child._set_parent(self)

        if not self._children.has_key(child._name):

            # skip all internal objects (that start with _)

            if not child._name.startswith('?'):

                self._order.insert(0,child._name)

            self._children[child._name] = child

        else:

            """ Create a list under the child name """

            self._children[child._name] = utils.prepend_list(self._children[child._name], child)

        return

    def _replace(self, child):

        """

        If the given child already exists => Replace the child, 

        but maintain the current children of that child 

        """

        child._set_parent(self)

        # skip all internal objects (that start with _)

        if not self._children.has_key(child._name):

            if not child._name.startswith('?'):

                self._order.append(child._name)

        else:

            existingchild = self._children[child._name]

            if isinstance(existingchild, ObjectContainer):

                for subchild in existingchild._objects():

        self._children[child._name] = child

        return

    def _error(self, child):

        """

        If the given child already exists => raise an exception.

        @raise exceptions.AlreadyExists: 

        """

        child._set_parent(self)

        if not self._children.has_key(child._name):

            # skip all internal objects (that start with _)

            if not child._name.startswith('?'):

                self._order.insert(0,child._name)

            self._children[child._name] = child

        else:

            raise exceptions.AlreadyExists('Child %s already exists' % child._name)

        return

    def _add_to_path(self, path, child, policy=REPLACE):

        """

        Add a child object.

        @param path: the path for the object

        @param child: The child object to add 

        @param namespace: The namespace of the object, which defines where the object is created  

        """

        # check that the child is a supported type

        if not self._supported_type(child):

            raise exceptions.IncorrectClassError("Cannot add instance of %s to %s Container" % (child.__class__,self.__class__))

        # ensure that the elements to the namespace exist  

        curelem = self

        for ppath in utils.dottedref.split_ref(path):

            if not curelem._children.has_key(ppath):

                # Create missing elem

                curelem._add(self._default_object(ppath))

            curelem = curelem._get(ppath)

        curelem._add(child,policy)

    def _get(self, path):

        """

        Get a child object by it path.

        @return: The child object if it is found. 

        @raise NotFound: when object is not found from the children.  

        """

        try:

            # traverse to the actual child element 

            curelem = self

            for pathelem in utils.dottedref.split_ref(path):

                if utils.dottedref.get_index(pathelem) == None:

                    curelem = curelem._children[pathelem]

                else:

                    # If the given pathelem is referring to a list 

                    name = utils.dottedref.get_name(pathelem)

                    index = utils.dottedref.get_index(pathelem)

                    curelem = utils.get_list(curelem._children[name])[index]

            return curelem

        # Catch the KeyError exception from dict and IndexError from list

    def _has(self, path):

        """

        Returns True if an element under the path is found.

        @return: Boolean value. 

        """

        try:

            # traverse to the actual child element 

            curelem = self

            for pathelem in utils.dottedref.split_ref(path):

                curelem = curelem._children[pathelem]

            return True

        except KeyError: 

            return False

    def _remove(self, path):

        """

        Remove a child object by it path.

        """

        # if the patherence is a long patherence (dotted name)

        # first get the _parent object and call the remove to the _parent

        (parentref,name) = utils.dottedref.psplit_ref(path)

        if parentref != "":

            self._get(parentref)._remove(name)

        elif utils.dottedref.get_index(path) != None and \

             self._get(utils.dottedref.get_name(path)):

            # Delete If the given pathelem is referring to a list 

            name = utils.dottedref.get_name(path)

            index = utils.dottedref.get_index(path)

            del self._children[name][index]

            if len(self._children[name]) == 0:

                del self._order[self._order.index(name)]

        elif self._get(path) != None: # delete if the child is found

            del self._children[path]

        else:

            raise exceptions.NotFound("Child %s not found!" % path)

    def _list_traverse(self,**kwargs):

        """

        Return a list of all children paths. This function calls internally __traverse__, see it for 

        more details.

        @return: an unordered list of children paths. The path is relative to this node. 

        """

        return [child._path(self) for child in self._traverse(**kwargs)]

    def _traverse(self, **kwargs):

        """

        The traverse goes recursively through the tree of children of this node and returns a result set as list.

        Arguments can be passed to it to filter out elements of the result set. All arguments are 

        given as dict, so they must be given with name. E.g. _traverse(name='test')

        @param name: The node name or part of name which is used as a filter. This is a regular expression (uses internally re.match()) 

        @param path: The path name or part of name which is used as a filter. This is a regular expression (uses internally re.match())

        @param filters: A list of predefined filters can be given as lambda functions. E.g. filters=[lambda x: isinstance(x._obj, FooClass)]  

        @return: a list of ObjectContainer objects.

        """

        filterlist=[]

        if kwargs.has_key('ref'):

            filterlist.append(lambda x: re.match(kwargs.get('ref'), x.ref))

        if kwargs.has_key('name'):

            filterlist.append(lambda x: re.match(kwargs.get('name'), x._name))

        if kwargs.has_key('path'):

            filterlist.append(lambda x: re.match(kwargs.get('path'), x._path()))

        if kwargs.has_key('type'):

            filterlist.append(lambda x: isinstance(x, kwargs.get('type')))

        if kwargs.has_key('filters'):

            filterlist += kwargs.get('filters')

        ret = []

        for child in self._objects():

            ret += subchildren

        return ret