1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2005, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.xml;
/** Attribute information item, and linked list of attribute information items.
* These are triples consisting of prefix,key,value. To obtain the namespace,
* getNamespace must be called with the parent. If next is null, this is
* the last attribute in the MetaData list.
*
* either an UnprefixedAttribute or a PrefixedAttribute
*
* @todo _vlue should be a normalized attribute value
*/
[serializable]
abstract class MetaData extends Iterable[MetaData] {
/** appends given MetaData items to this MetaData list */
def append(m: MetaData): MetaData =
next.append(copy(m));
def apply(s:String) = getValue(s);
def containedIn1(m: MetaData): Boolean =
m.equals1(this) || containedIn1(m.next);
/** returns a copy of this MetaData item with next field set to argument */
def copy(next: MetaData): MetaData;
/** if owner is the element of this metadata item, returns namespace */
def getNamespace(owner: Node): String;
def hasNext = (Null != next);
def length: Int = length(1);
def length(i: Int): Int = next.length(i + 1);
def isPrefixed: Boolean;
//def containedIn(m:MetaData): Boolean;
//def deepCopy: MetaData;
//def deepCopy(tail:MetaData): MetaData;
/** deep equals method */
override def equals(that: Any) = {
that match {
case m: MetaData =>
var res = (this.length == m.length) && (this.hashCode() == m.hashCode());
val it = this.elements;
while (res && it.hasNext) { res = it.next.containedIn1(m) }
res
case _ => false;
}
}
/** bq: this can be done better */
def elements = new Iterator[MetaData] {
var x: MetaData = MetaData.this;
def hasNext = Null != x;
def next = {
val y = x;
x = x.next;
y
}
}
/** shallow equals method */
def equals1(that: MetaData): Boolean;
/** filters this sequence of meta data */
def filter(f: MetaData => Boolean): MetaData = {
if (f(this)) copy(next filter f) else next filter f;
}
/** returns key of this MetaData item */
def key: String;
/** returns key of this MetaData item */
def value: String;
/** maps this sequence of meta data */
def map(f: MetaData => Text): List[Text] = f(this)::(next map f);
/** returns Null or the next MetaData item */
def next: MetaData;
/** gets value of unqualified (unprefixed) attribute with given key */
def getValue(key: String): String;
/** gets value of qualified (prefixed) attribute with given key */
def getValue(namespace: String, owner: Node, key: String): String =
getValue(namespace, owner.scope, key);
/** gets value of qualified (prefixed) attribute with given key */
def getValue(namespace: String, scope: NamespaceBinding, key: String): String;
override def hashCode(): Int;
def toString1(): String = {
val sb = new StringBuffer();
toString1(sb);
sb.toString();
}
//appends string representations of single attribute to StringBuffer
def toString1(sb:StringBuffer): Unit;
override def toString(): String = {
val sb = new StringBuffer();
toString(sb);
sb.toString();
}
def toString(sb: StringBuffer): Unit = {
sb.append(' ');
toString1(sb);
next.toString(sb);
}
def wellformed(scope: NamespaceBinding): Boolean;
}
|
