private Event nextEvent () { if ( queue.size() == 0 ) return null; if ( queue.peek().getEventType() == EventType.END_DOCUMENT ) { parseState = 0; // No more event after } return queue.poll(); }
/** * Does the current {@link TextUnit} have a parent? * * @return true, if successful */ public boolean hasParentTextUnit() { if (tempFilterEventStack.isEmpty()) { return false; } boolean first = true; // skip current TextUnit - the one we are currently processing for (Event fe : tempFilterEventStack) { if (fe.getEventType() == EventType.TEXT_UNIT && !first) { return true; } first = false; } return false; }
/** * Is the current buffered {@link Event} a {@link StartGroup}? * * @return true, if current {@link Event} is a {@link StartGroup} */ public boolean isCurrentGroup() { Event e = peekTempEvent(); if (e != null && e.getEventType() == EventType.START_GROUP) { return true; } return false; }
/** * Is the current buffered {@link Event} a {@link StartSubfilter}? * * @return true, if current {@link Event} is a {@link StartSubfilter} */ public boolean isCurrentSubfilter() { Event e = peekTempEvent(); if (e != null && e.getEventType() == EventType.START_SUBFILTER) { return true; } return false; }
/** * Is the current buffered {@link Event} a {@link TextUnit}? * * @return true if TextUnit, false otherwise. */ public boolean isCurrentTextUnit() { Event e = peekTempEvent(); if (e != null && e.getEventType() == EventType.TEXT_UNIT) { return true; } return false; }
/** * Peek at the most recently created {@link StartSubDocument} * * @return the filter event */ public StartSubDocument peekMostRecentSubDocument() { if (tempFilterEventStack.isEmpty()) { return null; } // the normal stack iterator gives the elements in the wrong order int lastIndex = tempFilterEventStack.size() - 1; for (int i = lastIndex; i >= 0; i--) { Event fe = tempFilterEventStack.get(i); if (fe.getEventType() == EventType.START_SUBDOCUMENT) { StartSubDocument sd = (StartSubDocument) fe.getResource(); return sd; } } return null; }
public Event next () { // Check for cancellation first if ( canceled ) { queue.clear(); queue.add(new Event(EventType.CANCELED)); hasNext = false; } // Parse next if nothing in the queue if ( queue.size() == 0 ) { parseNext(); } // Return the head of the queue if ( queue.peek().getEventType() == EventType.END_DOCUMENT ) { hasNext = false; } return queue.poll(); }
@Override public Event handleEvent(Event event) { switch (event.getEventType()) { case START_DOCUMENT: return handleStartDocument(event); default: if (merger != null) { return merger.handleEvent(event); } } return event; }
private boolean isStyledReferenceableEvent(ReferenceableEvent referenceableEvent) { switch (referenceableEvent.getEvent().getEventType()) { case TEXT_UNIT: return true; case DOCUMENT_PART: return referenceableEvent.getEvent().getDocumentPart().getSkeleton() instanceof StyledTextSkeleton; default: throw new IllegalStateException(UNEXPECTED_STRUCTURE); } }
private void writeReferenceableEvent(ReferenceableEvent referenceableEvent) { switch (referenceableEvent.getEvent().getEventType()) { case TEXT_UNIT: writeTextUnitReferenceableEvent(referenceableEvent); break; case DOCUMENT_PART: writeDocumentPartReferenceableEvent(referenceableEvent); default: } }
private void indexEvent(LocaleId targetLang, ITmWriter tmWriter, Event event) throws IOException { TranslationUnit tu; if (event.getEventType() == EventType.TEXT_UNIT) { tu = PensieveUtil.convertToTranslationUnit(sourceLang, targetLang, event.getTextUnit()); tmWriter.indexTranslationUnit(tu); } }
/** * Is the current buffered {@link Event} a complex {@link TextUnit}? A complex TextUnit is one which carries along * with it it's surrounding formatting or skeleton such <p> text </p> or <title> text </title> * * @return true, if current {@link Event} is a complex text unit, false otherwise. */ public boolean isCurrentComplexTextUnit() { Event e = peekTempEvent(); if (e != null && e.getEventType() == EventType.TEXT_UNIT && e.getResource().getSkeleton() != null) { return true; } return false; }
private Event synchronize (IFilter filter, EventType untilType) { boolean found = false; Event event = null; while ( !found && filter.hasNext() ) { event = filter.next(); found = (event.getEventType() == untilType); } if ( !found ) { throw new OkapiException("The document to compare is de-synchronized."); } return event; }
/** * Gets the next text unit in the XLIFF document. * * @return the next text unit or null. */ private ITextUnit getTextUnitFromXLIFF() { Event event; while (xlfReader.hasNext()) { event = xlfReader.next(); if (event.getEventType() == EventType.TEXT_UNIT) { return event.getTextUnit(); } } return null; }
/** * Is the current TextUnit of the specified type? * * @param type * a {@link TextUnit} type. * @return true if the current {@link TextUnit} type is the same as the parameter type. */ public boolean isTextUnitWithSameType(String type) { Event e = peekTempEvent(); if (e != null && e.getEventType() == EventType.TEXT_UNIT) { ITextUnit tu = e.getTextUnit(); if (tu != null && tu.getType() != null && tu.getType().equals(type)) { return true; } } return false; }
/** * Find in our buffered queue the most recent TextUnit * that has an assigned name * @return - the TextUnit name, null if not found */ public String findMostRecentTextUnitName() { if (tempFilterEventStack.isEmpty()) { return null; } // skip current TextUnit - the one we are currently processing for (Event fe : tempFilterEventStack) { if (fe.getEventType() == EventType.TEXT_UNIT && fe.getTextUnit().getName() != null) { return fe.getTextUnit().getName(); } } return null; }
@Override public Event handleEvent (Event event) { switch ( event.getEventType() ) { case START_DOCUMENT: handleStartDocument(event); break; case TEXT_UNIT: handleTextUnit(event); break; case END_DOCUMENT: close(); break; default: break; } return event; }
private IResource createResource(Event event) { if (event == null) return null; IResource res = event.getResource(); if (res != null) return res; switch (event.getEventType()) { case END_BATCH: case END_BATCH_ITEM: case END_DOCUMENT: case END_SUBDOCUMENT: case END_GROUP: res = new Ending(gen.createId()); event.setResource(res); break; default: break; } return res; }
@Override public Event handleEvent (Event event) { switch ( event.getEventType() ) { case START_BATCH: return handleStartBatch(event); case END_BATCH: return handleEndBatch(event); case START_DOCUMENT: return handleStartDocument(event); case RAW_DOCUMENT: return handleRawDocument(event); default: return writer.handleEvent(event); } }
@Override public Event handleEvent (Event event) { switch ( event.getEventType() ) { case START_DOCUMENT: processStartDocument(event.getStartDocument()); break; case END_DOCUMENT: close(); break; case TEXT_UNIT: processTextUnit(event.getTextUnit()); break; default: break; } return event; }