Java ProcessingInstruction类代码示例

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
/**
 * Parses an {@link ProcessingInstruction XML event} of a
 * processing instruction.
 * @param pi the event to parse
 * @return the data from the processing instruction or <code>null</code>
 * if the event is {@link #isIgnoredPI(ProcessingInstruction) ignored}
 * by this parser
 */
public TocPIData parse(ProcessingInstruction pi) throws JAXBException
{
 if (isIgnoredPI(pi))
  return null;
 String rawData = pi.getData();
 rawData = null == rawData ? "" : rawData.trim();
 boolean closing = rawData.endsWith("/");
 if (closing)
  rawData = rawData.substring(0, rawData.length() - 1).trim();
 TocPIData data;
 if (0 < rawData.length())
  data = parseAttrs(rawData);
 else if (closing)
  data = new TocPIData();
 else
  throw new JAXBException("Processing instruction contains no data");
 data.setClosing(closing);
 return data;
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
private void handlePI(ProcessingInstruction event)
    throws XMLStreamException {
    try {
        _sax.processingInstruction(
            event.getTarget(),
            event.getData());
    } catch (SAXException e) {
        throw new XMLStreamException(e);
    }
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
@Override
public String getPITarget() {
	if (this.event.isProcessingInstruction()) {
		return ((ProcessingInstruction) this.event).getTarget();
	}
	else {
		throw new IllegalStateException();
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
@Override
public String getPIData() {
	if (this.event.isProcessingInstruction()) {
		return ((ProcessingInstruction) this.event).getData();
	}
	else {
		throw new IllegalStateException();
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
@Override
public String getPITarget() {
    XMLSecEvent xmlSecEvent = getCurrentEvent();
    if (xmlSecEvent.getEventType() != PROCESSING_INSTRUCTION) {
        throw new IllegalStateException(ERR_STATE_NOT_PI);
    }
    return ((ProcessingInstruction) xmlSecEvent).getTarget();
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
@Override
public String getPIData() {
    XMLSecEvent xmlSecEvent = getCurrentEvent();
    if (xmlSecEvent.getEventType() != PROCESSING_INSTRUCTION) {
        throw new IllegalStateException(ERR_STATE_NOT_PI);
    }
    return ((ProcessingInstruction) xmlSecEvent).getData();
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
public String getPITarget() {
	if (event.isProcessingInstruction()) {
		return ((ProcessingInstruction) event).getTarget();
	}
	else {
		throw new IllegalStateException();
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
public String getPIData() {
	if (event.isProcessingInstruction()) {
		return ((ProcessingInstruction) event).getData();
	}
	else {
		throw new IllegalStateException();
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
private void processEvent(XmlParserContext ctx, XMLEvent xmlEvent) throws BagriException {
	
	if (ctx.getDocRoot() == null) {
		ctx.firstEvents.add(xmlEvent);
		if (xmlEvent.getEventType() == XMLStreamConstants.START_ELEMENT) {
			String root = "/" + xmlEvent.asStartElement().getName();
			ctx.addDocument(root);
			for (XMLEvent event: ctx.firstEvents) {
				processEvent(ctx, event);
			}
		}
	} else {
		switch (xmlEvent.getEventType()) {
			case XMLStreamConstants.START_ELEMENT:
				startElement(ctx, xmlEvent.asStartElement());
				break;
			case XMLStreamConstants.CHARACTERS:
				if (!xmlEvent.asCharacters().isWhiteSpace()) {
					ctx.addCharacters(xmlEvent.asCharacters().getData());
				}
				break;
			case XMLStreamConstants.END_ELEMENT:
				ctx.endElement();
				break;
			case XMLStreamConstants.ATTRIBUTE:
				ctx.addAttribute(((Attribute) xmlEvent).getName(), ((Attribute) xmlEvent).getValue());
				break;
			case XMLStreamConstants.COMMENT:
				ctx.addComment(((Comment) xmlEvent).getText());
				break;
			case XMLStreamConstants.PROCESSING_INSTRUCTION:
				ctx.addProcessingInstruction(((ProcessingInstruction) xmlEvent).getTarget(), ((ProcessingInstruction) xmlEvent).getData());
				break;
			default:
				break;
		}
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
public String getPITarget() {
	if (this.event.isProcessingInstruction()) {
		return ((ProcessingInstruction) this.event).getTarget();
	}
	else {
		throw new IllegalStateException();
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
public String getPIData() {
	if (this.event.isProcessingInstruction()) {
		return ((ProcessingInstruction) this.event).getData();
	}
	else {
		throw new IllegalStateException();
	}
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
public void processingInstruction(ProcessingInstruction event)
        throws XMLStreamException {
    String data = event.getData();
    if (data != null && data.length() > 0) {
        fStreamWriter.writeProcessingInstruction(event.getTarget(), data);
    }
    else {
        fStreamWriter.writeProcessingInstruction(event.getTarget());
    }
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
@Override
public void add(XMLEvent event) throws XMLStreamException
{
 if (event instanceof ProcessingInstruction)
 {
  if (null == piData)
   piData = parsePIEvent((ProcessingInstruction)event);
 }
 else
  piData = null;
 if (null != piData)
 {
  if (piData.isOpening())
  {
   formatter = TocFormatter.forPI(piData, event.getLocation());
   formatter.setXMLEventFactory(getXMLEventFactory());
  }
  if (piData.isClosing())
   super.add(getXMLEventFactory().createCharacters("\n"));
 }
 else if (state == State.INDEXED)
  index(event);
 else if (state == State.ROOT)
 {
  addDTD((StartElement)event);
  super.add(event);
  state = State.PASSTHROUGH;
 }
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
protected void trackContext(XMLEvent event)
{
 switch (event.getEventType())
 {
 case START_ELEMENT:
  context.add(0, (StartElement)event);
  break;
 case END_DOCUMENT:
 case END_ELEMENT:
  if (!context.isEmpty())
  {
   StartElement open = context.remove(0);
   EndElement close = event instanceof EndElement ? (EndElement)event : null;
   if (null == close || !open.getName().equals(close.getName()))
    throw new IllegalStateException("Unclosed " + describeEvent(open) + ' '
     + describeLocation(open.getLocation()));
  }
  else
   throw new IllegalStateException("Unclosed " + describeEvent(origin) + ' '
     + describeLocation(origin.getLocation()));
  break;
 case PROCESSING_INSTRUCTION:
  if (!TocPIParser.isIgnoredPI((ProcessingInstruction)event))
   throw new IllegalStateException("Processing instructions <?" + TocPIParser.PI_TARGET
     + "?> are not allowed within the context of " + describeEvent(origin));
  break;
 }
}
 

import javax.xml.stream.events.ProcessingInstruction; //导入依赖的package包/类
protected TocPIData parsePIEvent(ProcessingInstruction event)
  throws XMLStreamException
{
 try
 {
  return piParser().parse(event);
 }
 catch (JAXBException pierr)
 {
  throw new XMLStreamException("Error parsing " + describeEvent(event),
    event.getLocation(), pierr);
 }
}