xbrlxlinkhandlerimpl.java

xbrlapi的源码

package org.xbrlapi.xlink.handler;

import java.net.MalformedURLException;
import java.net.URL;

import org.apache.log4j.Logger;
import org.xbrlapi.Arc;
import org.xbrlapi.ExtendedLink;
import org.xbrlapi.Locator;
import org.xbrlapi.Resource;
import org.xbrlapi.SimpleLink;
import org.xbrlapi.Title;
import org.xbrlapi.SAXHandlers.ElementState;
import org.xbrlapi.impl.ArcImpl;
import org.xbrlapi.impl.EntityResourceImpl;
import org.xbrlapi.impl.ExtendedLinkImpl;
import org.xbrlapi.impl.FootnoteResourceImpl;
import org.xbrlapi.impl.LabelResourceImpl;
import org.xbrlapi.impl.LocatorImpl;
import org.xbrlapi.impl.ReferenceResourceImpl;
import org.xbrlapi.impl.ResourceImpl;
import org.xbrlapi.impl.SimpleLinkImpl;
import org.xbrlapi.impl.TitleImpl;
import org.xbrlapi.loader.Loader;
import org.xbrlapi.utilities.Constants;
import org.xbrlapi.utilities.XBRLException;
import org.xbrlapi.xlink.XLinkException;
import org.xbrlapi.xlink.XLinkHandlerDefaultImpl;
import org.xbrlapi.xmlbase.BaseURLSAXResolver;
import org.xbrlapi.xmlbase.XMLBaseException;
import org.xbrlapi.xpointer.resolver.PointerResolver;
import org.xml.sax.Attributes;
/**
 * XBRL XLink Handler
 * 
 * This class provides a real world example of an XLink handler for XBRL.
 * 
 * 
 * @author Geoffrey Shuetrim ([e-mail])
*/

public class XBRLXLinkHandlerImpl extends XLinkHandlerDefaultImpl {

	protected static Logger logger = Logger.getLogger(XBRLXLinkHandlerImpl.class);	
	
	/**
	 * The XBRL DTS loader that is using this XLink handler
	 */
	private Loader loader;
	
	/**
	 * The XPointer Resolver implementation to be used by the
	 * XLink handler
	 */
	private PointerResolver xptrResolver;

	/**
	 * The base URL resolver used by the XLink handler
	 */
	private BaseURLSAXResolver baseURLResolver;
		
	/**
	 * The depth of the element being examined for XLink 
	 * characteristics in the containing tree.  This is updated
	 * by the content handler each time a new element is started
	 * by the content handler.
	 */
	private long depth;
	
    /**
     * Data required to track the element scheme XPointer 
     * expressions that can be used to identify XBRL fragments.
     */
	private ElementState state;
	
	/**
	 * XBRL XLink handler constructor
	 */
	public XBRLXLinkHandlerImpl() {
		super();
		this.baseURLResolver = null;
		this.xptrResolver = null;
		this.loader = null;
	}

	/**
	 * Set the XBRL DTS loader
	 * @param loader The XBRL DTS loader
	 */
	public void setLoader(Loader loader) {
		this.loader = loader;
	}
	
	/**
	 * Set the base URL resolver for the XBRL XLink handler.
	 * @param resolver the base URL resolver used by the XLink handler.
	 */
	public void setBaseURLSAXResolver(BaseURLSAXResolver resolver) {
		baseURLResolver = resolver;
	}
	
	/**
	 * Set the XPointer resolver for the XBRL XLink handler.
	 * @param resolver the XPointer resolver used by the XLink handler.
	 */
	public void setXPointerResolver(PointerResolver resolver) {
		xptrResolver = resolver;
	}
	
	/**
	 * Handle the XML Base attribute discovery
	 * @param value the Value of the XML Base attribute
	 */
	public void xmlBaseStart(String value) throws XLinkException {
		try {
			baseURLResolver.addBaseURL(value);
		} catch (XMLBaseException e) {
			throw new XLinkException("The Base URL Resolver could not update the base URL",e);
		}
	}

	/**
	 * Creates and stores an XLink title fragment.
	 */
	public void startTitle(String namespaceURI, String lName, String qName,
			Attributes attrs) throws XLinkException {
		Title title = null;
		try {
			Loader loader = this.getLoader();
			title = new TitleImpl();
			title.setFragmentIndex(getLoader().getNextFragmentId());

			loader.addFragment(title,depth, state);
		} catch (XBRLException e) {
			throw new XLinkException("The title could not be created and stored.",e);
		}
	}
	
