public EntityReferenceImpl(CoreDocumentImpl ownerDoc,
    String name) 
{
    
    //protected int entityChanges = -1;	
    //protected boolean fEnableSynchronize = false;
    //
    // Constructors
    //
        super(ownerDoc);
        this.name = name;
        isReadOnly(true);
        needsSyncChildren(true);
}

Factory constructor.

 public Node cloneNode(boolean deep) 
{
        EntityReferenceImpl er = (EntityReferenceImpl)super.cloneNode(deep);
        er.setReadOnly(true, deep);
        return er;
}

Clone node.

 public String getBaseURI() 
{
        if (needsSyncData()) {
            synchronizeData();
        }
        if (baseURI == null) {
            DocumentType doctype;
            NamedNodeMap entities;
            EntityImpl entDef;
            if (null != (doctype = getOwnerDocument().getDoctype()) && 
                null != (entities = doctype.getEntities())) {
                entDef = (EntityImpl)entities.getNamedItem(getNodeName());
                if (entDef !=null) {
                    return entDef.getBaseURI();
                }
            }
        } else if (baseURI != null && baseURI.length() != 0 ) {// attribute value is always empty string
            try {
                return new URI(baseURI).toString();
            }
            catch (org.apache.xerces.util.URI.MalformedURIException e){
                // REVISIT: what should happen in this case?
                return null;
            }
        }        
        return baseURI;
}

Returns the absolute base URI of this node or null if the implementation wasn't able to obtain an absolute URI. Note: If the URI is malformed, a null is returned.

 protected String getEntityRefValue() 
{
        if (needsSyncChildren()){
            synchronizeChildren();
        }
        String value = "";
        if (firstChild != null){
          if (firstChild.getNodeType() == Node.ENTITY_REFERENCE_NODE){
              value = ((EntityReferenceImpl)firstChild).getEntityRefValue();
          }
          else if (firstChild.getNodeType() == Node.TEXT_NODE){
            value = firstChild.getNodeValue();
          }
          else {
             // invalid to have other types of nodes in attr value
            return null;
          }
          if (firstChild.nextSibling == null){
            return value;
          }
          else {
            StringBuffer buff = new StringBuffer(value);
            ChildNode next = firstChild.nextSibling;
            while (next != null){   
                if (next.getNodeType() == Node.ENTITY_REFERENCE_NODE){
                   value = ((EntityReferenceImpl)next).getEntityRefValue();
                }
                else if (next.getNodeType() == Node.TEXT_NODE){
                  value = next.getNodeValue();
                }
                else {
                    // invalid to have other types of nodes in attr value
                    return null;
                }
                buff.append(value);
                next = next.nextSibling;
            }
            return buff.toString();  
          }   
        } 
        return "";
}

NON-DOM: compute string representation of the entity reference. This method is used to retrieve a string value for an attribute node that has child nodes.

 public String getNodeName() 
{
        if (needsSyncData()) {
            synchronizeData();
        }
        return name;
}

Returns the name of the entity referenced

 public short getNodeType() 
{
        return Node.ENTITY_REFERENCE_NODE;
}

A short integer indicating what type of node this is. The named constants for this value are defined in the org.w3c.dom.Node interface.

 public  void setBaseURI(String uri) 
{
        if (needsSyncData()) {
            synchronizeData();
        }
        baseURI = uri;
}

NON-DOM: set base uri

 public  void setReadOnly(boolean readOnly,
    boolean deep) 
{
        if (needsSyncData()) {
            synchronizeData();
        }
        if (deep) {
            if (needsSyncChildren()) {
                synchronizeChildren();
            }
            // Recursively set kids
            for (ChildNode mykid = firstChild;
                 mykid != null;
                 mykid = mykid.nextSibling) {
                mykid.setReadOnly(readOnly,true);
            }
        }
        isReadOnly(readOnly);
}

NON-DOM: sets the node and its children value.

Note: make sure that entity reference and its kids could be set readonly.

 protected  void synchronizeChildren() 
{
        // no need to synchronize again
        needsSyncChildren(false);
        DocumentType doctype;
        NamedNodeMap entities;
        EntityImpl entDef;
        if (null != (doctype = getOwnerDocument().getDoctype()) && 
            null != (entities = doctype.getEntities())) {
            entDef = (EntityImpl)entities.getNamedItem(getNodeName());
            // No Entity by this name, stop here.
            if (entDef == null)
                return;
            // If entity's definition exists, clone its kids
            isReadOnly(false);
            for (Node defkid = entDef.getFirstChild();
                defkid != null;
                defkid = defkid.getNextSibling()) {
                Node newkid = defkid.cloneNode(true);
                insertBefore(newkid, null);
            }
            setReadOnly(true, true);
        }
}

EntityReference's children are a reflection of those defined in the named Entity. This method creates them if they haven't been created yet. This doesn't support editing the Entity though, since this only called once for all.