### Navigation

- index
- modules |
- Reconfigure docs »
- Module code »

# Source code for reconfigure.nodes

    class Node (object):
        """
        A base node class for the Node Tree.
        This class represents a named container node.
        """

        def __init__(self, name=None, *args, **kwargs):
            """
            :param name: Node name
            :param *args: Children
            :param comment: Node comment string
            :param origin: Node's source location (usually path to the file)
            """
            self.name = name
            self.origin = None
            self.children = []
            for node in list(args) + kwargs.pop('children', []):
                self.append(node)
            self.comment = kwargs.pop('comment', None)
            self.__dict__.update(kwargs)

        def __str__(self):
            s = '(%s)' % self.name
            if self.comment:
                s += ' (%s)' % self.comment
            s += '\n'
            for child in self.children:
                if child.origin != self.origin:
                    s += '\t@%s\n' % child.origin
                s += '\n'.join('\t' + x for x in str(child).splitlines()) + '\n'
            return s

        def __hash__(self):
            return sum(hash(x) for x in [self.name, self.origin, self.comment] + self.children)

        def __eq__(self, other):
            if other is None:
                return False

            return \
                self.name == other.name and \
                self.comment == other.comment and \
                self.origin == other.origin and \
                set(self.children) == set(other.children)

        def __iter__(self):
            return iter(self.children)

        def __len__(self):
            return len(self.children)

        def __nonzero__(self):
            return True

        def __getitem__(self, key):
            if type(key) in (int, slice):
                return self.children[key]
            return self.get(key)

        def __setitem__(self, key, value):
            if type(key) is int:
                self.children[key] = value
            self.set_property(key, value)

        def __contains__(self, item):
            return item in self.children

        def indexof(self, node):
            """
            :returns: index of the node in the children array or ``None`` if it's not a child
            """
            if node in self.children:
                return self.children.index(node)
            else:
                return None

        def get(self, name, default=None):
            """
            :returns: a child node by its name or ``default``
            """
            for child in self.children:
                if child.name == name:
                    return child
            if default:
                self.append(default)
            return default

        def get_all(self, name):
            """
            :returns: list of child nodes with supplied ``name``
            """
            return [n for n in self.children if n.name == name]

        def append(self, node):
            if not node.origin:
                node.origin = self.origin
            self.children.append(node)
            node.parent = self

        def remove(self, node):
            self.children.remove(node)

        def replace(self, name, node=None):
            """
            Replaces the child nodes by ``name``

            :param node: replacement node or list of nodes

            ::

                n.append(Node('a'))
                n.append(Node('a'))
                n.replace('a', None)
                assert(len(n.get_all('a')) == 0)

            """
            if name:
                self.children = [c for c in self.children if c.name != name]
            if node is not None:
                if type(node) == list:
                    for n in node:
                        self.children.append(n)
                else:
                    self.children.append(node)

        def set_property(self, name, value):
            """
            Creates or replaces a child :class:`PropertyNode` by name.
            """
            node = self.get(name)
            if node is None:
                node = PropertyNode(name, value)
                self.append(node)
            node.value = value
            return self

    class RootNode (Node):
        """
        A special node class that indicates tree root
        """

    class PropertyNode (Node):
        """
        A node that serves as a property of its parent node.
        """

        def __init__(self, name, value, comment=None):
            """
            :param name: Property name
            :param value: Property value
            """
            Node.__init__(self, name, comment=comment)
            self.value = value

        def __eq__(self, other):
            if other is None:
                return False

            return \
                Node.__eq__(self, other) and \
                self.value == other.value

        def __hash__(self):
            return Node.__hash__(self) + hash(self.value)

        def __str__(self):
            s = '%s = %s' % (self.name, self.value)
            if self.comment:
                s += ' (%s)' % self.comment
            return s

    class IncludeNode (Node):
        """
        A node that indicates a junction point between two config files
        """

        def __init__(self, files):
            """
            :param files: an includer-dependent config location specifier
            """
            Node.__init__(self)
            self.name = '<include>'
            self.files = files

        def __str__(self):
            return '<include> %s' % self.files

### Navigation

- index
- modules |
- Reconfigure docs »
- Module code »