	/**
	 * Handle the change of XML Base scope as you step back up the tree
	 */
	public void xmlBaseEnd() throws XLinkException {
			try {
				 baseURLResolver.removeBaseURL();
			} catch (XMLBaseException e) {
				throw new XLinkException("The Base URL Resolver could not revert to the previous base URL",e);
			}
	}

	/**
	 * The extended link processing algorithm, central to this implementation, 
	 * operates as follows:
	 * <ul>
	 * <li>Store all locators and resources that are found in the extended link 
	 * in a map of lists where the map is indexed by XLink label attribute values
	 * and each list is made up of the locators and resources that have been found
	 * in the extended link that carry the same XLink label.
	 * </li>
	 * <li> 
	 * Preprocess the XLink href attribute values on locators to determine those
	 * locators linking to XML resources that have already been discovered and 
	 * parsed and those linking to XML resources that are yet to be parsed.  For 
	 * locators linking to parsed XML resources, add a relationship element to the
	 * locator containing the DTS index of the resource and add a relationship
	 * element to the resource containing the DTS index of the locator (The DTS
	 * index is the index attribute value unique within the DTS that is given to 
	 * various elements during the discovery process.)  For locators linked to 
	 * unparsed XML resources, place them in map of unprocessed locators, indexed
	 * by the href attribute value of the locator so that a resource can quickly 
	 * find all locators that point to them using the map and knowing their location.
	 * </li>
	 * <li>
	 * Store all arcs that are found in the extended link in a stack ready for 
	 * processing once the end of the extended link has been found.
	 * </li>
	 * </ul>
	 */
	public void startExtendedLink(
			String namespaceURI, 
			String lName,
			String qName, 
			Attributes attrs, 
			String role, 
			String title)
			throws XLinkException {
		
		// Create the extended link fragment
		try {
			ExtendedLink link = new ExtendedLinkImpl();
			link.setFragmentIndex(getLoader().getNextFragmentId());
			if (attrs.getValue("id") != null) {
				link.appendID(attrs.getValue("id"));
				state.setId(attrs.getValue("id"));
			}
			getLoader().addFragment(link,depth, state);
		} catch (XBRLException e) {
			throw new XLinkException("The extended link could not be created.",e);
		}
	}

	/**
	 * Nothing needs to be done at the end of the extended link discovery.
	 */
	public void endExtendedLink(String namespaceURI, String sName, String qName)
			throws XLinkException {
		;
	}
	
	/**
	 * TODO Avoid using classes to differentiate XLink resources.
	 * Create the resource and add it to the map of arc anchors ready to be processed
	 * once the end of the containing extended link has been found.
	 */
	public void startResource(
			String namespaceURI, 
			String lName, 
			String qName,
			Attributes attrs, 
			String role, 
			String title, 
			String label)
			throws XLinkException {
		try {
			Resource resource = null;
			if (namespaceURI.equals(Constants.XBRL21LinkNamespace)) {
				if (lName.equals("label")) {
					resource = new LabelResourceImpl();
				} else if (lName.equals("reference")) {
					resource = new ReferenceResourceImpl();
				} else if (lName.equals("footnote")) {
					resource = new FootnoteResourceImpl();
				} else {
					resource = new ResourceImpl();				
				}
			} else if (namespaceURI.equals(Constants.GenericLabelNamespace)) {
				if (lName.equals("label")) {
					resource = new LabelResourceImpl();			
				} else {
	                resource = new ResourceImpl();
	            }
			} else if (namespaceURI.equals(Constants.GenericReferenceNamespace)) {
				if (lName.equals("reference")) {
					resource = new ReferenceResourceImpl();				
				} else {
	                resource = new ResourceImpl();
	            }
            } else if (namespaceURI.equals(Constants.XBRLAPIEntitiesNamespace)) {
                if (lName.equals("identifier")) {
                    resource = new EntityResourceImpl();             
                } else {
                    resource = new ResourceImpl();
                }
			} else {
				resource = new ResourceImpl();
			}
			resource.setFragmentIndex(getLoader().getNextFragmentId());

			if (attrs.getValue("id") != null) {
				resource.appendID(attrs.getValue("id"));
				state.setId(attrs.getValue("id"));
			}

			getLoader().addFragment(resource,depth, state);
		} catch (XBRLException e) {
			throw new XLinkException("The resource could not be created.",e);
		}
	}

