#

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

#

class ProblemTypeFilter(object):

    """

    Class for filtering problem types.

    An instance of this class can be constructed with includes

    and excludes, and then it can be asked if a certain problem

    type matches and should be included.

    """

    def __init__(self, includes, excludes):

        self._includes = [Pattern(expr) for expr in includes]

        self._excludes = [Pattern(expr) for expr in excludes]

    def match(self, problem_type):

        """

        Check whether the given problem type matches the filter or not.

        @return: True if matches (should be included), False if not.

        """

        # No filters: always match

        if not self._includes and not self._excludes:

            return True

        # Filter out entries that don't match includes

        if self._includes and not self._match(self._includes, problem_type):

            return False

        # Filter out entries that match excludes

        if self._excludes and self._match(self._excludes, problem_type):

            return False

        return True

    def filter(self, lst, key=lambda item: item.type):

        result = []

        for item in lst:

            if self.match(key(item)):

                result.append(item)

        return result

    def _match(self, patterns, problem_type):

        for p in patterns:

            if p.match(problem_type):

                return True

        return False

class Pattern(object):

    def __init__(self, pattern):

        self.elements = pattern.split('.')

    def match(self, problem_type):

        type_elements = problem_type.split('.')

        for i in xrange(max(len(type_elements), len(self.elements))):

            if i < len(type_elements):

                type_elem = type_elements[i]

            else:

                # The pattern is longer than the type, so it cannot

                # possibly match.

                # E.g. type = 'foo', pattern = 'foo.bar.baz'

                return False

            if i < len(self.elements):

                pattern_elem = self.elements[i]

            else:

                # The pattern ends and we have matched so far, so the

                # type is a sub-type of an included one.

                # E.g. type = 'foo.bar.baz', pattern = 'foo.bar'

                return True

            if pattern_elem != '*' and type_elem != pattern_elem:

                return False

        return True