documentimpl.java

Java的面向对象数据库系统的源代码

        }
        return entity;
    }

    /**
     * Creates a document type with the specified name (the name follows the
     * <TT>!DOCTYPE</TT> entity) and associates it with the document.
     * If the document is HTML or already has a DTD associated with it, throws
     * an exception. This method is not defined in the DOM but is used by the
     * parser.
     *
     * @param name The name of the document type
     * @param name The public identifier, if exists
     * @param name The system identifier, if exists
     * @throws org.w3c.dom.DOMException <T>NOT_SUPPORTED_ERR</TT>
     *  Document is HTML or already has a DTD
     */
    /*
    public final DocumentType createDocumentType (String name, String publicId,
                                                  String systemId)
                                                  throws DOMException {
        if (isHtmlDoc () || _docType != null)
            throw new DOMExceptionImpl (DOMException.NOT_SUPPORTED_ERR);
        _docType = new DocumentTypeImpl( this, name );
        return _docType;
        }
     */


    public final NodeList getElementsByTagName( String tagName ) {
        return new org.ozoneDB.xml.dom.ElementListImpl( this, tagName );
    }


    /**
     * Return true if certain feature for specific DOM version supported by this
     * implementation.
     *
     * @param feature Name of feature to check
     * @param version Optional version number
     * @return True if supported
     */
    public boolean hasFeature( String feature, String version ) {
        // Versions higher than 1.0 not supported yet.
        if (version != null) {
            if (version.indexOf( "1.0" ) < 0 && version.indexOf( "Level 1" ) < 0) {
                return false;
            }
        }
        // Supports XML and HTML.
        if (feature != null) {
            if (feature.equalsIgnoreCase( "XML" ) || feature.equalsIgnoreCase( "HTML" )) {
                return true;
            }
        }
        return false;
    }


    /**
     * Register an application-defined element type. The element's tag name and
     * class are specified. When a so named element is created with {@link
     * #createElement}, an object of the specified class is created and returned.
     * This allows applications to define classes for specific element types.
     *
     * @param tagName The name of the element tag
     * @param elementClass Class derived from {@link org.ozoneDB.xml.XMLElement},
     *  used to construct the element
     */
    public void registerElement( String tagName, Class elementClass ) {
        if (tagName == null || tagName.length() == 0) {
            throw new NullPointerException( "Argument 'tagName' is null or an empty string." );
        }
        if (elementClass == null || elementClass.isAssignableFrom( Element.class )) {
            throw new IllegalArgumentException( "Argument 'elementClass' is null or does not extend Element." );
        }
        if (_elementTypes == null) {
            _elementTypes = new Hashtable();
        }
        _elementTypes.put( tagName, elementClass );
    }


    public void assignDoctype( DocumentTypeProxy docType ) {
        if (docType == null) {
            throw new NullPointerException( "Argument 'docType' is null." );
        }
        if (_docType != null) {
            throw new IllegalStateException( "Document type already assigned to this document." );
        }
        _docType = docType;
    }

    /**
     * Implements a lock mechanism. The lock mechanism differs from synchronization
     * in that it supports multiple function calls, while still preserving the lock
     * granted to a specific thread. Caution is required as other threads may obtain
     * access without first acquiring lock. All implementations of the lock mechanism
     * should use {@link #lock}, {@link #unlock} and {@link #acquire} to assure true
     * synchronization.
     * <P>
     * Calling {@link #lock} obtains a lock to the current running thread. If the
     * lock has already been granted to some other thread, this call will block
     * until the lock is released or until the lock has timed out.
     * <P>
     * Calling {@link #unlock} releases the lock from the current thread, if still
     * held by the current thread. A thread may call {@link #lock} any number of
     * times and must call {@link #unlock} that number of times to release the
     * lock. The thread may call {@link #unlock} an additional number of times if
     * necessary by the implementation.
     * <P>
     * If a thread requires access to a resource that might be lock, it should
     * acquire it by calling {@link #acquire}. This method will block until the
     * resource is unlocked by some other thread. If the resource is unlocked,
     * or locked by the current thread, {@link #acquire} will return immediately.
     */


    /**
     * Obtains a lock, preventing other threads from gaining access to the locked
     * resource. The lock is retained across multiple calls, until {@link #unlock}
     * is called. Attempts to call {@link #acquire} from another thread will be
     * blocked.
     * <P>
     * If the resource is already locked by another thread, the method will
     * block until the lock is released or until the block has timedout.
     * <P>
     * {@link #lock} may be called any number of times, and {@link #unlock} must
     * be called that number of times to release the lock.
     *
     * @see #unlock
     */
    public void lock() throws RuntimeException {
        synchronized (this) {
            // If current thread is locking, increase the lock count.
            // Otherwise, wait for lock to be released, acquire the lock and
            // increase the lock count. If timeout has reached or thread has
            // been interrupted, acquire() will throw an exception.
            if (_lockThread == Thread.currentThread()) {
                ++_lockCount;
            } else {
                acquire( Long.MAX_VALUE );
                _lockThread = Thread.currentThread();
                ++_lockCount;
            }
        }
    }


    /**
     * Releases a lock, so other thread may gain access to the resource. {@link
     * #unlock} must be called as many times as {@link #lock} was called to
     * release the lock. {@link #unlock} may be called an additional number of
     * times, if so required by the implementation (e.g. to assure that a lock
     * is released at the end of a thread).
     *
     * @see #lock
     */
    public void unlock() {
        // If the current thread is locking, decrease the lock count.
        // If the lock count is zero, release the lock, otherwise unlock()
        // must be called again to release lock.
        if (_lockThread == Thread.currentThread()) {
            synchronized (this) {
                --_lockCount;
                if (_lockCount == 0) {
                    _lockThread = null;
                    notify();
                }
            }
        }
    }


    /**
     * Called to acquire access to a possible locked resource. If the resource
     * was locked by the current thread, the method will return immediately.
     * If the resource was locked by some other thread, the method will block
     * until the resource is unlocked, or the block has timed out.
     *
     * @see #lock
     * @see #unlock
     */
    public void acquire( long lockTimeout ) throws RuntimeException {
        long start;

        synchronized (this) {
            try {
                // If the application is not locked by the current thread,
                // wait until the application is unlocked, then proceed.
                if (_lockThread != Thread.currentThread() && _lockThread != null) {
                    // Remember when started waiting for lock to implement
                    // timeout. Repeat until lock is released by other thread,
                    // or until timeout has expired.
                    start = System.currentTimeMillis();
                    while (_lockThread != null && lockTimeout > (System.currentTimeMillis() - start)) {
                        // If the locking thread is dead, release the lock
                        // immediately, otherwise, wait for it to be released.
                        if (!_lockThread.isAlive()) {
                            _lockThread = null;
                        } else {
                            wait( lockTimeout - System.currentTimeMillis() - start );
                        }
                    }
                    // Timeout, throw an exception.
                    if (_lockThread != null) {
                        throw new RuntimeException( "Timeout waiting for lock to be released." );
                    }
                }
            } catch (InterruptedException except) {
                // Thread interrupted, throw an exception.
                throw new RuntimeException( "Timeout waiting for lock to be released." );
            }
        }
    }


    public synchronized boolean equals( Object other ) {
        DocumentProxy otherX;

        // Use Node's equals method to perform the first tests of equality.
        // If these tests do not pass, return false.
        if (!super.equals( other )) {
            return false;
        }

        // Very simple equality test: are the document types equal.
        // There's nothing else about the document to compare.
        synchronized (other) {
            otherX = (DocumentProxy)other;
            return
                    getDoctype() == null && otherX.getDoctype() == null || getDoctype() != null && otherX.getDoctype()
                    != null && _docType.equals( otherX.getDoctype() );
        }
    }


    public Object clone() {
        DocumentProxy clone = null;
        try {
            clone = (DocumentProxy)database().createObject( DocumentImpl.class.getName() );
            cloneInto( clone, true );
        } catch (Exception except) {
            throw new DOMExceptionImpl( DOMExceptionImpl.PDOM_ERR, except.getMessage() );
        }
        return clone;
    }


    public Node cloneNode( boolean deep ) {
        DocumentProxy clone = null;
        try {
            clone = (DocumentProxy)database().createObject( DocumentImpl.class.getName() );
            cloneInto( clone, deep );
        } catch (Exception except) {
            throw new DOMExceptionImpl( DOMExceptionImpl.PDOM_ERR, except.getMessage() );
        }
        return clone;
    }

    public String toString() {
        return "Document: ";
    }


    public synchronized void cloneInto( NodeProxy into, boolean deep ) {

        // Use the Node cloning method. The DOM object does not need cloning,
        // but the document type (which contains entities, notations, etc)
        // must be cloned.
        super.cloneInto( into, deep );
        if (deep) {
            if (_docType != null) {
                ((DocumentProxy)into).setDoctype( (DocumentTypeProxy)_docType.clone() );
            }
            // If application elements are defined, clone the list as well.
            if (_elementTypes != null) {
                ((DocumentProxy)into).setElementTypes( (Hashtable)_elementTypes.clone() );
            }
        } else {
            ((DocumentProxy)into).setDoctype( _docType );
            ((DocumentProxy)into).setElementTypes( _elementTypes );
        }
    // ((DocumentProxy)into).setElementFactory (_elementFactory);
    }


    protected final boolean supportsChildern() {
        return true;
    }


    public DocumentImpl() {
        super( null, "#document", null, false );
        _ownerDocument = this;
    }


    protected DocumentImpl( String rootElement ) {
        super( null, rootElement != null ? rootElement : "", null, rootElement != null );
        _ownerDocument = this;
    }


    public void onDelete() {
        clearDocument();
    }


    private void deleteAllChildern( Node node ) {
        Node dummyNode;
        while (node != null) {
            if (node.hasChildNodes()) {
                deleteAllChildern( node.getFirstChild() );
            }
            dummyNode = node.getNextSibling();
            System.out.println( "deleting " + node.getNodeName() );
            database().deleteObject( (OzoneRemote)node );
            node = dummyNode;
        }
    }

    /**
     * Deletes all child Nodes from this Document to provide a fresh and
     * empty Document. Attention: This methods permanently removes the
     * existing content!
     */
    public void clearDocument() {
        // System.out.println( "clearDocument() " );
        if (_docType != null) {
            database().deleteObject( _docType );
        }
        Node node = getFirstChild();
        while (node != null) {
            deleteAllChildern( node );
            node = getNextSibling();
        }
    }

}