# XML "function" nodes that transform their contents

            cause)

    def __init__(self, cause):

        exc.ExceptionWithCause.__init__(self, 'Invalid input value', cause)

    return [(name, func(value)) for name, value in items]

def cast(type_, val):

    '''Throws FormatException if can't cast'''

    try: return type_(val)

    except ValueError, e: raise FormatException(e)

def conv_items(type_, items):

    return map_items(lambda val: cast(type_, val),

        xml_dom.TextEntryOnlyIter(items))

def pop_value(items, name='value'):

    '''@param name Name of value param, or None to accept any name'''

    try: last = items.pop() # last entry contains value

    except IndexError: return None # input is empty and no actions

    if name != None and last[0] != name: return None # input is empty

    return last[1]

    '''Merges siblings in root that are marked as mergeable.

    Used to recombine pieces of nodes that were split apart in the mappings.

    '''

    for name in set((c.tagName for c in xpath.get(root, '*[@merge=1]'))):

        xml_dom.merge_by_name(root, name)

    # Recurse

    for child in xml_dom.NodeElemIter(root): merge_tagged(child)

    return name.startswith('_') and name != '_' # '_' is default root node name

def is_func(node): return is_func_name(node.tagName)

def is_xml_func_name(name): return is_func_name(name) and name in funcs

def is_xml_func(node): return is_xml_func_name(node.tagName)

          functions are treated specially, depending on the db param (below).

    @param db

        * If None: Non-relational functions other than structural functions are

          replaced with their last parameter (usually the value), not evaluated.

          This is used in column-based mode to remove XML-only functions.

        * If != None: Relational functions are evaluated directly. This is used

          in row-based mode to combine relational and XML functions.

    row_mode = has_rel_funcs and db != None

    column_mode = has_rel_funcs and db == None

    if len(items) == 1 and items[0][0].isdigit(): # has single numeric param

        # pass-through optimization for aggregating functions with one arg

        value = items[0][1] # pass through first arg

        value = sql_io.put(db, name, dict(items)) # evaluate using DB

        # local XML function can't be used or does not exist

        if column_mode and is_rel_func(name): return # preserve relational funcs

        # otherwise XML-only in column mode, or DB-only in XML output mode

        value = pop_value(items, None) # just replace with last param

            exc.add_traceback(e)

                '\n'+term.emph_multiline(str_)))

# Function names must start with _ to avoid collisions with real tags

# Functions take arguments (items)

    return None

    '''Used to retrieve a value from another XML node

    @param items

        addr=<path> XPath to value, relative to the XML func's parent node

    '''

    items = dict(items)

    try: addr = items['addr']

    except KeyError, e: raise SyntaxError(e)

    value = xpath.get_value(node.parentNode, addr)

    if value == None:

        warnings.warn(UserWarning('_ref: XPath reference target missing: '

            +str(addr)))

    return value

funcs['_ref'] = _ref

    try:

        left = items['left']

        right = items['right']

    except KeyError: return '' # a value was None

    return util.bool2str(left == right)

funcs['_eq'] = _eq

    try:

        cond = items['cond']

        then = items['then']

    else: return else_

funcs['_if'] = _if

    items = dict(items)

    try: require = cast(strings.ustr, items['require'])

    except KeyError, e: raise SyntaxError(e)

    value = items.get('value', None)

funcs['_collapse'] = _collapse

        repl "*" means all other input values

        with "*" means keep input value the same

        with "" means ignore input value

    @param items

        <last_entry> Value

        <other_entries> name=value Mappings. Special values: See repl() repls.

    '''

    items = conv_items(strings.ustr, items) # get *once* from iter, check types

    value = pop_value(items)

    if value == None: return None # input is empty

    if value == None: return None # input is empty

        for repl, with_ in items:

            if re.match(r'^\w+$', repl):

                repl = r'(?<![^\W_])'+repl+r'(?![^\W_])' # match whole word

            value = re.sub(repl, with_, value)

    if value == None: return None # input is empty

        for action, units_ in items:

            units_ = util.none_if(units_, u'')

            if action == 'default': units.set_default_units(quantity, units_)

                try: quantity = units.convert(quantity, units_)

    default = (str_, None)

    start, sep, end = str_.partition(range_sep)

    if sep == '': return default # not a range

funcs['_rangeStart'] = _rangeStart

funcs['_rangeEnd'] = _rangeEnd

    from_ = items.get('from', None)

    to = items.get('to', None)

    if from_ == None or to == None: return None

    return str(to - from_)

funcs['_range'] = _range

    sum_ = 0.

        sum_ += value

    else: return str(sum_/count)

    def __init__(self):

        Exception.__init__(self, 'CV (coefficient of variation) values are only'

            ' allowed for ratio scale data '

            '(see <http://en.wikipedia.org/wiki/Coefficient_of_variation>)')

    except IndexError: return None # input is empty

    ('first', slice(None, 1)),

    ('middle', slice(1, -1)),

    ('last', slice(-1, None)),

]

name_parts_slices = dict(_name_parts_slices_items)

name_parts = [name for name, slice_ in _name_parts_slices_items]

        if part in items: parts.append(items[part])

    items = dict(conv_items(strings.ustr, items))

    try: value = items['value']

    except KeyError: return None # input is empty

    if not value.isupper(): return value # pass through other coordinate formats

    try: return util.cast(str, angles.compass2heading(value)) # ignore None

    except KeyError, e: raise FormatException(e)

funcs['_compass'] = _compass

    try:

        require = cast(strings.ustr, items['require'])

    node = root

    while node != None:

        new_node = xpath.get_1(node, next, allow_rooted=False)

            if node is root: root = new_node # also update root

        node = new_node

    return root

funcs['_simplifyPath'] = _simplifyPath