/* Copyright 2004 The Apache Software Foundation
*
* Licensed 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.
*/
package org.apache.xmlbeans.impl.values;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlAnySimpleType;
import org.apache.xmlbeans.SimpleValue;
import org.apache.xmlbeans.XmlErrorCodes;
import org.apache.xmlbeans.XmlSimpleList;
import org.apache.xmlbeans.impl.common.ValidationContext;
import org.apache.xmlbeans.impl.common.QNameHelper;
import org.apache.xmlbeans.impl.common.PrefixResolver;
import org.apache.xmlbeans.impl.common.XMLChar;
import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;
public class XmlListImpl extends XmlObjectBase implements XmlAnySimpleType
{
public XmlListImpl(SchemaType type, boolean complex)
{ _schemaType = type; initComplexType(complex, false); }
public SchemaType schemaType()
{ return _schemaType; }
private SchemaType _schemaType;
private XmlSimpleList _value;
private XmlSimpleList _jvalue;
// SIMPLE VALUE ACCESSORS BELOW -------------------------------------------
// gets raw text value
private static String nullAsEmpty(String s)
{
if (s == null)
return "";
return s;
}
private static String compute_list_text(List xList)
{
if (xList.size() == 0)
return "";
StringBuffer sb = new StringBuffer();
sb.append(nullAsEmpty(((SimpleValue)xList.get(0)).getStringValue()));
for (int i = 1; i < xList.size(); i++)
{
sb.append(' ');
sb.append(nullAsEmpty(((SimpleValue)xList.get(i)).getStringValue()));
}
return sb.toString();
}
protected String compute_text(NamespaceManager nsm)
{
return compute_list_text(_value);
}
protected boolean is_defaultable_ws(String v) {
try {
XmlSimpleList savedValue = _value;
set_text(v);
// restore the saved value
_value = savedValue;
return false;
}
catch (XmlValueOutOfRangeException e) {
return true;
}
}
protected void set_text(String s)
{
// first check against any patterns...
if (_validateOnSet() && !_schemaType.matchPatternFacet(s))
throw new XmlValueOutOfRangeException(XmlErrorCodes.DATATYPE_VALID$PATTERN_VALID,
new Object[] { "list", s, QNameHelper.readable(_schemaType) });
SchemaType itemType = _schemaType.getListItemType();
XmlSimpleList newval = lex(s, itemType, _voorVc, has_store() ? get_store() : null);
// check enumeration
if (_validateOnSet())
validateValue(newval, _schemaType, _voorVc);
// we made it all the way through; so we're OK.
_value = newval;
_jvalue = null;
}
private static final String[] EMPTY_STRINGARRAY = new String[0];
public static String[] split_list(String s)
{
if (s.length() == 0)
return EMPTY_STRINGARRAY;
List result = new ArrayList();
int i = 0;
int start = 0;
for (;;)
{
while (i < s.length() && XMLChar.isSpace(s.charAt(i)))
i += 1;
if (i >= s.length())
return (String[])result.toArray(EMPTY_STRINGARRAY);
start = i;
while (i < s.length() && !XMLChar.isSpace(s.charAt(i)))
i += 1;
result.add(s.substring(start, i));
}
}
public static XmlSimpleList lex(String s, SchemaType itemType, ValidationContext ctx, PrefixResolver resolver)
{
String[] parts = split_list(s);
XmlAnySimpleType[] newArray = new XmlAnySimpleType[parts.length];
boolean pushed = false;
if (resolver != null)
{
NamespaceContext.push(new NamespaceContext(resolver));
pushed = true;
}
int i = 0;
try
{
for (i = 0; i < parts.length; i++)
{
try
{
newArray[i] = itemType.newValue(parts[i]);
}
catch (XmlValueOutOfRangeException e)
{
ctx.invalid(XmlErrorCodes.LIST, new Object[] { "item '" + parts[i] + "' is not a valid value of " + QNameHelper.readable(itemType) });
}
}
}
finally
{
if (pushed)
NamespaceContext.pop();
}
return new XmlSimpleList(Arrays.asList(newArray));
}
protected void set_nil()
{
_value = null;
}
public List xlistValue()
{
check_dated();
return _value;
}
public List listValue()
{
check_dated();
if (_value == null)
return null;
if (_jvalue != null)
return _jvalue;
List javaResult = new ArrayList();
for (int i = 0; i < _value.size(); i++)
javaResult.add(java_value((XmlObject)_value.get(i)));
_jvalue = new XmlSimpleList(javaResult);
return _jvalue;
}
private static boolean permits_inner_space(XmlObject obj)
{
switch (((SimpleValue)obj).instanceType().getPrimitiveType().getBuiltinTypeCode())
{
case SchemaType.BTC_STRING:
case SchemaType.BTC_ANY_URI:
case SchemaType.BTC_ANY_SIMPLE:
case SchemaType.BTC_ANY_TYPE:
return true;
default:
return false;
}
}
private static boolean contains_white_space(String s)
{
return s.indexOf(' ') >= 0 ||
s.indexOf('\t') >= 0 ||
s.indexOf('\n') >= 0 ||
s.indexOf('\r') >= 0;
}
public void set_list(List list)
{
SchemaType itemType = _schemaType.getListItemType();
XmlSimpleList xList;
boolean pushed = false;
if (has_store())
{
NamespaceContext.push(new NamespaceContext(get_store()));
pushed = true;
}
try
{
XmlAnySimpleType[] newval = new XmlAnySimpleType[list.size()];
for (int i = 0; i < list.size(); i++)
{
Object entry = list.get(i);
if ((entry instanceof XmlObject) && permits_inner_space((XmlObject)list.get(i)))
{
String stringrep = list.get(i).toString();
if (contains_white_space(stringrep))
throw new XmlValueOutOfRangeException();
}
newval[i] = itemType.newValue(entry);
}
xList = new XmlSimpleList(Arrays.asList(newval));
}
finally
{
if (pushed)
NamespaceContext.pop();
}
if (_validateOnSet())
{
// check enumeration + min/max/etc
validateValue(xList, _schemaType, _voorVc);
}
_value = xList;
_jvalue = null;
}
public static void validateValue(XmlSimpleList items, SchemaType sType, ValidationContext context)
{
XmlObject[] enumvals = sType.getEnumerationValues();
checkEnum: if (enumvals != null)
{
for (int i = 0; i < enumvals.length; i++)
{
if (equal_xmlLists(items, ((XmlObjectBase)enumvals[i]).xlistValue()))
break checkEnum;
}
context.invalid(XmlErrorCodes.DATATYPE_ENUM_VALID,
new Object[] { "list", items, QNameHelper.readable(sType) });
}
XmlObject o;
int i;
if ((o = sType.getFacet( SchemaType.FACET_LENGTH )) != null)
{
if ((i = ((SimpleValue)o).getIntValue()) != items.size())
{
context.invalid(XmlErrorCodes.DATATYPE_LENGTH_VALID$LIST_LENGTH,
new Object[] { items, new Integer(items.size()), new Integer(i), QNameHelper.readable(sType) });
}
}
if ((o = sType.getFacet( SchemaType.FACET_MIN_LENGTH )) != null)
{
if ((i = ((SimpleValue)o).getIntValue()) > items.size())
{
context.invalid(XmlErrorCodes.DATATYPE_MIN_LENGTH_VALID$LIST_LENGTH,
new Object[] { items, new Integer(items.size()), new Integer(i), QNameHelper.readable(sType) });
}
}
if ((o = sType.getFacet( SchemaType.FACET_MAX_LENGTH )) != null)
{
if ((i = ((SimpleValue)o).getIntValue()) < items.size())
{
context.invalid(XmlErrorCodes.DATATYPE_MAX_LENGTH_VALID$LIST_LENGTH,
new Object[] { items, new Integer(items.size()), new Integer(i), QNameHelper.readable(sType) });
}
}
}
// comparators
// protected int compare_to(XmlObject i) - no sorting order; inherit from base
protected boolean equal_to(XmlObject obj)
{
return equal_xmlLists(_value, ((XmlObjectBase)obj).xlistValue());
}
private static boolean equal_xmlLists(List a, List b)
{
if (a.size() != b.size())
return false;
for (int i = 0; i < a.size(); i++)
{
if (!a.get(i).equals(b.get(i)))
return false;
}
return true;
}
protected int value_hash_code()
{
if (_value == null)
return 0;
// hash code probes 9 distributed values, plus the last
int hash = _value.size();
int incr = _value.size() / 9;
if (incr < 1)
incr = 1;
int i;
for (i = 0; i < _value.size(); i += incr)
{
hash *= 19;
hash += _value.get(i).hashCode();
}
if (i < _value.size())
{
hash *= 19;
hash += _value.get(i).hashCode();
}
return hash;
}
protected void validate_simpleval(String lexical, ValidationContext ctx)
{
validateValue((XmlSimpleList)xlistValue(), schemaType(), ctx);
}
}