	/**
	 * Handle the end of the resource.
	 */
	public void endResource(String namespaceURI, String sName, String qName) throws XLinkException {
		;// Do Nothing.
	}
	
	/**
	 * Create the locator fragment and then add it to the map of arc anchors.
	 * Finally queue up the locator href value in the exploration queue.
	 */
	public void startLocator(
			String namespaceURI, 
			String lName, 
			String qName,
			Attributes attrs, 
			String href, 
			String role, 
			String title,
			String label) 
	throws XLinkException {
		try {
			URL url = new URL(baseURLResolver.getBaseURL(),href);
			Loader loader = getLoader();
			Locator locator = new LocatorImpl();
			locator.setFragmentIndex(loader.getNextFragmentId());
			locator.setTarget(url);
			loader.addFragment(locator,depth, state);
			loader.stashURL(url);
		} catch (MalformedURLException e) {
			throw new XLinkException("The locator href is malformed.",e);
		} catch (XMLBaseException e) {
			throw new XLinkException("The locator href could not be queued up for processing.",e);
		} catch (XBRLException e) {
			throw new XLinkException("The locator href could not be queued up for processing.",e);
		}
	}

	/**
	 * Handle the end of the locator.
	 */
	public void endLocator(String namespaceURI, String sName, String qName) throws XLinkException {
		;
	}
	
	/**
	 * Create the arc fragment first. Then add the arc to the 
	 * stack of arcs to be processed.
	 */
	public void startArc(
			String namespaceURI, 
			String lName, 
			String qName,
			Attributes attrs, 
			String from, 
			String to, 
			String arcrole,
			String title, 
			String show, 
			String actuate) throws XLinkException {
		try {
			Arc arc = new ArcImpl();				
    		arc.setFragmentIndex(getLoader().getNextFragmentId());
			getLoader().addFragment(arc,depth, state);
		} catch (XBRLException e) {
			throw new XLinkException("The arc could not be created.",e);
		}
	}
	
	/**
	 * Handle the end of the arc.
	 */
	public void endArc(String namespaceURI, String sName, String qName) throws XLinkException {
		;
	}
	
	/**
	 * Add the href to the set of XML documents to be explored and 
	 * create the fragment for the simple link.
	 * TODO Should simple links generate relationship metadata?
	 */
	public void startSimpleLink(
			String namespaceURI, 
			String lName,
			String qName, 
			Attributes attrs, 
			String href, 
			String role,
			String arcrole, 
			String title, 
			String show, 
			String actuate)
			throws XLinkException {
		
		try {
			URL url = new URL(baseURLResolver.getBaseURL(),href);
			Loader loader = getLoader();
			SimpleLink link = new SimpleLinkImpl();
			link.setFragmentIndex(getLoader().getNextFragmentId());
			link.setTarget(url);
			loader.addFragment(link,depth, state);
			loader.stashURL(url);
			
		} catch (MalformedURLException e) {
			throw new XLinkException("The URL on a simple link was malformed.",e);
		} catch (XBRLException e) {
			throw new XLinkException("The URL on a simple link could not be queued up for exploration in DTS discovery.",e);
		} catch (XMLBaseException e) {
			throw new XLinkException("The URL on a simple link could not be queued up for exploration in DTS discovery.",e);
		}
		
	}
	
	/**
	 * Handle the end of the simple link
	 */
	public void endSimpleLink(String namespaceURI, String sName, String qName) throws XLinkException {
		;// Do nothing
	}
		
	/**
	 * Returns the XBRL DTS loader that is using this XLink handler.
	 * @return The XBRL DTS loader that is using this XLink handler.
	 * @throws XBRLException if the XLink handler has no loader to work with.
	 */
	private Loader getLoader() throws XBRLException {
		if (loader == null)
			throw new XBRLException("The XLink Handler has no XBRL DTS loader to work with.");
		return loader;
	}

	public void setDepth(long depth) {
		this.depth = depth; 
	}
	
	private long getDepth() {
		return depth; 
	}
	
	public void setState(ElementState state) {
		this.state = state; 
	}
	
	private ElementState getState() {
		return state; 
	}	
	
}