import copy

import xml_dom

    def __init__(self, name, value=None, is_attr=False):

        if name == '': name = '.'

        self.name = name

        self.is_positive = True

        self.is_ptr = False

        self.other_branches = [] # temp implementation for split paths

        if not self.is_positive: str_ += '!'

        if self.is_attr: str_ += '@'

        str_ += self.name

        if self.keys != []: str_ += repr(self.keys)

        if self.value != None: str_ += '='+repr(self.value)

        return str_

def is_positive(path): return path[0].is_positive

def value(path): return path[-1].value

def set_value(path, value): path[-1].value = value

def backward_id(elem):

    if len(elem.keys) >= 1 and value(elem.keys[0]) == None and\

    else: return None

_cache = {}

def parse(str_):

    try: return _cache[str_]

    parser = Parser(str_)

    def _path():

        is_positive = not parser.str_('!')

        tree = []

            # Split path

            if parser.str_('{'):

                tree[-1].other_branches = _paths()

                parser.str_('}', required=True)

                tree += tree[-1].other_branches.pop(0) # use first path for now

                break # nothing allowed after split path

            elem = XpathElem(is_attr=parser.str_('@'),

                name=parser.re(r'[\w.*]*', required=True))

            # Keys used to match nodes

            if parser.str_('['):

                elem.keys = _paths()

                parser.str_(']', required=True)

            # Attrs created when no matching node exists

            elem.is_ptr = parser.str_('->')

            tree.append(elem)

            if parser.str_('('):

                elem.keys.append(path)

                tree += path

            if not parser.str_('/'): break

        tree[0].is_positive = is_positive

        if parser.str_('='):

            else: value = parser.re(r'[\w.]*')

            set_value(tree, value)

        # Expand * abbrs

        for i in reversed(xrange(len(tree))):

            id_ = backward_id(elem)

                try: elem.name = before+tree[i+offset].name+after

                except IndexError: pass # no replacement elem

        return tree

    def _paths():

    parser.str_('/') # optional leading /

    _cache[str_] = path

    return path

instance_level = 1

def obj(path):

    obj_path = copy.deepcopy(path[:instance_level+1])

    obj_path[-1].is_ptr = False # prevent pointer w/o target

def set_id(path, id_, has_types=True):

    if has_types: id_level = instance_level

    else: id_level = 0

    path[id_level].keys.append([XpathElem('id', id_, True)])

def is_instance(elem): return elem.keys != [] and is_id(elem.keys[0])

def get(parent, xpath, create=False, last_only=None):

    if last_only == None: last_only = create

    if type(xpath) == str: xpath = parse(xpath)

    doc = parent.ownerDocument

    root = doc.documentElement

    for elem_idx, elem in enumerate(xpath):

        # Find possible matches

            last_only and (elem.keys == [] or is_instance(elem)))

            for attr in elem.keys:

                if not is_match: break

                is_match = (get(child, attr, False, last_only) != None)\

                == is_positive(attr)

            if is_match: node = child; break

            if elem.value != None: xml_dom.set_value(node, elem.value)

        if create:

            for attr in elem.keys + elem.attrs:

                get(node, attr, create, last_only)

        for branch in elem.other_branches:

            branch = copy.deepcopy(branch)

            set_value(branch, value(xpath))

            get(node, branch, create, last_only)

        # Follow pointer

                if id_ == None or get(root, obj_xpath, False, True) == None:

                    # no target or target keys don't match

                    if not create: return None

                    obj_xpath[-1].keys = [] # just get by tag name

                    last = get(root, obj_xpath, False, True)

                    if last != None: id_ = str(int(xml_dom.get_id(last)) + 1)

                    # Will append if target keys didn't match. Place ! in XPath

                    # after element to fork at to avoid this.

                    xml_dom.set_value(node, id_)

                else: last_only = False

            return get(root, xpath, create, last_only)

def put_obj(root, xpath, id_, has_types, value=None):

    if type(xpath) == str: xpath = parse(xpath)

    xpath = copy.deepcopy(xpath) # don't modify input!

    if value != None: set_value(xpath, value)

    get(root, xpath, True)

def path2xml(xpath, first_branch=True):

    get(root, xpath, True)

    return root

def xml_set_id(root, id_): xml_dom.set_id(root.firstChild, id_)