/** * Mark an object with {@link PdfObject#MUST_BE_FLUSHED}. * * @param pdfObject an object to mark. */ protected void markObjectAsMustBeFlushed(PdfObject pdfObject) { if (pdfObject.getIndirectReference() != null) { pdfObject.getIndirectReference().setState(PdfObject.MUST_BE_FLUSHED); } }
/** * Gets the mapped resource name of the given {@link PdfObject}. * <br> * <br> * Note: if the name for the object won't be found, then the name of object's Indirect Reference will be searched. * * @param resource the object, for which the name will be searched. * @return the mapped resource name or {@code null} if object isn't added to resources. */ public PdfName getResourceName(PdfObject resource) { PdfName resName = resourceToName.get(resource); if (resName == null) resName = resourceToName.get(resource.getIndirectReference()); return resName; }
/** * Indicates is the object has been flushed or not. * * @return true if object has been flushed, otherwise false. */ public boolean isFlushed() { PdfIndirectReference indirectReference = getIndirectReference(); return (indirectReference != null && indirectReference.checkState(FLUSHED)); }
@Override public String toString() { String string = "["; for (PdfObject entry : list) { PdfIndirectReference indirectReference = entry.getIndirectReference(); string = string + (indirectReference == null ? entry.toString() : indirectReference.toString()) + " "; } string += "]"; return string; }
protected static void markObjectAsIndirect(PdfObject pdfObject) { if (pdfObject.getIndirectReference() == null) { pdfObject.setState(PdfObject.MUST_BE_INDIRECT); } }
/** * Indicates is the object has been set as modified or not. Useful for incremental updates (e.g. appendMode). * * @return true is object has been set as modified, otherwise false. */ public boolean isModified() { PdfIndirectReference indirectReference = getIndirectReference(); return (indirectReference != null && indirectReference.checkState(MODIFIED)); }
/** * Add an entry to the name tree * * @param key key of the entry * @param value object to add */ public void addEntry(String key, PdfObject value) { PdfObject existingVal = items.get(key); if (existingVal != null) { if (value.getIndirectReference() != null && value.getIndirectReference().equals(existingVal.getIndirectReference())) { return; } else { Logger logger = LoggerFactory.getLogger(PdfNameTree.class); logger.warn(MessageFormatUtil.format(LogMessageConstant.NAME_ALREADY_EXISTS_IN_THE_NAME_TREE, key)); } } modified = true; items.put(key, value); }
/** * Some wrappers use object's indirect reference to obtain the {@code PdfDocument} * to which the object belongs to. For this matter, for these wrappers it is implicitly defined * that they work with indirect objects only. Commonly these wrappers have two constructors: one with * {@code PdfDocument} as parameter to create a new object, and the other one which * wraps around the given {@code PdfObject}. This method should be used in the second * type of constructors to ensure that wrapper will able to obtain the {@code PdfDocument} instance. * * @param object the {@code PdfObject} to be checked if it is indirect. */ protected static void ensureObjectIsAddedToDocument(PdfObject object) { if (object.getIndirectReference() == null) { throw new PdfException(PdfException.ObjectMustBeIndirectToWorkWithThisWrapper); } }
protected void ensureUnderlyingObjectHasIndirectReference() { if (getPdfObject().getIndirectReference() == null) { throw new PdfException(PdfException.ToFlushThisWrapperUnderlyingObjectMustBeAddedToDocument); } }
@Override public String toString() { if (!isFlushed()) { String string = "<<"; for (Map.Entry<PdfName, PdfObject> entry : map.entrySet()) { PdfIndirectReference indirectReference = entry.getValue().getIndirectReference(); string = string + entry.getKey().toString() + " " + (indirectReference == null ? entry.getValue().toString() : indirectReference.toString()) + " "; } string += ">>"; return string; } else { return indirectReference.toString(); } }
/** * Getter for the object number in case the object is indirect or if it is reference. * * @return -1 for direct objects; the object number for indirect objects */ public int getNumber() { if (isIndirect() && object.getIndirectReference() != null) { return object.getIndirectReference().getObjNumber(); } if (isIndirectReference()) { return ((PdfIndirectReference) object).getObjNumber(); } return number; }
void addNewIndirectObject(PdfObject object) { object.makeIndirect(document); ++n; int idx = size(); idxToRef.put(idx, object.getIndirectReference().getObjNumber()); refToIdx.put(object.getIndirectReference().getObjNumber(), idx); objects.add(object); LoggerHelper.info("New indirect object was successfully created. Its object number is: " + object.getIndirectReference().getObjNumber(), getClass()); } }
public void addNewIndirectObject(PdfObject object) { objects.addNewIndirectObject(object); nodes.add(PdfObjectTreeNode.getInstance(object, object.getIndirectReference().getObjNumber())); LoggerHelper.info("Tree node was successfully created for new indirect object", getClass()); } }
/** * Processes an object. If the object is indirect, it is added to the * list of resources. If not, it is just processed. * * @param obj the object to process */ protected final void process(PdfObject obj) { PdfIndirectReference ref = obj.getIndirectReference(); if (ref == null) { loopOver(obj); } else if (!resources.containsKey(ref.getObjNumber())) { resources.put(ref.getObjNumber(), obj); loopOver(obj); } }
private static int removeObjectFromArray(PdfArray array, PdfObject toRemove) { int i; for (i = 0; i < array.size(); ++i) { PdfObject obj = array.get(i); if (obj == toRemove || obj == toRemove.getIndirectReference()) { array.remove(i); break; } } return i; } }
protected void associateIfIndirect(PdfObjectTreeNode node) { PdfIndirectReference ref = null; if (node != null && node.getPdfObject() != null) { ref = node.getPdfObject().getIndirectReference(); } if (ref != null) { int idx = objects.getIndexByRef(ref.getObjNumber()); nodes.set(idx, node); } }
private static void deleteOldReferences(PdfArray all, PdfArray toDelete) { if (all == null || toDelete == null) return; for (PdfObject pi : toDelete) { PdfIndirectReference pir = pi.getIndirectReference(); if (pir == null) { continue; } for (int k = 0; k < all.size(); ++k) { PdfIndirectReference pod = all.get(k).getIndirectReference(); if (pod == null) { continue; } if (pir.getObjNumber() == pod.getObjNumber()) { all.remove(k); --k; } } } }
/** * Writes object to body of PDF document. * * @param pdfObj object to write. * @throws IOException */ protected void writeToBody(PdfObject pdfObj) throws IOException { if (crypto != null) { crypto.setHashKeyForNextObject(pdfObj.getIndirectReference().getObjNumber(), pdfObj.getIndirectReference().getGenNumber()); } writeInteger(pdfObj.getIndirectReference().getObjNumber()). writeSpace(). writeInteger(pdfObj.getIndirectReference().getGenNumber()).writeBytes(obj); write(pdfObj); writeBytes(endobj); }
private void write(PdfArray pdfArray) { writeByte('['); for (int i = 0; i < pdfArray.size(); i++) { PdfObject value = pdfArray.get(i, false); PdfIndirectReference indirectReference; if ((indirectReference = value.getIndirectReference()) != null) { write(indirectReference); } else { write(value); } if (i < pdfArray.size() - 1) writeSpace(); } writeByte(']'); }
private int removeKidObject(PdfObject kid) { PdfObject k = getK(); if (k == null || !k.isArray() && k != kid && k != kid.getIndirectReference()) { return -1; } int removedIndex = -1; if (k.isArray()) { PdfArray kidsArray = (PdfArray) k; removedIndex = removeObjectFromArray(kidsArray, kid); } if (!k.isArray() || k.isArray() && ((PdfArray) k).isEmpty()) { getPdfObject().remove(PdfName.K); removedIndex = 0; } setModified(); return removedIndex; }