/* 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.store;
import org.apache.xmlbeans.impl.values.TypeStore;
import org.apache.xmlbeans.impl.values.TypeStoreUser;
import org.apache.xmlbeans.impl.common.QNameHelper;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.XmlCursor.TokenType;
import org.apache.xmlbeans.XmlCursor.XmlBookmark;
import org.apache.xmlbeans.XmlCursor.XmlMark;
import org.apache.xmlbeans.XmlCursor;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.Map;
import java.util.Iterator;
import javax.xml.namespace.QName;
public abstract class Splay extends Goobers
{
//
// Can't change the kind of a base token
//
Splay ( int kind, boolean is )
{
_bits = kind;
if (is)
_bits += 0x8;
}
//
// Splay kinds
//
static final int DOC = 0; // DOC must be 0
static final int BEGIN = 1; // BEGIN must be 1
static final int ATTR = 2;
static final int COMMENT = 3;
static final int PROCINST = 4;
static final int ROOT = 5; // ROOT must be second to last
static final int END = 6; // END must be last
//
//
//
final int getKind ( ) { return _bits & 0x7; }
final boolean isDoc ( ) { return getKind() == DOC; }
final boolean isRoot ( ) { return getKind() == ROOT; }
final boolean isBegin ( ) { return getKind() == BEGIN; }
final boolean isEnd ( ) { return getKind() == END; }
final boolean isAttr ( ) { return getKind() == ATTR; }
final boolean isComment ( ) { return getKind() == COMMENT; }
final boolean isProcinst ( ) { return getKind() == PROCINST; }
final boolean isContainer ( ) { return getKind() <= BEGIN; }
final boolean isFinish ( ) { return getKind() >= ROOT; }
final int getCch ( ) { return _cch; }
final int getCdocBegin ( ) { return 1; }
final int getCchLeft ( ) { return _cchLeft; }
final int getCdocBeginLeft ( ) { return _bits >> 5; }
final int getCchAfter ( ) { return _cchAfter; }
final int getCchValue ( ) { return _cch - _cchAfter; }
QName getName ( ) { throw new IllegalStateException(); }
String getUri ( ) { throw new IllegalStateException(); }
String getLocal ( ) { throw new IllegalStateException(); }
// Fourth bit in _bits has several meanings, depending on splay kind
final boolean isNormalAttr ( ) { return (_bits & 0xF) == (0x0 + ATTR); }
final boolean isXmlns ( ) { return (_bits & 0xF) == (0x8 + ATTR); }
final boolean isLeaf ( ) { return (_bits & 0xF) == (0x8 + BEGIN); }
final boolean isFragment ( ) { return (_bits & 0xF) == (0x8 + COMMENT); }
final boolean isXsiAttr ( ) { return isNormalAttr() && getUri().equals( _xsi ); }
final boolean isXsiNil ( ) { return isNormalAttr() && getName().equals(_xsiNil ); }
final boolean isXsiType ( ) { return isNormalAttr() && getName().equals( _xsiType ); }
final boolean isTypeable ( ) { return isContainer() || isNormalAttr(); }
final void toggleIsLeaf ( )
{
assert isBegin();
_bits ^= 0x8;
}
final boolean isValid ( )
{
assert ((_bits & 0x10) == 0) || isTypeable();
return (_bits & 0x10) == 0;
}
final boolean isInvalid ( )
{
assert ((_bits & 0x10) == 0) || isTypeable();
return (_bits & 0x10) != 0;
}
final void toggleIsInvalid ( )
{
assert isTypeable();
_bits ^= 0x10;
}
final void adjustCch ( int delta )
{
_cch += delta;
assert _cch >= 0;
}
final void adjustCchAfter ( int delta )
{
_cchAfter += delta;
assert _cchAfter >= 0;
}
final void adjustCchLeft ( int delta )
{
_cchLeft += delta;
assert _cchLeft >= 0;
}
final void adjustCdocBeginLeft ( int d )
{
_bits += d * 32;
assert getCdocBeginLeft() >= 0;
}
final Splay getFinishSplay ( )
{
assert isContainer();
return isLeaf() ? this : ((Container) this).getFinish();
}
final int getPosAfter ( )
{
return getEndPos() - getCchAfter();
}
final int getPosLeafEnd ( )
{
assert isLeaf();
return 1 + getCchValue();
}
final int getCpForPos ( Root r, int p )
{
int cp = r.getCp( this );
if (p == 0)
return cp;
return
isLeaf()
? p - (p <= getPosLeafEnd() ? 1 : 2) + cp
: p - 1 + getCchValue() + cp;
}
final int getPostCch ( int p )
{
assert p >= 0 && p <= getEndPos();
return
isLeaf() && p <= getPosLeafEnd()
? getPosLeafEnd() - p
: getEndPos() - p;
}
static final String _xsi =
"http://www.w3.org/2001/XMLSchema-instance";
static final String _schema =
"http://www.w3.org/2001/XMLSchema";
static final String _openFragUri =
"http://www.openuri.org/fragment";
static final String _xml1998Uri =
"http://www.w3.org/XML/1998/namespace";
static final String _xmlnsUri =
"http://www.w3.org/2000/xmlns/";
static final QName _xsiNil = new QName( _xsi, "nil" );
static final QName _xsiType = new QName( _xsi, "type" );
static final QName _openuriFragment = new QName( _openFragUri, "fragment" );
static final QName _xmlFragment = new QName( "", "xml-fragment" );
static final boolean isXmlFragment ( QName name )
{
return _openuriFragment.equals( name ) || _xmlFragment.equals( name );
}
static boolean beginsWithXml ( String name )
{
if (name.length() < 3)
return false;
char ch;
if (((ch = name.charAt( 0 )) == 'x' || ch == 'X') &&
((ch = name.charAt( 1 )) == 'm' || ch == 'M') &&
((ch = name.charAt( 2 )) == 'l' || ch == 'L'))
{
return true;
}
return false;
}
/**
* This returns the pos of the very end of the splay. This is not
* generally a valid position to exist because in these cases, I
* force the position to be 0 on the next splay.
*/
final int getEndPos ( )
{
return getMaxPos() + 1;
}
/**
* This returns the largest pos possible without actually being at
* the end of the splay.
*/
final int getMaxPos ( )
{
switch ( getKind() )
{
case ATTR :
case ROOT : return 0;
case BEGIN : return (isLeaf() ? 1 : 0) + getCch();
case DOC :
case COMMENT :
case PROCINST :
case END : return getCchAfter();
default :
assert false: "Unexpected splay kind " +getKind();
return 0;
}
}
static final boolean isWhiteSpace ( char ch )
{
switch ( ch )
{
case ' ':
case '\t':
case '\n':
case '\r':
return true;
default:
return false;
}
}
static final boolean isWhiteSpace ( String s )
{
int l = s.length();
while ( l-- > 0)
if (!isWhiteSpace( s.charAt( l )))
return false;
return true;
}
static final boolean isWhiteSpace ( StringBuffer sb )
{
int l = sb.length();
while ( l-- > 0)
if (!isWhiteSpace( sb.charAt( l )))
return false;
return true;
}
final boolean isAfterWhiteSpace ( Root r )
{
int cchAfter = getCchAfter();
if (cchAfter == 0)
return true;
int off =
r._text.unObscure(
r.getCp( this ) + getCch() - cchAfter, cchAfter );
while ( cchAfter-- > 0 )
if (!isWhiteSpace( r._text._buf[ off + cchAfter ] ))
return false;
return true;
}
final void setName ( Root r, QName newName )
{
assert isBegin() || isAttr() || isProcinst();
// BUGBUG - deal with xsi:nil here too
QName oldName = getName();
if (!newName.equals( oldName ))
{
r.startChange();
((QNameSplay) this).changeName( newName );
if (!isProcinst() && !isXmlns())
{
assert isAttr() || isBegin();
if (isBegin())
disconnectTypes( r );
if (_xsiType.equals( oldName ) || _xsiType.equals( newName ))
getContainer().disconnectTypes( r );
else if (_xsiNil.equals( oldName ) || _xsiNil.equals( newName ))
getContainer().invalidateNil();
else
disconnectTypes( r );
}
r.invalidateVersion();
}
}
/**
* If this is an invalid leaf, then refresh it's value and return the
* number of characters added.
*/
final int ensureContentValid ( )
{
assert isContainer();
if (isValid())
return 0;
Type t = peekType();
return t.validateContent( this, t );
}
/**
* Ensure that the value (ATTR, COMMENT and PROCINST) is valid. Really
* only does anything for attrs.
*/
final void ensureValueValid ( )
{
assert isNormalAttr();
if (isInvalid())
{
Type t = peekType();
t.validateValue( this, t );
}
}
/**
* Given a position in this splay, return the TokenType associated with
* the content to the left of the position.
*/
final TokenType getTokenType ( int p )
{
assert p >= 0 && p <= getMaxPos();
// No need to revalidate text value here because there can be no pos
// which could exists when this splay is invalid which could be on
// text.
// First, see if we're in/at the text after the splay
if (p >= getPosAfter())
return TokenType.TEXT;
switch ( getKind() )
{
case ATTR :
return isXmlns() ? TokenType.NAMESPACE : TokenType.ATTR;
case BEGIN :
if (p == 0)
return TokenType.START;
assert isLeaf();
return p == getPosLeafEnd() ? TokenType.END : TokenType.TEXT;
case ROOT : return TokenType.ENDDOC;
case DOC : return TokenType.STARTDOC;
case COMMENT : return TokenType.COMMENT;
case PROCINST : return TokenType.PROCINST;
case END : return TokenType.END;
default :
assert false: "Unexpected splay kind " + getKind();
return null;
}
}
/**
* Cause this splay to become a leaf. This does not logically
* alter the document, but does alter the physical splay tree which
* demands that I issue a change notice.
*/
final void foliate ( Root r )
{
assert isBegin();
assert !isLeaf();
Begin b = (Begin) this;
Splay e = b.getFinish();
assert b.nextNonAttrSplay() == e;
assert b._end == e;
assert e.isEnd();
assert !b.isLeaf();
// Caller must initiate change
assert r.validateChangeStarted();
int cchBefore = getCch();
e.saveTextAfter( r );
b._end = null;
b.toggleIsLeaf();
b.adjustCchAfter( - cchBefore );
// Move the goobers from the end to the begin
Goober nextGoober;
for ( Goober g = e.firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = e.nextGoober( g );
assert g.getPos() == 0;
g.set( this, cchBefore + 1 );
}
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
int gp = g.getPos();
if (gp > cchBefore + 1)
g.set( this, gp + 1 );
}
e.removeSplay( r );
}
final void defoliate ( Root r )
{
assert isLeaf();
// Caller must initiate change
assert r.validateChangeStarted();
// Caller must ensure leaf is valid
assert isValid();
Begin b = (Begin) this;
int posLeafEnd = getPosLeafEnd();
int cchAfter = getCchAfter();
int cchValue = getCchValue();
Splay a = this;
int cchAttr = 0;
for ( Splay t = nextSplay() ; t.isAttr() ; t = t.nextSplay() )
{
cchAttr += t.getCch();
a = t;
}
r.insertSplay( b._end = new End( (Begin) this ), a );
b.toggleIsLeaf();
b.adjustCchAfter( cchValue - cchAfter );
b._end.adjustCchAfter( cchAfter );
r.updateCch( b, - cchAfter );
r.updateCch( b._end, cchAfter );
if (cchAttr > 0)
{
int cp = r.getCp( b );
r._text.move(
cp + cchValue + cchAfter + cchAttr,
r._text, cp + cchValue, cchAfter );
}
Goober nextGoober;
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
int gp = g.getPos();
if (gp >= posLeafEnd)
g.set( b._end, gp - posLeafEnd );
}
assert validate();
}
/**
* Remove the text after *this* splay.
* No validation is done, caller must do that
*/
private final void removeTextAfter ( Root r )
{
assert r != null;
assert Root.dv > 0 || getRootSlow() == r;
assert !isRoot() && !isAttr();
// Caller must initiate change
assert r.validateChangeStarted();
int cchTextAfter = getCchAfter();
if (cchTextAfter == 0)
return;
int cpTextAfter = r.getCp( this ) + getCch() - cchTextAfter;
int posTextAfter = getPosAfter();
adjustCchAfter( - cchTextAfter );
r.updateCch( this, - cchTextAfter );
r._text.remove( cpTextAfter, cchTextAfter );
Goober nextGoober;
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
int k = g.getKind();
if (g.getPos() >= posTextAfter)
{
if (k == ANNOTATION)
g.disconnect( r );
else if (k == CURSOR)
g.set( nextSplay(), 0 );
}
}
assert validate();
}
/**
* Transfers the text after this "node" to be after the "node" before it.
* No type invalidation is done here. No checking for isInvalid is needed
* either. No validation is done, caller must do that.
*/
private final int saveTextAfter ( Root r )
{
assert r != null;
assert Root.dv > 0 || getRootSlow() == r;
// Caller must initiate change
assert r.validateChangeStarted();
Splay endText = this;
if (isBegin() && !isLeaf())
endText = getFinishSplay();
int cchEndText = endText.getCchAfter();
if (cchEndText == 0)
return 0;
assert !isRoot() && !isDoc() && !isAttr();
Splay getsText = prevNonAttrSplay();
int getsTextLastPos = getsText.getEndPos();
int cpGetsText = r.getCp( getsText ) + getsText.getCch();
int cpEndText = r.getCp( endText ) + endText.getCch() - cchEndText;
getsText.adjustCchAfter( cchEndText );
endText.adjustCchAfter( - cchEndText );
r.updateCch( getsText, cchEndText );
r.updateCch( endText, - cchEndText );
assert cpGetsText <= cpEndText;
if (cpGetsText != cpEndText)
{
r._text.insert( cpGetsText, r._text, cpEndText, cchEndText );
r._text.remove( cpEndText + cchEndText, cchEndText );
}
int posEndText = endText.getPosAfter();
Goober nextGoober;
for ( Goober g = endText.firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = endText.nextGoober( g );
int gp = g.getPos();
if (gp >= posEndText)
g.set( getsText, getsTextLastPos + gp - posEndText );
}
assert validate();
return cchEndText;
}
/**
* Moves this splay, all of its content and attributes. If no destination
* is provided, then only a removal is performed.
*/
final void move (
Root r, Root rDst, Splay sDst, int pDst, boolean invalidate )
{
assert r != null;
assert Root.dv > 0 || getRootSlow() == r;
assert !isDoc() && !isFinish();
assert rDst == null || (r != rDst || !sDst.between( r, pDst, this ) );
assert rDst == null || sDst != null;
assert rDst == null || Root.dv > 0 || sDst.getRootSlow() == rDst;
assert rDst == null || pDst >= 0 && pDst < sDst.getEndPos();
assert
rDst == null ||
(true || checkInsertionValidity( 0, sDst, pDst, false ));
r.startChange();
if (rDst != null)
rDst.startChange();
// The text after the logical entity to move/remove is not part of
// this operation. Transfer it to a previous splay. No need to
// fret about invalidity here, because it's text *after*.
int cchSaved = saveTextAfter( r );
// If any text was saved, I need to move the cursors at the beginning
// of this splay to where the text was saved. I do this because this
// content is going away and cursors need to collapse to the right
// location which, in this case, is before the after text.
//
// No need to deal with goobers other than cursor because annotations
// and types will be dealt with appropriately later.
//
// Also, update the target if it was in the moved text!
//
// TODO - if moving xsi:type or xsi:nil must do stuff
if (cchSaved > 0)
{
Splay gotText = prevNonAttrSplay();
Goober nextGoober;
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
if (g.getKind() == CURSOR)
g.set( gotText, gotText.getEndPos() - cchSaved );
}
if (rDst != null)
{
Splay hadText =
isBegin() && !isLeaf() ? getFinishSplay() : this;
if (sDst == hadText && pDst >= hadText.getEndPos())
{
sDst = gotText;
pDst =
gotText.getEndPos() -
(cchSaved - (pDst - hadText.getEndPos()));
}
}
}
assert sDst != this;
// Compute the splay, up to which, I will remove
Splay last =
isBegin() ? getFinishSplay().nextNonAttrSplay() : nextSplay();
//
//
//
Container container = getContainer();
int cp = r.getCp( this );
int cch = 0;
for ( Splay s = this ; s != last ; s = s.nextSplay() )
{
// I'm going to blow away the Types here, make sure I have
// all the text.
if (s.isInvalid())
{
assert s.isLeaf() || s.isNormalAttr();
if (s.isNormalAttr())
s.ensureValueValid();
else if (s.isLeaf())
s.ensureContentValid();
}
cch += s.getCch();
Goober nextGoober;
for ( Goober g = s.firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = s.nextGoober( g );
switch ( g.getKind() )
{
case TYPE :
g.disconnect( r );
break;
case ANNOTATION :
if (rDst == null)
g.disconnect( r );
else
g.set( rDst ); // Potential move to a new tree
break;
case CURSOR :
g.set( last, 0 );
break;
}
}
}
// Remove the splays and the text. Unfortunately, I need to remove
// the text here. I can't think of a way to keep the tree valid and
// have the text moved in one copy .... Can you?
Splay sRemoved = r.removeSplays( this, last );
Splay first =
sRemoved._leftSplay == null ? sRemoved : sRemoved._leftSplay;
if (first.isBegin())
((Begin) first)._container = null;
char[] textRemoved = rDst == null || cch == 0 ? null : new char [ cch ];
r._text.remove( cp, cch, textRemoved, 0 );
r.invalidateVersion();
if (rDst != null)
{
sDst.insert(
rDst, pDst, sRemoved, textRemoved, 0, cch, invalidate );
}
if (invalidate)
{
Type parentType = container.peekType();
if (parentType != null)
{
if (isBegin())
parentType.invalidateElement( container, last );
else if (isAttr() && isXsiNil())
parentType.invalidateNil();
}
}
assert r.validate();
assert rDst == null || rDst.validate();
}
/**
* Removes this splay, all of its content and attributes.
*/
final void remove ( Root r, boolean invalidate )
{
move( r, null, null, 0, invalidate );
}
private final void complain ( String msg )
{
throw new IllegalArgumentException( msg );
}
/**
* Check to if the insertion of a "node" into the destination is allowed.
* This assumes that the source is a single piece of contents (like a node).
* Fragments are strings of content, not contained, and must not be
* validated by this function.
*
* Returns true if the src to copy is characters (potentially 0 chars too)
*/
final boolean checkInsertionValidity (
int p, Splay sDst, int pDst, boolean endOk )
{
assert p >= 0;
assert p < getEndPos();
assert pDst >= 0;
assert pDst < sDst.getEndPos();
boolean srcChars = false;
if (p > 0)
{
if (!endOk && isLeaf() && p == getPosLeafEnd())
complain( "Can't move/copy/insert an end token." );
srcChars = true;
// valid text target will be tested for further down
}
else
{
if (isDoc())
complain( "Can't move/copy/insert a whole document." );
if (isFinish())
{
if (!endOk)
complain( "Can't move/copy/insert an end token." );
srcChars = true;
}
else if (isFragment())
srcChars = true;
}
if (pDst == 0 && sDst.isDoc())
complain( "Can't insert before the start of the document." );
if (p > 0 && sDst.isAttr())
complain( "Can't insert text before an attribute." );
if (isAttr() && pDst > 0 && (!sDst.isContainer() || pDst != 1))
complain( "Can't insert an attribute in text." );
if (p <= 0 && pDst <= 0)
{
if (isAttr())
{
boolean isOk = sDst.isAttr();
if (!isOk)
{
Splay t = sDst.prevNonAttrSplay();
if (t.isContainer() && t.getCchAfter() == 0)
isOk = true;
}
if (!isOk)
{
complain(
"Can only move/copy/insert attribute after another " +
"attribute or start token." );
}
}
else if (sDst.isAttr())
{
complain(
"Can't move/copy/insert a non-attribute before " +
"an attribute." );
}
}
return srcChars;
}
/**
* Insert in this splay at position p whose root is r the splays rootInsert
* with text txt at offset cpTxt and length cchTxt
*/
final void insert (
Root r, int p, Splay rootInsert,
Object txt, int offTxt, int cchTxt,
boolean invalidate )
{
// BUGBUG - what is a new xsitype attr is inserted? -- must disconnect types
assert p < getEndPos();
assert cchTxt >= 0;
assert rootInsert != null;
assert rootInsert._parentSplay == null;
assert rootInsert.getCchLeft() + rootInsert.getCch() == cchTxt;
// We are inserting a tree here. Get the first splay in the tree
// It must either be at the root or just to the left of the root.
// This is the "classic" dog leg pattern I use to pass splay trees.
assert
rootInsert._leftSplay == null ||
rootInsert._leftSplay._leftSplay == null;
r.startChange();
Splay sInsert =
rootInsert._leftSplay == null ? rootInsert : rootInsert._leftSplay;
assert !sInsert.isDoc() && !sInsert.isFinish();
assert Root.dv > 0 || getRootSlow() == r;
// When this member is called, we better be able to do the insert.
assert true || sInsert.checkInsertionValidity( 0, this, p, false );
// If there is a fragment, there better be text in it
assert !sInsert.isFragment() || sInsert.getCch() > 0;
//
Splay s = this;
assert Root.dv > 0 || sInsert.getRootSlow() == null;
Splay sOrig = null;
int pOrig = 0;
int cchBypassed = 0;
// Prepare for inserting into the middle of a splay
if (p > 0)
{
int ple;
if (s.isLeaf() && p <= (ple = s.getPosLeafEnd()))
{
if (s.isInvalid())
{
assert ple == 1;
assert p == 1;
int cchValid = s.ensureContentValid();
p += cchValid;
ple += cchValid;
}
assert s.getFinishSplay() == s;
defoliate( r );
assert s.getFinishSplay() != s;
if (p == ple)
{
s = getFinishSplay();
p = 0;
}
s.insert( r, p, rootInsert, txt, offTxt, cchTxt, invalidate );
return;
}
// You can copy an attr to a dst where it is the first attr, or
// after all pre-exisitng attrs. This these cases, p == 1 on
// the begin. In this case, there is no need to move text later.
assert !sInsert.isAttr() || (p == 1 && s.isContainer());
sOrig = s;
pOrig = p;
cchBypassed = getEndPos() - p;
s = s.nextNonAttrSplay();
p = 0;
}
assert p == 0;
assert !s.isDoc();
// Get the container receiving all of this
Container c = s.getContainer();
// Run over the top level content, parenting any BEGINS. Also,
// characterize the content being inserted for future invalidation.
// Only fragments will have multiple top level begins.
boolean insertingElements = false;
boolean insertingText = false;
boolean insertingNilAttr = false;
Splay insertingFragment = null;
for ( Splay t = sInsert ; t != null ; t = t.nextSplay() )
{
if (t.isBegin())
{
insertingElements = true;
Begin b = (Begin) t;
assert b._container == null;
b._container = c;
t = t.getFinishSplay();
}
else if (t.isFragment())
{
assert insertingFragment == null;
insertingFragment = t;
}
if (t.isXsiNil())
insertingNilAttr = true;
if (t.getCchAfter() > 0)
insertingText = true;
}
// Now, insert the text (if any)
r._text.insert( r.getCp( s ), txt, offTxt, cchTxt );
// Insert the tree
r.insertSplay( rootInsert, s.prevSplay() );
// If the first splay to isnert was a fragment, remove it, leaving
// the text it carried in the tree. Don't perform invalidation.
if (insertingFragment != null)
insertingFragment.remove( r, false );
// Invalidate the parent if requested
if (invalidate)
{
Type cType = c.peekType();
if (cType != null)
{
if (insertingElements)
{
cType.invalidateElement( c, s );
insertingText = true;
}
if (insertingText)
cType.invalidateText();
if (insertingNilAttr)
cType.invalidateNil();
}
}
// If there is post text to move, move it to the end of the stuff
// inserted. Don't do this is if an attr was inserted because in this
// case, the attr is logically after the text to be moved anyways.
if (sOrig != null && !sInsert.isAttr())
{
int cchMoved = sOrig.moveChars( r, pOrig, -1, r, s, 0, true );
assert cchMoved > 0;
assert cchMoved == cchBypassed;
}
// build a leaf if possible
if (s.isEnd() && s.getContainer().nextNonAttrSplay() == s)
s.getContainer().foliate( r );
r.invalidateVersion();
assert r.validate();
}
/**
* Replaces the contents of this (attributes as well) with a copy of the
* contents of sSrc. If preserveType is true, then the xsi:type attr
* of the source is not copied, and the xsi:type of the target (this)
* is not altered.
*/
final void replaceContents (
Root r, Splay sSrc, Root rSrc,
boolean preserveType, boolean preserveNamespaces )
{
assert !isFinish() && !sSrc.isFinish();
assert Root.dv > 0 || getRootSlow() == r;
assert Root.dv > 0 || sSrc.getRootSlow() == rSrc;
// If the src and dst are the same splay, then there is nothing to do
if (this == sSrc)
return;
// If we are to preserve namespace mappings, make a copy of the
// namspaces in scope here
Map sourceNamespaces =
preserveNamespaces ? sSrc.lookupAllPrefixMappings() : null;
// If the destination is a simple container of text, then the content
// model is limited to text. Handle this specially.
if (isAttr() || isComment() || isProcinst())
{
// TODO - Do this without creating a string?
String str = sSrc.getText( rSrc );
setText( r, str, 0, str.length() );
}
else
{
// No need to startChange() here, fcns I call will do it for me
assert isContainer();
// Make copy of source
CopyContext copyContext = sSrc.copySplayContents( rSrc );
// If we need to preserve the xsi:type attribute, then fetch it.
// If there is more than one, the first one wins.
String targetXsiType = null;
if (preserveType)
{
for ( Splay s = nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXsiType())
{
targetXsiType = s.getText( r );
break;
}
}
}
// Because I have removed the entire contents of the target, I can
// insert fragment or node.
removeContent( r, true );
assert isLeaf() || getFinishSplay() == nextSplay();
assert getCchValue() == 0;
Splay copy = copyContext.getTree();
if (copy != null)
{
// Need to compute a normalized splay/pos to insert at. Only
// two cases, either we're inserting in a leaf or a
// container/finish pair.
Splay insertSplay = this;
int insertPos = 1;
if (!isLeaf())
{
insertSplay = nextSplay();
insertPos = 0;
}
char[] textCopy = copyContext.getText();
insertSplay.insert(
r, insertPos, copy,
textCopy, 0, textCopy == null ? 0 : textCopy.length, true );
// Now, go thorugh all the attrs, removing types and place the
// original back in.
if (preserveType)
{
Splay next = nextSplay();
for ( Splay s = next ; s.isAttr() ; s = next )
{
next = s.nextSplay();
if (s.isXsiType())
s.remove( r, true );
}
if (targetXsiType != null)
{
Attr a = new Attr( _xsiType );
int cchType = targetXsiType.length();
a.adjustCch( cchType );
if (getEndPos() > 1)
insert( r, 1, a, targetXsiType, 0, cchType, true );
else
{
nextNonAttrSplay().insert(
r, 0, a, targetXsiType, 0, cchType, true );
}
}
}
}
}
if (sourceNamespaces != null)
applyNamespaces( r, sourceNamespaces );
}
static final class CopyContext
{
void copyText ( char[] text )
{
_text = text;
}
void copySplay ( Splay s, boolean copyTextAfter )
{
assert !s.isDoc() && !s.isRoot();
Splay t;
switch ( s.getKind() )
{
case BEGIN :
{
s.ensureContentValid();
t = _frontier = new Begin( s.getName(), _frontier );
if (s.isLeaf())
{
t.toggleIsLeaf();
_frontier = _frontier.getContainer();
}
break;
}
case ATTR :
{
if (s.isXmlns())
t = new Xmlns( s.getName() );
else
{
s.ensureValueValid();
t = new Attr( s.getName() );
}
break;
}
case COMMENT :
{
t = new Comment();
break;
}
case PROCINST :
{
t = new Procinst( s.getName() );
break;
}
case END :
{
Begin b = (Begin) _frontier;
t = b._end = new End( b );
_frontier = _frontier.getContainer();
break;
}
default :
throw new IllegalStateException();
}
assert s.isValid();
int cch = s.getCchValue();
if (copyTextAfter)
{
int cchAfter = s.getCchAfter();
cch += cchAfter;
t.adjustCchAfter( cchAfter );
}
if (cch > 0)
t.adjustCch( cch );
copy( t );
}
/**
* May be called once before any other copy
*/
void copyFragment ( int cch )
{
assert cch > 0;
Splay s = new Fragment();
s.adjustCchAfter( cch );
s.adjustCch( cch );
copy( s );
}
Splay getTree ( )
{
assert _frontier == null;
if (_last == null)
return null;
if (_first != null)
{
_last.adjustCchLeft( _first.getCchLeft() + _first.getCch() );
_last.adjustCdocBeginLeft(
_first.getCdocBeginLeft() + _first.getCdocBegin() );
_last._leftSplay = _first;
_first._parentSplay = _last;
if (_tail != null)
{
_last.adjustCchLeft( _tail.getCchLeft() + _tail.getCch() );
_last.adjustCdocBeginLeft(
_tail.getCdocBeginLeft() + _tail.getCdocBegin() );
_first._rightSplay = _tail;
_tail._parentSplay = _first;
}
}
return _last;
}
char[] getText ( )
{
return _text;
}
private void copy ( Splay s )
{
//
// Here I make sure that the structure of the splay tree returned
// by the copy is such that the last splay copied is at the root,
// the first splay copied is the left child of the last copied,
// the second to last splay copied is the right child of the first,
// and the third through the second to last are a left only list
// off of the left child of the second!
//
// You may be asking your self, "Self, why all this madness?"
//
// Several reasons. First, by making the first hang off the
// left child of the last and have the right child of last be null,
// the root will have the total splay statistics for the whole
// tree. Second, you have quick access to the first splay copied.
// Third, building the third through the second to last do
// not require walking to update statictics.
//
// Ultimately, I do this to be consistent with the format of the
// tree when a range of splays are removed from a tree. To avoid
// an additional splay, the removal of a sub tree is shaped like
// this.
//
if (_last != null)
{
if (_first == null)
_first = _last;
else if (_tail == null)
_tail = _last;
else
{
_last.adjustCchLeft( _tail.getCchLeft() + _tail.getCch() );
_last.adjustCdocBeginLeft(
_tail.getCdocBeginLeft() + _tail.getCdocBegin() );
_last._leftSplay = _tail;
_tail._parentSplay = _last;
_tail = _last;
}
}
_last = s;
}
private char[] _text;
private Splay _first;
private Splay _tail;
private Splay _last;
private Container _frontier;
}
/**
* Copies the contents of this splay (deeply).
* This will update any invalid content.
*
* Because this can return only text, if there is text at the beginning
* of the contents, I will create a FRAG as the first splay (after any
* attributes).
*/
final CopyContext copySplayContents ( Root r )
{
assert !isFinish() && !isXmlns();
if (isContainer())
ensureContentValid();
else if (isNormalAttr())
ensureValueValid();
CopyContext copyContext = new CopyContext();
if (isContainer())
{
int cchAttrs = 0;
Splay t = nextSplay(), s = t;
for ( ; s.isAttr() ; s = s.nextSplay() )
{
copyContext.copySplay( s, false );
cchAttrs += s.getCch();
}
int cchValue = isLeaf() ? getCchValue() : getCchAfter();
if (cchValue > 0)
copyContext.copyFragment( cchValue );
int cchContents = 0;
if (!isLeaf())
{
Splay finish = getFinishSplay();
for ( Splay u = s ; u != finish ; u = u.nextSplay() )
{
copyContext.copySplay( u, true );
cchContents += u.getCch();
}
}
int cchAll = cchAttrs + cchValue + cchContents;
if (cchAll > 0)
{
char[] text = new char [ cchAll ];
int cp = r.getCp( this );
int cch = getCch();
if (cchAttrs > 0)
r._text.fetch( text, 0, cp + cch, cchAttrs );
if (cchValue > 0)
r._text.fetch( text, cchAttrs, cp, cchValue );
if (cchContents > 0)
{
r._text.fetch(
text, cchAttrs + cchValue,
cp + cch + cchAttrs, cchContents );
}
copyContext.copyText( text );
}
}
else
{
assert isNormalAttr() || isComment() || isProcinst();
int cchValue = getCchValue();
if (cchValue > 0)
{
copyContext.copyFragment( cchValue );
char[] text = new char [ cchValue ];
r._text.fetch( text, 0, r.getCp( this ), cchValue );
copyContext.copyText( text );
}
}
return copyContext;
}
/**
* Copies this splay (deeply). Also copies attributes after a begin
* This will update any invalid content.
*/
final Splay copySplay ( )
{
assert !isDoc() && !isFinish();
// Compute splay to stop at (does not get copied). Also compute
// a splay, to be copied, which should not have it's text after copied.
Splay stopHere, noTextAfter;
if (isBegin())
{
noTextAfter = getFinishSplay();
stopHere = noTextAfter.nextNonAttrSplay();
}
else
{
noTextAfter = null;
stopHere = nextSplay();
}
// Make the copy
CopyContext copyContext = new CopyContext();
for ( Splay next, s = this ; s != stopHere ; s = next )
{
next = s.nextSplay();
copyContext.copySplay( s, s != noTextAfter );
}
return copyContext.getTree();
}
final void removeAttributes ( Root r )
{
assert isContainer();
for ( ; ; )
{
Splay s = nextSplay();
if (!s.isAttr())
break;
s.remove( r, true );
}
}
/**
* Removes all content from splay.
* Begin will be a leaf upon exit.
*/
final void removeContent ( Root r, boolean removeAttrs )
{
assert Root.dv > 0 || getRootSlow() == r;
r.startChange();
if (isInvalid())
{
toggleIsInvalid();
r.invalidateVersion();
if (isContainer() && removeAttrs)
removeAttributes( r );
return;
}
switch ( getKind() )
{
case DOC :
break;
case BEGIN :
{
if (isLeaf())
{
removeChars( r, 1, getCchValue() );
if (removeAttrs)
removeAttributes( r );
return;
}
break;
}
case ATTR :
{
if (isXmlns())
{
assert false: "Unexpected kind for removeContent";
}
// Fall through
}
case COMMENT :
case PROCINST :
{
int cchValue = getCchValue();
if (cchValue == 0)
return;
r._text.remove( r.getCp( this ), cchValue );
r.updateCch( this, - cchValue );
if (getKind() == ATTR)
{
invalidateText();
if (isXsiType())
getContainer().disconnectTypes( r );
}
r.invalidateVersion();
return;
}
default :
assert false: "Unexpected kind for removeContent";
}
assert isDoc() || (isBegin() && !isLeaf());
Splay s = nextNonAttrSplay();
if (s.isRoot())
{
assert isDoc();
}
else
{
//
// Remove all the splays. Inhibit invalidation on each remove to
// prevent a flood of invalidations to the parent type (if there).
//
Splay next;
for ( s = nextNonAttrSplay() ; !s.isFinish() ; s = next )
{
assert !s.isAttr();
if (s.isLeaf())
next = s.nextNonAttrSplay();
else if (s.isBegin())
next = s.getFinishSplay().nextSplay();
else
next = s.nextSplay();
s.remove( r, false );
}
//
// Have to remove the text after this here because the above
// removes could have suuffled text to after this.
//
assert !isLeaf();
if (getCchAfter() > 0)
removeTextAfter( r );
//
// Tricky code. Merge the END and the BEGIN to form a leaf.
//
if (isBegin())
foliate( r );
invalidateText();
r.invalidateVersion();
}
// TODO - if removing text from xsi:type or nil must do stuff
// TODO - if removing text from xsi:type or nil must do stuff
// TODO - if removing text from xsi:type or nil must do stuff
// TODO - if removing text from xsi:type or nil must do stuff
// TODO - if removing text from xsi:type or nil must do stuff
// TODO - if removing attribute xsi:type or xsi:nil, must do stuiff
// TODO - if removing attribute xsi:type or xsi:nil, must do stuiff
// TODO - if removing attribute xsi:type or xsi:nil, must do stuiff
// TODO - if removing attribute xsi:type or xsi:nil, must do stuiff
// TODO - if removing attribute xsi:type or xsi:nil, must do stuiff
if (removeAttrs)
removeAttributes( r );
// If the tree became empty, reset _leftOnly
if (r._leftSplay == r._doc && r._doc._rightSplay == null)
r._leftOnly = true;
assert validate();
}
final int copyChars (
Root r, int p, int cch, Root rDst, Splay sDst, int pDst )
{
assert pDst > 0 && pDst <= sDst.getEndPos();
int postCch = getPostCch( p );
if (p == 0 || cch == 0 || postCch == 0)
return 0;
if (cch < 0 || cch > postCch)
cch = postCch;
assert cch > 0;
// TODO - uses string to avoid problems with source and dest from same buffer
// rewrite to not create string object
char[] chars = new char [ cch ];
r._text.fetch( chars, 0, getCpForPos( r, p ), cch );
sDst.insertChars( pDst, rDst, chars, 0, cch );
return cch;
}
/**
* Move cch chars from pos p on this splay to pos pDst on sDst.
* Source and destination can be different documents. Normally cursors
* stay put when their char is moved, but moveCursors can cause cursors
* tomove with the chars (used internally).
*/
final int moveChars (
Root r, int p, int cch, Root rDst, Splay sDst, int pDst,
boolean moveCursors )
{
if (p == 0)
return 0;
int postCch = getPostCch( p );
if (cch == 0 || postCch == 0)
return 0;
if (cch < 0 || cch > postCch)
cch = postCch;
r.startChange();
rDst.startChange();
assert cch > 0;
// I don't have to check the invalidity of the source because the
// only invalid text I would have to deal with is that in a leaf, and
// If the source is in a leaf here, then it must be positioned at the
// end (1) which is not sensitive to the invalidity.
//
// However, I much check the destination for validity because I may
// be appending text to an existing value.
if (sDst.isContainer() && pDst == 1)
{
int cchValid = sDst.ensureContentValid();
pDst += cchValid;
if (sDst == this && p == 1)
p += cchValid;
}
//
if (pDst == 0)
{
sDst = sDst.prevNonAttrSplay();
pDst = sDst.getEndPos();
}
// If the destination if in the range of the source, then this is
// effectively a no-op.
// TODO - Probably should disconnect Types in the range
if (sDst == this && pDst >= p && pDst <= p + cch)
return cch;
assert pDst > 0;
Container cDst = sDst.getContainer( pDst );
Container c = getContainer( p );
// Move the text
rDst._text.move(
sDst.getCpForPos( rDst, pDst ), r._text, getCpForPos( r, p ), cch );
// Perform the "insertion" first
if (!sDst.isLeaf() || pDst > sDst.getPosLeafEnd())
sDst.adjustCchAfter( cch );
rDst.updateCch( sDst, cch );
for ( Goober g = sDst.firstGoober() ; g != null ;
g = sDst.nextGoober( g ) )
{
int gp = g.getPos();
if (gp >= pDst)
g.set( gp + cch );
}
assert sDst != this || pDst < p || pDst > p + cch;
if (sDst == this)
{
int pDstSave = pDst;
if (pDst > p + cch)
pDst -= cch;
if (p >= pDstSave)
p += cch;
}
// Then perform the "removal"
if (!isLeaf() || p > getPosLeafEnd())
adjustCchAfter( - cch );
r.updateCch( this, - cch );
Goober nextGoober;
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
int gp = g.getPos();
if (gp >= p + cch)
{
g.set( gp - cch );
}
else if (gp >= p)
{
if (!moveCursors && g.getKind() == CURSOR)
{
if (p == getEndPos())
g.set( nextSplay(), 0 );
else
g.set( p );
}
else
g.set( rDst, sDst, pDst + gp - p );
}
}
cDst.invalidateText();
c.invalidateText();
r.invalidateVersion();
rDst.invalidateVersion();
return cch;
}
/**
* Remove cch chars starting at position p on this splay.
*/
final int removeChars ( Root r, int p, int cch )
{
int maxPos = getMaxPos();
assert p > 0 && p <= maxPos;
if (p == 0)
return 0;
r.startChange();
// TODO - merge the two following chunks of code??????
if (isLeaf())
{
int ple = getPosLeafEnd();
if (p <= ple)
{
if (cch < 0 || ple - p < cch)
cch = ple - p;
if (cch == 0)
return 0;
r._text.remove( r.getCp( this ) + p - 1, cch );
r.updateCch( this, - cch );
Goober nextGoober;
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
int k = g.getKind();
int gp = g.getPos();
if (gp >= p + cch)
g.set( gp - cch );
else if (gp >= p)
{
if (k == CURSOR)
g.set( p );
else
{
assert k == ANNOTATION;
g.disconnect( r );
}
}
}
invalidateText();
r.invalidateVersion();
return cch;
}
}
int posAfter = getPosAfter();
assert p >= posAfter;
int maxCch = maxPos - p + 1;
assert maxCch >= 0;
if (cch < 0 || cch > maxCch)
cch = maxCch;
if (cch <= 0)
return 0;
Container c = getContainer( p );
r._text.remove( getCpForPos( r, p ), cch );
adjustCchAfter( - cch );
r.updateCch( this, - cch );
Goober nextGoober;
for ( Goober g = firstGoober() ; g != null ; g = nextGoober )
{
nextGoober = nextGoober( g );
int k = g.getKind();
int gp = g.getPos();
if (gp >= p)
{
if (k == CURSOR)
g.set( nextNonAttrSplay(), 0 );
else
g.disconnect( r );
}
}
c.invalidateText();
r.invalidateVersion();
assert validate();
return cch;
}
/**
* Insert text a position p in this splay
*/
final void insertChars ( int p, Root r, Object txt, int off, int cch )
{
assert p > 0 && p <= getEndPos();
if (cch == 0)
return;
r.startChange();
Container container = getContainer( p );
if (isContainer() && p == 1)
p += ensureContentValid();
r._text.insert( getCpForPos( r, p ), txt, off, cch );
if (p >= getPosAfter())
adjustCchAfter( cch );
r.updateCch( this, cch );
for ( Goober g = firstGoober() ; g != null ; g = nextGoober( g ) )
{
int gp = g.getPos();
if (gp >= p)
g.set( gp + cch );
}
container.invalidateText();
r.invalidateVersion();
assert validate();
}
private static final int START_STATE = 0;
private static final int SPACE_SEEN_STATE = 1;
private static final int NOSPACE_STATE = 2;
public final int scrubText(
Text text, int ws, int cp, int cch, StringBuffer sb, int state )
{
assert text != null;
if (text._buf == null)
{
assert cch == 0;
assert cp == 0;
return state;
}
if (cch == 0)
return state;
boolean replace = false;
boolean collapse = false;
switch ( ws )
{
case TypeStore.WS_UNSPECIFIED : break;
case TypeStore.WS_PRESERVE : break;
case TypeStore.WS_REPLACE : replace = true; break;
case TypeStore.WS_COLLAPSE : collapse = replace = true; break;
default : assert false: "Unknown white space rule " +ws;
}
if (!replace && !collapse)
{
text.fetch(sb, cp, cch);
return state;
}
int off = text.unObscure( cp, cch );
int startpt = 0;
for ( int i = 0 ; i < cch ; i++ )
{
char ch = text._buf[ off + i ];
if (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t')
{
sb.append(text._buf, off + startpt, i - startpt);
startpt = i + 1;
if (collapse)
{
if (state == NOSPACE_STATE)
state = SPACE_SEEN_STATE;
}
else
sb.append(' ');
}
else
{
if (state == SPACE_SEEN_STATE)
sb.append( ' ' );
state = NOSPACE_STATE;
}
}
sb.append( text._buf, off + startpt, cch - startpt );
return state;
}
final String getText ( Root r )
{
return getText( r, TypeStore.WS_PRESERVE );
}
// final int getText ( Root r, char[] buf, int off, int len )
// {
// if (len <= 0)
// return 0;
//
// if (isInvalid())
// {
// if (isNormalAttr())
// ensureValueValid();
// else if (isLeaf())
// ensureContentValid();
// }
//
// int cp = r.getCp( this );
//
// if (isNormalAttr() || isComment() || isProcinst() || isLeaf())
// {
// int cch = getCchValue();
//
// if (cch == 0)
// return 0;
//
// if (cch > len)
// cch = len;
//
// r._text.fetch( buf, off, pos, cch );
//
// return cch;
// }
//
// if (!isContainer())
// return 0;
//
// int originalLen = len;
// Splay last = getFinishSplay();
//
// for ( Splay s = this ; len > 0 && s != last ; s = s.nextSplay() )
// {
// int srcCp, srcCch;
//
// if (s.isBegin())
// {
// if (s.isInvalid())
// s.ensureContentValid();
//
// srcCp = cp;
// srcCch = s.getCch();
// }
// else
// {
// // It's ok for an attr to be invalid here, gets text after
//
// srcCp = cp + s.getCchValue();
// srcCch = s.getCchAfter();
// }
//
// if (srcCch > 0)
// {
// if (srcCch > len)
// srcCch = len;
//
// int srcOff = r._text.unObscure( srcCp, srcCch );
//
// System.arrayCopy( r._text._buf, srcOff, buf, off, srcCch );
//
// len -= srcCch;
// off += srcCch;
// }
//
// cp += s.getCch();
// }
//
// return sb.toString();
// }
final String getText ( Root r, int ws )
{
if (isInvalid())
{
if (isNormalAttr())
ensureValueValid();
else if (isLeaf())
ensureContentValid();
}
int cp = r.getCp( this );
if (isNormalAttr() || isComment() || isProcinst() || isLeaf())
{
int cch = getCchValue();
if (cch == 0)
return "";
if (ws == TypeStore.WS_PRESERVE || ws == TypeStore.WS_UNSPECIFIED)
return r._text.fetch( cp, cch );
StringBuffer sb = new StringBuffer();
scrubText( r._text, ws, cp, getCchValue(), sb, START_STATE );
return sb.toString();
}
if (!isContainer())
return null;
Splay last = getFinishSplay();
int scrubState = START_STATE;
StringBuffer sb = new StringBuffer();
for ( Splay s = this ; s != last ; s = s.nextSplay() )
{
if (s.isBegin())
{
if (s.isInvalid())
s.ensureContentValid();
scrubState =
scrubText(
r._text, ws, cp, s.getCch(), sb, scrubState );
}
else
{
// It's ok for an attr to be invalid here, gets text after
int cchAfter = s.getCchAfter();
if (cchAfter > 0)
{
scrubState =
scrubText(
r._text, ws, cp + s.getCchValue(),
cchAfter, sb, scrubState );
}
}
cp += s.getCch();
}
return sb.toString();
}
/**
* Gets an attr splay for a given container, null otherwise.
*/
Splay getAttr ( QName name )
{
assert name != null;
if (!isContainer())
return null;
for ( Splay s = nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isNormalAttr() && s.getName().equals( name ))
return s;
}
return null;
}
void setXsiNil ( Root r, boolean nil )
{
assert isContainer();
if (getXsiNil( r ) == nil)
return;
setAttr( r, _xsiNil, "true" );
}
boolean getXsiNil ( Root r )
{
assert isContainer();
Splay s;
for ( s = nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXsiNil())
break;
}
if (!s.isAttr())
return false;
String value = s.getText( r, TypeStore.WS_COLLAPSE );
return value.equals( "true" ) ||value.equals( "1" );
}
QName getXsiTypeName ( Root r )
{
assert isContainer();
Splay s;
for ( s = nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXsiType())
break;
}
if (!s.isAttr())
return null;
assert s.isXsiType();
String value = s.getText( r, TypeStore.WS_COLLAPSE );
// TODO - unobscure the underlying text and use it directly
// TODO - should I make sure the prefix is wqell formed? ie. just text
String prefix, localname;
int firstcolon = value.indexOf( ':' );
if (firstcolon >= 0)
{
prefix = value.substring( 0, firstcolon );
localname = value.substring( firstcolon + 1 );
}
else
{
prefix = "";
localname = value;
}
String uri = namespaceForPrefix( prefix, true );
if (uri == null)
return null; // no prefix definition found - that's illegal
return new QName( uri, localname );
}
void setXsiType ( Root r, QName typeName )
{
assert isContainer();
if (typeName == null)
{
removeAttr( r, _xsiType );
return;
}
String value = typeName.getLocalPart();
String ns = typeName.getNamespaceURI();
String prefix = prefixForNamespace( r, ns, null, true);
assert prefix != null : "Cannot establish prefix for " + ns;
if (prefix.length() > 0)
value = prefix + ":" + value;
boolean set = false;
setAttr( r, _xsiType, value );
}
void removeAttr ( Root r, QName attrName )
{
Splay next;
for ( Splay s = nextSplay() ; s.isAttr() ; s = next )
{
next = s.nextSplay();
if (s.getName().equals( attrName ))
s.remove( r, true );
}
}
void setAttr ( Root r, QName attrName, String value )
{
assert isContainer();
assert attrName != null;
assert value != null;
boolean set = false;
Splay next;
for ( Splay s = nextSplay() ; s.isAttr() ; s = next )
{
next = s.nextSplay();
if (s.getName().equals( attrName ))
{
if (set)
s.remove( r, true );
else
{
s.setText( r, value, 0, value.length() );
set = true;
}
}
}
if (!set)
{
Splay sInsert = this;
int pInsert = 1;
if (!isLeaf() && getCch() == 0)
{
sInsert = nextSplay();
pInsert = 0;
}
int cchValue = value.length();
Attr attr = new Attr( attrName );
attr.adjustCch( cchValue );
sInsert.insert( r, pInsert, attr, value, 0, cchValue, false );
}
}
/**
* Sets the content/value of this splay to the given text.
*/
final void setText ( Root r, Object txt, int off, int cch )
{
removeContent( r, false );
if (txt == null || cch == 0)
return;
switch ( getKind() )
{
case DOC :
case BEGIN :
{
assert !isBegin() || isLeaf();
insertChars( 1, r, txt, off, cch );
break;
}
case ATTR :
{
if (isXmlns())
{
assert false: "Unexpected kind for setText";
}
// TODO - if setting text of xsi:type or xsi:nil must do stuff
// TODO - if setting text of xsi:type or xsi:nil must do stuff
// TODO - if setting text of xsi:type or xsi:nil must do stuff
// TODO - if setting text of xsi:type or xsi:nil must do stuff
// Fall through
}
case COMMENT :
case PROCINST :
{
r.startChange();
assert getCchValue() == 0;
r._text.insert( r.getCp( this ), txt, off, cch );
r.updateCch( this, cch );
if (getKind() == ATTR)
{
invalidateText();
if (isXsiType())
getContainer().disconnectTypes( r );
}
r.invalidateVersion();
break;
}
default :
assert false: "Unexpected kind for setText";
}
assert validate();
}
final Map lookupAllPrefixMappings ( )
{
Map mappings = null;
Splay container = this.isContainer() ? this : getContainer();
for ( ; container != null ; container = container.getContainer() )
{
for ( Splay s = container.nextSplay() ; s.isAttr() ;
s = s.nextSplay() )
{
if (s.isXmlns())
{
if (mappings == null)
mappings = new HashMap();
else if (mappings.containsKey( s.getLocal() ))
continue;
mappings.put( s.getLocal(), s.getUri() );
}
}
}
return mappings;
}
final void applyNamespaces ( Root r, Map namespaces )
{
if (namespaces == null)
return;
Splay container = this.isContainer() ? this : getContainer();
namespace_loop:
for ( Iterator i = namespaces.keySet().iterator() ; i.hasNext() ; )
{
String prefix = (String) i.next();
// Usually, this is the predefined xml namespace
if (prefix.toLowerCase().startsWith( "xml" ))
continue;
String namespace = (String) namespaces.get( prefix );
Splay candidate = container;
candidate_loop:
for ( Splay c = container.getContainer() ; c != null && !c.isDoc() ;
c = c.getContainer() )
{
for ( Splay s = c.nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() && prefix.equals( s.getLocal() ))
{
if (namespace.equals( s.getUri()))
continue namespace_loop;
break candidate_loop;
}
}
candidate = c;
}
// Insert the new namespace at the end of the attr list after
// makeing sure all previous mappings are gone
QName qname = new QName( namespace, prefix );
removeAttr( r, qname );
candidate.nextNonAttrSplay().insert(
r, 0, new Xmlns( qname ), null, 0, 0, false );
}
}
/**
* Returns the prefix associated with this attr/element.
*/
final String getPrefix ( Root r )
{
assert isBegin() || isAttr();
if (isXmlns())
return "xmlns";
// TODO - have a prefix goober to override the mapping on the frontier.
// Parser will add this when the natural prefix is not the real prefix.
Splay c = isBegin() ? this : getContainer();
// special case
String ns = getUri();
// last argument is false, which means, don't modify the tree
return prefixForNamespace( r, ns, null, false );
}
/**
* Given a prefix, returns the namespace corresponding to
* the prefix at this location, or null if there is no mapping
* for this prefix.
* <p>
* prefix="" indicates the absence of a prefix. A return value
* of "" indicates the no-namespace, and should not be confused
* with a return value of null, which indicates an illegal
* state, where there is no mapping for the given prefix.
* <p>
* If the the default namespace is not explicitly mapped in the xml,
* the xml spec says that it should be mapped to the no-namespace.
* When the 'defaultAlwaysMapped' parameter is true, the default namepsace
* will return the no-namespace even if it is not explicity
* mapped, otherwise the default namespace will return null.
* <p>
* This function intercepts the built-in prefixes "xml" and
* "xmlns" and returns their well-known namespace URIs.
*
* @param prefix The prefix to look up.
* @param mapDefault If true, return the no-namespace for the default namespace if not set.
* @return The mapped namespace URI ("" if no-namespace), or null if no mapping.
*/
final String namespaceForPrefix ( String prefix, boolean defaultAlwaysMapped )
{
// null same as "", means look up the default namespace
if (prefix == null)
prefix = "";
// handle built-in prefixes
if ("xml".equals(prefix))
return _xml1998Uri;
if ("xmlns".equals(prefix))
return _xmlnsUri;
assert isContainer();
// find an xmlns decl
for ( Container c = (Container) this ; c != null ; c = c.getContainer())
{
for ( Splay s = c.nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() && prefix.equals( s.getLocal() ))
return s.getUri();
}
}
// CR135193: if defaultAlwaysMapped, return no-namespace when no default namespace is found
// otherwise, return null to indicate no default namespace was found.
if (defaultAlwaysMapped && prefix.length() == 0) {
return "";
}
// no namespace defn found: return null
return null;
}
/**
* Returns the prefix to use for a given namespace URI. Can either
* be allowed to modify the tree to ensure such a mapping (if r
* is non-null), or can be told to return null if there is no
* existing mapping (if r is null).
* <p>
* For the case where the tree may be modified, a suggested prefix
* can be supplied. The suggestion may be ignored for any reason,
* for example, if the prefix is already in-use.
* <p>
* Returns "xml" and "xmlns" for the well-known namespace URIs
* corresponding to those built-in prefixes.
*
* @param r should be null if you don't want to modify the tree.
* if a prefix can't be found, null will be returned
* rather than introducing an xmlns.
* @param ns the namespace to look for or introduce a mapping for.
* careful with "", because it may have nonlocal effects
* if somebody has overridden the default namespace.
* @param suggestion a suggested prefix to try first; may be null.
*
* @param createIfMissing true (normally it's true) if you want to create
* an xmlns declaration when one doesn't already exist for
* your requested URI. If you don't want to modify the tree,
* pass false.
*/
final String prefixForNamespace ( Root r, String ns, String suggestion,
boolean createIfMissing )
{
// null same as empty string, means no-namespace
if (ns == null)
ns = "";
// special cases
if (_xml1998Uri.equals( ns ))
return "xml";
if (_xmlnsUri.equals( ns ))
return "xmlns";
assert isContainer();
Container c;
Splay s;
//
// Special handling is ns is not specified (no namespace)
//
if (ns.length() == 0)
{
loop:
for ( c = (Container) this ; c != null ; c = c.getContainer() )
{
for ( s = c.nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() && s.getLocal().length() == 0)
{
if (s.getUri().length() == 0)
return s.getLocal();
break loop;
}
}
}
//
// If there is no overridden default namespace in scope,
// return "" - the default default namespace is the no-namepsace.
//
if ( c == null )
return "";
//
// If we found a problematic default namespace but cannot modify
// the tree, return null - no prefix available.
//
if ( !createIfMissing )
return null;
//
// There is a default namespace which maps to a 'real' namespace,
// create a default namespace on this container which is "". This
// can screw attributes and such, but, oh well.
//
for ( s = nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() && s.getLocal().length() == 0)
{
s.setName( r, new QName( "", "" ) );
return s.getLocal();
}
}
// this is an xmlns="" declaration
Attr a = new Xmlns( new QName( "", "" ) );
r.startChange();
r.insertSplay( a, this );
r.invalidateVersion();
return a.getLocal();
}
//
// the ordinary not-a-no-namespace case
//
assert ns != null && ns.length() > 0;
//
// look for an existing prefix for the requested URI
//
for ( c = (Container) this ; c != null ; c = c.getContainer() )
{
findxmlns: for ( s = c.nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() && s.getUri().equals( ns ))
{
String result = s.getLocal();
// now check to verify that the prefix isn't masked
for ( Container c2 = (Container) this ; c2 != c ; c2 = c2.getContainer() )
{
for ( Splay s2 = c2.nextSplay() ; s2.isAttr() ; s2 = s2.nextSplay() )
{
if (s2.isXmlns() && s2.getLocal().equals(result))
continue findxmlns;
}
}
// not masked: OK.
return result;
}
}
}
//
// We could not find an existing prefix in-scope that works.
// If !createIfMissing, don't modify the tree - return null instead.
//
if (!createIfMissing)
return null;
//
// We must add an xmlns:something="uri", so we must pick a prefix.
// We will use the suggestion if it's not already in scope and if
// it's not the empty string or an illegal prefix.
//
if (suggestion != null)
{
if (suggestion.length() == 0 || suggestion.toLowerCase().startsWith( "xml" ))
suggestion = null; // bad suggestion
else
{
for ( c = (Container) this ; c != null ; c = c.getContainer() )
{
for ( s = c.nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() &&
s.getLocal().equals( suggestion ))
{
suggestion = null;
break;
}
}
}
}
}
//
// If no suggestion, come up with a safe prefix to use
//
if (suggestion == null)
{
String base = QNameHelper.suggestPrefix(ns);
suggestion = base;
for ( int i = 1 ; ; i++ )
{
loop:
for ( c = (Container) this ; c != null ; c = c.getContainer() )
{
for ( s = c.nextSplay() ; s.isAttr() ; s = s.nextSplay() )
{
if (s.isXmlns() &&
s.getLocal().equals( suggestion ))
{
suggestion = null;
break loop;
}
}
}
if (suggestion != null)
break;
suggestion = base + i;
}
}
Container target = null;
Container lastContainer = null;
for ( c = (Container) this ; c != null ; c = c.getContainer() )
{
lastContainer = c;
if (c.isBegin())
target = c;
}
if (target == null)
target = lastContainer;
Attr a = new Xmlns( new QName( ns, suggestion ) );
r.startChange();
r.insertSplay( a, target );
r.invalidateVersion();
return a.getLocal();
}
/**
* Gets the container associated with the content at pos in this
* splay.
*/
final Container getContainer ( int p )
{
assert p >= 0 && p <= getEndPos();
assert p > 0 || !isDoc();
if (p == 0)
return getContainer();
if (isLeaf())
return p < getPosAfter() ? (Container) this : getContainer();
if (isContainer())
return (Container) this;
if (isFinish())
return getContainer().getContainer();
return getContainer();
}
/**
* Gets the splay which contains this splay.
*/
abstract Container getContainer ( );
/**
* Helper fcn to locate the container this splay is container in.
* Should only be called by implementations of getContainer in
* cases where the container is not obviously computable.
*/
Container findContainer ( )
{
assert !isContainer();
assert !isFinish();
Splay s = nextSplay();
while ( !s.isFinish() && !s.isBegin() )
s = s.nextSplay();
return s.getContainer();
}
final void invalidateText ( )
{
assert isValid();
Type t = peekType();
if (t != null)
{
assert isTypeable();
t.invalidateText();
}
}
final void invalidateNil ( )
{
assert isTypeable();
if (!isAttr())
{
Type t = peekType();
if (t != null)
t.invalidateNil();
}
}
protected final void disconnectTypes ( Root r )
{
disconnectTypes( r, false );
}
protected final void disconnectTypes ( Root r, boolean disconnectDoc )
{
assert isTypeable();
Splay last = isAttr() ? this : getFinishSplay();
Splay s = this;
for ( ; ; )
{
Type t = null;
if (s.isNormalAttr() || s.isLeaf())
{
t = s.peekType();
}
else if (s.isFinish())
{
Container c = s.getContainer();
if (!c.isDoc() || disconnectDoc)
t = c.peekType();
}
if (t != null)
{
Splay u = t.getSplay();
if (u.isInvalid())
{
if (u.isAttr())
t.validateValue( u, t );
else
{
// The finish splay might get whacked
Splay f = u.getFinishSplay();
t.validateContent( u, t );
if (f == last)
last = f;
}
}
t.disconnect( r );
}
if (s == last)
break;
if (s.isContainer() && !s.isLeaf() && s.peekType() == null)
s = s.getFinishSplay();
else
s = s.nextSplay();
}
}
/**
* Sets the type of of this
*/
final void setType ( Root r, SchemaType sType )
{
setType( r, sType, true );
}
final void setType ( Root r, SchemaType sType, boolean complain )
{
assert isTypeable();
assert sType != null;
//
// Is the current type already this type?
//
Type t = peekType();
if (t != null && t.get_schema_type() == sType)
return;
//
// Can always set an arbitrary type at the doc level
//
if (isDoc())
{
disconnectTypes( r, true );
assert peekType() == null;
new Type( r, sType, this );
assert validate();
return;
}
//
// Gotta get the parent type to do anything further. If it
// can't be found, then barf
//
Type parentType = getContainer().getType( r );
assert parentType != null;
//
// You can set the attribute type, as long as it is the natural
// type. Attributes cannot have xsi:type
//
if (isAttr())
{
if (parentType.get_attribute_type( getName() ) != sType && complain)
{
throw new IllegalArgumentException(
"Can't set type of attribute to " + sType.toString() );
}
return;
}
assert isBegin();
//
// Now, for interior types, I have to deal with xsi:type and
// whether or not the type is allowed at this point.
//
// First check to see if this type can be here sans xsi:type.
// If so, make sure there is no xsi:type
if (parentType.get_element_type( getName(), null ) == sType)
{
setXsiType( r, null );
disconnectTypes( r );
assert validate();
return;
}
// If the desired type has no name, then it cannot be
// referenced via xsi:type
QName typeName = sType.getName();
if (typeName == null)
{
if (complain)
{
throw new IllegalArgumentException(
"Can't set type of element, type is un-named" );
}
return;
}
if (parentType.get_element_type( getName(), typeName ) != sType)
{
if (complain)
{
throw new IllegalArgumentException(
"Can't set type of element, invalid type" );
}
return;
}
setXsiType( r, typeName );
disconnectTypes( r );
assert validate();
}
/**
* Get the Type associated with this splay. It does not attempt to create
* one and will return null is non exists.
*/
final Type peekType ( )
{
assert isTypeable();
Type type = null;
if (_goobers != null)
{
for ( Goober g = firstGoober() ; g != null ; g = nextGoober( g ) )
if (g.getKind() == TYPE)
return (Type) g;
}
assert type != null || isValid();
return type;
}
/**
* Get the Type associated with this splay. If non exists, it attempts
* to create one. Returns null if one could not be created.
*/
final Type getType ( Root r )
{
assert isTypeable();
Type type = peekType();
if (!isDoc() && type == null)
{
Type parentType = getContainer().getType( r );
assert parentType != null;
// Defensive
if (parentType == null)
return null;
TypeStoreUser newUser;
if (isBegin())
{
newUser =
parentType.create_element_user(
getName(), getXsiTypeName( r ) );
}
else
{
assert isNormalAttr();
newUser = parentType.create_attribute_user( getName() );
}
assert newUser != null;
// Defensive
if (newUser == null)
return null;
type = new Type( r, newUser, this );
}
assert type != null;
return type;
}
/**
* Is this inside of the content of sRange? Does an inclusive check.
*/
final boolean between ( Root r, int pThis, Splay sRange )
{
assert Root.dv > 0 || getRootSlow() == r;
assert Root.dv > 0 || getRootSlow() == sRange.getRootSlow();
if (sRange.isDoc())
return true;
if (compare( r, pThis, sRange, 0 ) < 0)
return false;
Splay sEnd;
int pEnd;
assert !sRange.isDoc();
if (sRange.isLeaf())
{
sEnd = sRange;
pEnd = sRange.getPosLeafEnd() + 1;
}
else if (sRange.isBegin())
{
sEnd = sRange.getFinishSplay();
pEnd = 1;
}
else
{
sEnd = sRange.nextSplay();
pEnd = 0;
}
return compare( r, pThis, sEnd, pEnd ) <= 0;
}
/**
* Compare two positions. Attributes are a bitch.
*/
final int compare ( Root r, int pThis, Splay sThat, int pThat )
{
Splay sThis = this;
assert Root.dv > 0 || sThis.getRootSlow() == r;
assert Root.dv > 0 || sThat.getRootSlow() == r;
assert pThis >= 0 && pThis <= sThis.getEndPos();
assert pThat >= 0 && pThat <= sThat.getEndPos();
// Normalize positions
if (pThis == sThis.getEndPos())
{
if (sThis.isAttr())
{
if ((sThis = sThis.nextSplay()).isAttr())
pThis = 0;
else
{
sThis = sThis.prevNonAttrSplay();
pThis = 1;
}
}
else
{
sThis = sThis.nextNonAttrSplay();
pThis = 0;
}
}
if (pThat == sThat.getEndPos())
{
if (sThat.isAttr())
{
if ((sThat = sThat.nextSplay()).isAttr())
pThat = 0;
else
{
sThat = sThat.prevNonAttrSplay();
pThat = 1;
}
}
else
{
sThat = sThat.nextNonAttrSplay();
pThat = 0;
}
}
assert pThis < sThis.getEndPos();
assert pThat < sThat.getEndPos();
if (sThis == sThat)
return pThis < pThat ? -1 : pThis > pThat ? 1 : 0;
//
if (sThis.isAttr())
{
if (sThat.isAttr())
return compare( r, sThat );
if (sThis.prevNonAttrSplay() != sThat)
return compare( r, sThat );
return pThat == 0 ? 1 : -1;
}
else if (sThat.isAttr())
{
assert !sThis.isAttr();
if (sThat.prevNonAttrSplay() != sThis)
return compare( r, sThat );
return pThis == 0 ? -1 : 1;
}
else
{
return compare( r, sThat );
}
}
private int compare ( Root r, Splay sThat )
{
Splay sThis = this;
if (sThis == sThat)
return 0;
if (r.isLeftOnly())
{
if (sThis.getCchLeft() < sThat.getCchLeft())
return -1;
if (sThis.getCchLeft() > sThat.getCchLeft())
return 1;
if (sThis.getCdocBeginLeft() < sThat.getCdocBeginLeft())
return -1;
if (sThis.getCdocBeginLeft() > sThat.getCdocBeginLeft())
return 1;
while ( sThis != r )
{
sThis = sThis.nextSplay();
if (sThis == sThat)
return -1;
if (sThis.getCch() > 0 || sThis.getCdocBegin() > 0)
break;
}
return 1;
}
if (sThat.isRoot())
return -1;
if (sThis.isRoot())
return 1;
sThis.splay( r, r );
sThat.splay( r, sThis );
assert sThis._leftSplay == sThat || sThis._rightSplay == sThat;
return sThis._leftSplay == sThat ? 1 : -1;
}
final Splay nextNonAttrSplay ( )
{
Splay s = nextSplay();
while ( s != null && s.isAttr() )
s = s.nextSplay();
return s;
}
final Splay prevNonAttrSplay ( )
{
Splay s = prevSplay();
while ( s != null && s.isAttr() )
s = s.prevSplay();
return s;
}
final Splay nextSplay ( )
{
Splay s = this;
Splay r = s._rightSplay;
if (r != null)
{
for ( Splay l = s = r ; (l = l._leftSplay) != null ; )
s = l;
return s;
}
for ( Splay p = s._parentSplay ; ; p = (s = p)._parentSplay )
if (p == null || p._leftSplay == s)
return p;
}
final Splay prevSplay ( )
{
Splay s = this;
Splay l = s._leftSplay;
if (l != null)
{
for ( Splay r = s = l ; (r = r._rightSplay) != null ; )
s = r;
return s;
}
for ( Splay p = s._parentSplay ; ; p = (s = p)._parentSplay )
if (p == null || p._rightSplay == s)
return p;
}
final void rotateRight ( )
{
assert _parentSplay._leftSplay == this;
Splay p = _parentSplay;
Splay g = p._parentSplay;
assert p != null;
p._leftSplay = _rightSplay;
if (_rightSplay != null)
_rightSplay._parentSplay = p;
_rightSplay = p;
p._parentSplay = this;
_parentSplay = g;
if (g != null)
{
if (g._leftSplay == p)
g._leftSplay = this;
else
g._rightSplay = this;
}
p.adjustCchLeft( - getCchLeft() - getCch() );
p.adjustCdocBeginLeft( - getCdocBeginLeft() - getCdocBegin() );
}
final void rotateLeft ( )
{
assert _parentSplay._rightSplay == this;
Splay p = _parentSplay;
Splay g = p._parentSplay;
assert p != null;
p._rightSplay = _leftSplay;
if (_leftSplay != null)
_leftSplay._parentSplay = p;
_leftSplay = p;
p._parentSplay = this;
_parentSplay = g;
if (g != null)
{
if (g._leftSplay == p)
g._leftSplay = this;
else
g._rightSplay = this;
}
adjustCchLeft( p.getCchLeft() + p.getCch() );
adjustCdocBeginLeft( p.getCdocBeginLeft() + p.getCdocBegin() );
}
//
// Splay this so that it's parent is pStop.
//
// This version of splay is capable of splaying this to the top. There
// are two cases. One is there r is this and this is splayed to be
// the left child of r. The other case is where r is null. In this case
// the tree this is in is detached from the main document, and this will be
// splayed to the top of that subtree such that it's parent will be null.
//
final void splay ( Root r, Splay pStop )
{
assert pStop != null;
assert this != pStop;
assert Root.dv > 0 || r == null || getRootSlow() == r;
assert Root.dv > 0 || r == null || pStop.getRootSlow() == r;
assert r == null || r.validateSplayTree();
assert !isRoot();
boolean rotated = false;
for ( ; ; )
{
assert _parentSplay != null;
Splay p = _parentSplay;
assert p != null;
// If this is a child of the stopper, then we are done
if (p == pStop)
break;
Splay g = p._parentSplay;
// If this is child of root, then simple rotate
rotated = true;
if (g == pStop)
{
if (p._leftSplay == this)
rotateRight();
else
rotateLeft();
break;
}
// Fancy splays
if (g._leftSplay == p)
{
if (p._leftSplay == this)
p.rotateRight();
else
rotateLeft();
rotateRight();
}
else
{
if (p._rightSplay == this)
p.rotateLeft();
else
rotateRight();
rotateLeft();
}
}
if (rotated && r != null)
r._leftOnly = false;
assert r == null || r.validateSplayTree();
}
/**
* Remove this splay where root is the splay root of the tree this splay.
* This may be a ROOT splay
*/
final Splay removeSplay ( Splay r )
{
Root root = r.isRoot() ? (Root) r : null;
assert r._parentSplay == null;
assert root == null || root.validateSplayTree();
assert !isRoot();
assert !isDoc();
assert Root.dv > 0 || getSplayRootSlow() == r;
// If the splay to be removed has no cch or cbegin, then when the
// tree is left only children, we need not splay.
int cch = getCch();
int cbegin = getCdocBegin();
if (root != null && root._leftOnly && cch == 0 && cbegin == 0)
{
assert _rightSplay == null;
assert _parentSplay != null;
if ((_parentSplay._leftSplay = _leftSplay) != null)
_leftSplay._parentSplay = _parentSplay;
}
else
{
splay( root, r );
if (_leftSplay == null)
{
r.adjustCchLeft( - cch );
r.adjustCdocBeginLeft( - cbegin );
if ((r._leftSplay = _rightSplay) != null)
_rightSplay._parentSplay = r;
}
else
{
Splay p = prevSplay();
p.splay( root, this );
assert p._rightSplay == null;
r._leftSplay = p;
p._parentSplay = r;
r.adjustCchLeft( - cch );
r.adjustCdocBeginLeft( - cbegin );
p._rightSplay = _rightSplay;
if (p._rightSplay != null)
p._rightSplay._parentSplay = p;
}
}
_leftSplay = _rightSplay = _parentSplay = null;
adjustCchLeft( - getCchLeft() );
adjustCdocBeginLeft( - getCdocBeginLeft() );
assert root == null || root.validateSplayTree();
return this;
}
//
// The Zoo (more like a petting zoo now)
//
static abstract class QNameSplay extends Splay
{
QNameSplay ( int kind, boolean is, QName name )
{
super( kind, is );
_name = name;
}
final QName getName ( ) { return _name; }
final void changeName ( QName name ) { _name = name; }
final String getUri ( ) { return _name.getNamespaceURI(); }
final String getLocal ( ) { return _name.getLocalPart(); }
private QName _name;
}
static abstract class Container extends QNameSplay
{
Container ( int kind, boolean is, QName name )
{ super( kind, is, name ); }
abstract Finish getFinish ( );
}
static final class Doc extends Container
{
Doc ( Root r, QName name )
{ super( DOC, false, name ); _root = r; }
Container getContainer ( ) { return null; }
Finish getFinish ( ) { return _root; }
Root _root;
}
static class Begin extends Container
{
Begin ( QName name, Container container )
{ super( BEGIN, false, name ); _container = container; }
final Container getContainer ( ) { return _container; }
final Finish getFinish ( ) { return _end; }
End _end;
Container _container;
}
static abstract class Finish extends Splay
{
Finish ( int kind ) { super( kind, false ); }
}
static final class End extends Finish
{
End ( Begin begin ) { super( END ); _begin = begin; }
Container getContainer ( ) { return _begin; }
final Begin _begin;
}
static final class Comment extends Splay
{
Comment ( ) { super( COMMENT, false ); }
Container getContainer ( ) { return findContainer(); }
}
static final class Fragment extends Splay
{
Fragment ( ) { super( COMMENT, true ); }
Container getContainer ( ) { return null; }
}
static class Attr extends QNameSplay
{
Attr ( QName name ) { super( ATTR, false, name ); }
Attr ( QName name, boolean isXmlns )
{
super( ATTR, true, name );
assert isXmlns;
}
Container getContainer ( )
{
for ( Splay s = prevSplay() ; ; s = s.prevSplay() )
if (!s.isAttr())
return (Container) s;
}
}
static final class Xmlns extends Attr
{
Xmlns ( QName name ) { super( name, true ); }
}
static final class Procinst extends QNameSplay
{
Procinst ( QName target )
{
super( PROCINST, false, target );
}
Procinst ( String target )
{
super( PROCINST, false, new QName( "", target ) );
}
Container getContainer ( ) { return findContainer(); }
}
/**
* Every splay points to a collection of goobers. Goobers can be
* aggregated into groups which share the same state (kind and position).
*/
static final int CURSOR = 0;
static final int TYPE = 1;
static final int ANNOTATION = 2;
static final int AGGREGATE = 3;
static abstract class Goober extends Goobers
{
Goober ( Root r, int kind )
{
_root = r;
_state = kind;
}
final int getKind ( ) { return _state & 7; }
final Root getRoot ( ) { return _root; }
final Splay getSplay ( ) { return _splay; }
final int getPos ( ) { return _state >> 3; }
final int getState ( ) { return _state; }
final boolean isAnnotation ( ) { return getKind() == ANNOTATION; }
final void set ( Root r, Splay s, int p )
{
assert s != null;
doSet( r, s, p );
}
private final void doSet ( Root r, Splay s, int p )
{
assert s != null || p == 0;
assert Root.dv > 0 || s == null || r == s.getRootSlow();
assert Root.dv > 0 || _splay == null || _root == _splay.getRootSlow();
// assert Root.dv > 0 || _root == r || _splay.getRootSlow() != s.getRootSlow();
_root = r;
if (_splay != s)
{
if (_splay != null)
remove();
if (s != null)
append( s );
}
assert p >= 0;
assert _splay == null || p <= _splay.getMaxPos();
_state = p * 8 + (_state & 7);
}
final void set ( Root r )
{
assert r != null;
_root = r;
}
final void set ( Splay s, int p ) { doSet( getRoot(), s, p ); }
final void set ( int p ) { doSet( getRoot(), getSplay(), p ); }
final void set ( Goober g )
{ doSet( g.getRoot(), g.getSplay(), g.getPos() ); }
void disconnect ( Root r )
{
doSet( r, null, 0 );
}
void release ( )
{
set( null, 0);
_root = null;
}
private final void append ( Splay s )
{
assert s != null;
assert Root.dv > 0 || s.getRootSlow() == _root;
assert _splay == null;
assert _parent == null;
assert _next == null && _prev == null;
if (s._goobers == null)
{
s._goobers = this;
_next = _prev = this;
}
else
{
_next = s._goobers;
_prev = _next._prev;
_next._prev = this;
_prev._next = this;
}
_splay = s;
_parent = s;
}
private final void remove ( )
{
assert _splay != null;
assert _goobers == null;
if (_next == this)
{
assert _parent._goobers == this;
_parent._goobers = null;
// If parent is an aggregate goober, remove it too
if (_parent != _splay)
{
Goober g = (Goober) _parent;
assert g.getKind() == AGGREGATE;
g.remove();
}
}
else
{
_prev._next = _next;
_next._prev = _prev;
if (_parent._goobers == this)
_parent._goobers = _next;
}
_next = _prev = null;
_parent = null;
_splay = null;
}
XmlBookmark getBookmark ( )
{
return
getKind() == ANNOTATION
? ((Annotation) this).getXmlBookmark()
: null;
}
String getKindName ( )
{
switch ( getKind() )
{
case CURSOR : return "CURSOR";
case TYPE : return "TYPE";
case ANNOTATION : return "ANNOTATION";
default : return "<unknow goober kind>";
}
}
private Root _root;
private Splay _splay;
private int _state; // pos and kind
Goober _next;
Goober _prev;
Goobers _parent;
}
static final class CursorGoober extends Goober
{
CursorGoober ( Root r )
{
super( r, CURSOR );
}
private static final HashMap createDebugIdMap ( )
{
// Creepy way to discover is assert is enabled.
HashMap map = null;
assert (map = new HashMap()) != null;
return map;
}
public int getDebugId ( )
{
if (_debugIds == null)
return -1;
synchronized ( _debugIds )
{
if (!_debugIds.containsKey( this ))
_debugIds.put( this, new Integer( _nextDebugId++ ) );
return ((Integer) _debugIds.get( this )).intValue();
}
}
private static final HashMap _debugIds = createDebugIdMap();
private static int _nextDebugId = 1;
}
static class Annotation extends Goober implements XmlMark
{
public Object monitor()
{
return getRoot();
}
Annotation ( Root r )
{
super( r, ANNOTATION );
}
Annotation ( Root r, XmlBookmark a )
{
this( r );
if (a._ref == null)
_annotation = a;
else
_ref = a._ref;
_key = a.getKey();
}
void setKey ( Object key )
{
_key = key;
}
// called via bookmark (public via XmlMark)
public final XmlCursor createCursor ( )
{
synchronized (monitor())
{
if (getSplay() == null)
{
throw new IllegalStateException(
"Attempting to create a cursor on a bookmark that " +
"has been cleared or replaced.");
}
return new Cursor( getRoot(), getSplay(), getPos() );
}
}
public XmlBookmark getXmlBookmark ( )
{
if (_annotation != null)
return _annotation;
if (_ref != null)
return (XmlBookmark) _ref.get();
return null;
}
void disconnect ( Root r )
{
super.disconnect( r );
XmlBookmark xa = getXmlBookmark();
if (xa != null)
xa._currentMark = null;
}
XmlBookmark _annotation;
Reference _ref;
Object _key;
}
final Goober firstGoober ( )
{
if (_goobers == null || _goobers.getKind() != AGGREGATE)
return _goobers;
assert _goobers._goobers != null;
assert _goobers._goobers.getKind() != AGGREGATE;
return _goobers._goobers;
}
final Goober nextGoober ( Goober g )
{
assert g != null;
if ((g = g._next) != g._parent._goobers)
return g;
return g._parent == g._splay ? null : nextGoober( (Goober) g._parent );
}
static final boolean _assertEnabled = getAssertEnabled();
private static boolean getAssertEnabled ( )
{
// Creepy way to discover is assert is enabled.
boolean enabled = false;
assert (enabled = true) || true;
return enabled;
}
static void assertAssertEnabled ( )
{
if (!_assertEnabled)
{
throw
new RuntimeException(
"Assert needs to be enabled for this operation" );
}
}
// Associate id's with splays when asserts are enabled
private static final HashMap _debugIds =
_assertEnabled ? new HashMap() : null;
private static int _nextDebugId = 1;
public int getDebugId ( )
{
if (_debugIds == null)
return -1;
synchronized ( _debugIds )
{
if (!_debugIds.containsKey( this ))
_debugIds.put( this, new Integer( _nextDebugId++ ) );
return ((Integer) _debugIds.get( this )).intValue();
}
}
void dump ( ) { getRootSlow().dump(); }
void dump ( boolean verbose ) { getRootSlow().dump( verbose ); }
public Splay getSplayRootSlow ( )
{
assertAssertEnabled();
Splay s = this;
while ( s._parentSplay != null )
s = s._parentSplay;
return s;
}
public Root getRootSlow ( )
{
assertAssertEnabled();
Splay s = getSplayRootSlow();
return s.isRoot() ? (Root) s : null;
}
int getCpSlow ( )
{
assertAssertEnabled();
int cch = 0;
for ( Splay s = this ; (s = s.prevSplay()) != null ; )
cch += s.getCch();
return cch;
}
int compareSlow ( Splay sThat )
{
assertAssertEnabled();
assert Root.dv > 0 || getRootSlow() == sThat.getRootSlow();
if (this == sThat)
return 0;
for ( Splay s = this ; s != null ; s = s.nextSplay() )
if (s == sThat)
return -1;
for ( Splay s = this ; s != null ; s = s.prevSplay() )
if (s == sThat)
return 1;
assert false: "Yikes!";
return 0;
}
boolean validate ( )
{
assertAssertEnabled();
return getRootSlow().validate();
}
//
// Document splay tree members
//
Splay _leftSplay;
Splay _rightSplay;
Splay _parentSplay;
private int _bits; // 27: cDocbeginLeft, 1: invalid, 1: multi, 3: kind
private int _cch;
private int _cchAfter;
private int _cchLeft;
}