5e5a4c9daa
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@935127 13f79535-47bb-0310-9956-ffa450edef68
168 lines
5 KiB
Python
168 lines
5 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing,
|
|
# software distributed under the License is distributed on an
|
|
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
# KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
# Functions to help represent data as lists of elements and attributes
|
|
|
|
from util import *
|
|
|
|
element = "'element"
|
|
attribute = "'attribute"
|
|
atsign = "'@"
|
|
|
|
# Return true if a value is an element
|
|
def isElement(v):
|
|
if not isList(v) or isNil(v) or v == None or car(v) != element:
|
|
return False
|
|
return True
|
|
|
|
# Return true if a value is an attribute
|
|
def isAttribute(v):
|
|
if not isList(v) or isNil(v) or v == None or car(v) != attribute:
|
|
return False
|
|
return True
|
|
|
|
# Return the name of attribute
|
|
def attributeName(l):
|
|
return cadr(l)
|
|
|
|
# Return the value of attribute
|
|
def attributeValue(l):
|
|
return caddr(l)
|
|
|
|
# Return the name of an element
|
|
def elementName(l):
|
|
return cadr(l)
|
|
|
|
# Return true if an element has children
|
|
def elementHasChildren(l):
|
|
return not isNil(cddr(l))
|
|
|
|
# Return the children of an element
|
|
def elementChildren(l):
|
|
return cddr(l)
|
|
|
|
# Return true if an element has a value
|
|
def elementHasValue(l):
|
|
r = reverse(l)
|
|
if isSymbol(car(r)):
|
|
return False
|
|
if isList(car(r)) and not isNil(car(r)) and isSymbol(car(car(r))):
|
|
return False
|
|
return True
|
|
|
|
# Return the value of an element
|
|
def elementValue(l):
|
|
return car(reverse(l))
|
|
|
|
# Convert an element to a value
|
|
def elementToValueIsList(v):
|
|
if not isList(v):
|
|
return False
|
|
return isNil(v) or not isSymbol(car(v))
|
|
|
|
def elementToValue(t):
|
|
if isTaggedList(t, attribute):
|
|
return (atsign + attributeName(t)[1:], attributeValue(t))
|
|
if isTaggedList(t, element):
|
|
if elementHasValue(t):
|
|
if not elementToValueIsList(elementValue(t)):
|
|
return (elementName(t), elementValue(t))
|
|
return cons(elementName(t), (elementsToValues(elementValue(t)),))
|
|
return cons(elementName(t), elementsToValues(elementChildren(t)))
|
|
if not isList(t):
|
|
return t
|
|
return elementsToValues(t)
|
|
|
|
# Convert a list of elements to a list of values
|
|
def elementToValueIsSymbol(v):
|
|
if not isList(v):
|
|
return False
|
|
if (isNil(v)):
|
|
return False
|
|
if not isSymbol(car(v)):
|
|
return False
|
|
return True
|
|
|
|
def elementToValueGroupValues(v, l):
|
|
if isNil(l) or not elementToValueIsSymbol(v) or not elementToValueIsSymbol(car(l)):
|
|
return cons(v, l)
|
|
if car(car(l)) != car(v):
|
|
return cons(v, l)
|
|
if not elementToValueIsList(cadr(car(l))):
|
|
g = (car(v), (cdr(v), cdr(car(l))))
|
|
return elementToValueGroupValues(g, cdr(l))
|
|
g = (car(v), cons(cdr(v), cadr(car(l))))
|
|
return elementToValueGroupValues(g, cdr(l))
|
|
|
|
def elementsToValues(e):
|
|
if isNil(e):
|
|
return e
|
|
return elementToValueGroupValues(elementToValue(car(e)), elementsToValues(cdr(e)))
|
|
|
|
# Convert a value to an element
|
|
def valueToElement(t):
|
|
if isList(t) and not isNil(t) and isSymbol(car(t)):
|
|
n = car(t)
|
|
v = cadr(t)
|
|
if not isList(v):
|
|
if n[0:2] == atsign:
|
|
return (attribute, n[1:], v)
|
|
return (element, n, v)
|
|
if isNil(v) or not isSymbol(car(v)):
|
|
return cons(element, cons(n, (valuesToElements(v),)))
|
|
return cons(element, cons(n, valuesToElements(cdr(t))))
|
|
if not isList(t):
|
|
return t
|
|
return valuesToElements(t)
|
|
|
|
# Convert a list of values to a list of elements
|
|
def valuesToElements(l):
|
|
if isNil(l):
|
|
return l
|
|
return cons(valueToElement(car(l)), valuesToElements(cdr(l)))
|
|
|
|
# Return a selector lambda function which can be used to filter elements
|
|
def evalSelect(s, v):
|
|
if isNil(s):
|
|
return True
|
|
if isNil(v):
|
|
return False
|
|
if car(s) != car(v):
|
|
return False
|
|
return evalSelect(cdr(s), cdr(v))
|
|
|
|
def selector(s):
|
|
return lambda v: evalSelect(s, v)
|
|
|
|
# Return the value of the attribute with the given name
|
|
def namedAttributeValue(name, l):
|
|
f = filter(lambda v: isAttribute(v) and attributeName(v) == name, l)
|
|
if isNil(f):
|
|
return None
|
|
return caddr(car(f))
|
|
|
|
# Return child elements with the given name
|
|
def namedElementChildren(name, l):
|
|
return filter(lambda v: isElement(v) and elementName(v) == name, l)
|
|
|
|
# Return the child element with the given name
|
|
def namedElementChild(name, l):
|
|
f = namedElementChildren(name, l)
|
|
if isNil(f):
|
|
return None
|
|
return car(f)
|
|
|