Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.vxquery.index; import java.io.DataOutput; import java.io.IOException; import java.util.ArrayList; import java.util.List; import org.apache.commons.lang3.StringUtils; import org.apache.hyracks.data.std.primitive.BooleanPointable; import org.apache.hyracks.data.std.primitive.BytePointable; import org.apache.hyracks.data.std.primitive.DoublePointable; import org.apache.hyracks.data.std.primitive.FloatPointable; import org.apache.hyracks.data.std.primitive.IntegerPointable; import org.apache.hyracks.data.std.primitive.LongPointable; import org.apache.hyracks.data.std.primitive.ShortPointable; import org.apache.hyracks.data.std.primitive.UTF8StringPointable; import org.apache.hyracks.data.std.primitive.VoidPointable; import org.apache.hyracks.data.std.util.ArrayBackedValueStorage; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.document.StringField; import org.apache.lucene.index.IndexWriter; import org.apache.vxquery.datamodel.accessors.PointablePool; import org.apache.vxquery.datamodel.accessors.PointablePoolFactory; import org.apache.vxquery.datamodel.accessors.SequencePointable; import org.apache.vxquery.datamodel.accessors.TaggedValuePointable; import org.apache.vxquery.datamodel.accessors.atomic.CodedQNamePointable; import org.apache.vxquery.datamodel.accessors.atomic.XSBinaryPointable; import org.apache.vxquery.datamodel.accessors.atomic.XSDatePointable; import org.apache.vxquery.datamodel.accessors.atomic.XSDateTimePointable; import org.apache.vxquery.datamodel.accessors.atomic.XSDecimalPointable; import org.apache.vxquery.datamodel.accessors.atomic.XSDurationPointable; import org.apache.vxquery.datamodel.accessors.atomic.XSQNamePointable; import org.apache.vxquery.datamodel.accessors.atomic.XSTimePointable; import org.apache.vxquery.datamodel.accessors.nodes.AttributeNodePointable; import org.apache.vxquery.datamodel.accessors.nodes.DocumentNodePointable; import org.apache.vxquery.datamodel.accessors.nodes.ElementNodePointable; import org.apache.vxquery.datamodel.accessors.nodes.NodeTreePointable; import org.apache.vxquery.datamodel.accessors.nodes.TextOrCommentNodePointable; import org.apache.vxquery.datamodel.values.ValueTag; import org.apache.vxquery.runtime.functions.cast.CastToStringOperation; import org.apache.vxquery.runtime.functions.index.update.Constants; import org.apache.vxquery.serializer.XMLSerializer; public class IndexDocumentBuilder extends XMLSerializer { private final PointablePool pp; private NodeTreePointable ntp; private final ArrayBackedValueStorage abvs = new ArrayBackedValueStorage(); private final DataOutput dOut = abvs.getDataOutput(); private final CastToStringOperation castToString = new CastToStringOperation(); private final Document doc; private final List<ComplexItem> results; private final byte[] bstart; private final int sstart; private final int lstart; private final IndexWriter writer; private final String filePath; class ComplexItem { public final StringField sf; public final String id; public ComplexItem(StringField sfin, String idin) { sf = sfin; id = idin; } } //TODO: Handle Processing Instructions, PrefixedNames, and Namepsace entries public IndexDocumentBuilder(TaggedValuePointable tvp, IndexWriter inWriter, String file) { writer = inWriter; this.filePath = file; //get bytes and info from doc pointer bstart = tvp.getByteArray(); sstart = tvp.getStartOffset(); lstart = tvp.getLength(); doc = new Document(); results = new ArrayList<>(); pp = PointablePoolFactory.INSTANCE.createPointablePool(); } //This is a wrapper to start indexing using the functions adapted from XMLSerializer public void printStart() throws IOException { doc.add(new StringField(Constants.FIELD_PATH, filePath, Field.Store.YES)); print(bstart, sstart, lstart, "0", ""); for (int i = 1; i < results.size(); i++) { //TODO: Since each doc is a file, //we can only handle files //small enough to fit in memory doc.add(results.get(i).sf); } writer.addDocument(doc); } //adapted from XMLSerializer. The following functions are used to traverse the TaggedValuePointable //and create the index elements, then create the item for the lucene index public void print(byte[] b, int s, int l, String deweyId, String epath) throws IOException { TaggedValuePointable tvp = pp.takeOne(TaggedValuePointable.class); try { tvp.set(b, s, l); printTaggedValuePointable(tvp, deweyId, epath); } finally { pp.giveBack(tvp); } } private void printTaggedValuePointable(TaggedValuePointable tvp, String deweyId, String epath) throws IOException { byte tag = tvp.getTag(); String type = "text"; String[] result = { "", "" }; switch ((int) tag) { case ValueTag.XS_ANY_URI_TAG: result = printString(tvp, epath); break; case ValueTag.XS_BASE64_BINARY_TAG: result = printBase64Binary(tvp, epath); break; case ValueTag.XS_BOOLEAN_TAG: result = printBoolean(tvp, epath); break; case ValueTag.XS_DATE_TAG: result = printDate(tvp, epath); break; case ValueTag.XS_DATETIME_TAG: result = printDateTime(tvp, epath); break; case ValueTag.XS_DAY_TIME_DURATION_TAG: result = printDTDuration(tvp, epath); break; case ValueTag.XS_BYTE_TAG: result = printByte(tvp, epath); break; case ValueTag.XS_DECIMAL_TAG: result = printDecimal(tvp, epath); break; case ValueTag.XS_DOUBLE_TAG: result = printDouble(tvp, epath); break; case ValueTag.XS_DURATION_TAG: result = printDuration(tvp, epath); break; case ValueTag.XS_FLOAT_TAG: result = printFloat(tvp, epath); break; case ValueTag.XS_G_DAY_TAG: result = printGDay(tvp, epath); break; case ValueTag.XS_G_MONTH_TAG: result = printGMonth(tvp, epath); break; case ValueTag.XS_G_MONTH_DAY_TAG: result = printGMonthDay(tvp, epath); break; case ValueTag.XS_G_YEAR_TAG: result = printGYear(tvp, epath); break; case ValueTag.XS_G_YEAR_MONTH_TAG: result = printGYearMonth(tvp, epath); break; case ValueTag.XS_HEX_BINARY_TAG: result = printHexBinary(tvp, epath); break; case ValueTag.XS_INT_TAG: case ValueTag.XS_UNSIGNED_SHORT_TAG: result = printInt(tvp, epath); break; case ValueTag.XS_INTEGER_TAG: case ValueTag.XS_LONG_TAG: case ValueTag.XS_NEGATIVE_INTEGER_TAG: case ValueTag.XS_NON_POSITIVE_INTEGER_TAG: case ValueTag.XS_NON_NEGATIVE_INTEGER_TAG: case ValueTag.XS_POSITIVE_INTEGER_TAG: case ValueTag.XS_UNSIGNED_INT_TAG: case ValueTag.XS_UNSIGNED_LONG_TAG: result = printInteger(tvp, epath); break; case ValueTag.XS_NOTATION_TAG: result = printString(tvp, epath); break; case ValueTag.XS_QNAME_TAG: result = printQName(tvp, epath); break; case ValueTag.XS_SHORT_TAG: case ValueTag.XS_UNSIGNED_BYTE_TAG: result = printShort(tvp, epath); break; case ValueTag.XS_STRING_TAG: case ValueTag.XS_NORMALIZED_STRING_TAG: case ValueTag.XS_TOKEN_TAG: case ValueTag.XS_LANGUAGE_TAG: case ValueTag.XS_NMTOKEN_TAG: case ValueTag.XS_NAME_TAG: case ValueTag.XS_NCNAME_TAG: case ValueTag.XS_ID_TAG: case ValueTag.XS_IDREF_TAG: case ValueTag.XS_ENTITY_TAG: result = printString(tvp, epath); break; case ValueTag.XS_TIME_TAG: result = printTime(tvp, epath); break; case ValueTag.XS_UNTYPED_ATOMIC_TAG: result = printString(tvp, epath); break; case ValueTag.XS_YEAR_MONTH_DURATION_TAG: result = printYMDuration(tvp, epath); break; case ValueTag.ATTRIBUTE_NODE_TAG: type = "attribute"; printAttributeNode(tvp, deweyId, epath); break; case ValueTag.TEXT_NODE_TAG: type = "textnode"; result = printTextNode(tvp, epath); break; case ValueTag.COMMENT_NODE_TAG: type = "comment"; result = printCommentNode(tvp, epath); break; case ValueTag.SEQUENCE_TAG: type = "sequence"; printSequence(tvp, deweyId, epath); break; case ValueTag.NODE_TREE_TAG: type = "tree"; printNodeTree(tvp, deweyId, epath); break; case ValueTag.ELEMENT_NODE_TAG: type = "element"; printElementNode(tvp, deweyId, epath); break; case ValueTag.DOCUMENT_NODE_TAG: type = "doc"; buildIndexItem(deweyId, type, result, epath); printDocumentNode(tvp, deweyId, epath); break; default: throw new UnsupportedOperationException("Encountered tag: " + tvp.getTag()); } if ((int) tag != ValueTag.DOCUMENT_NODE_TAG && (int) tag != ValueTag.SEQUENCE_TAG && (int) tag != ValueTag.NODE_TREE_TAG && (int) tag != ValueTag.ELEMENT_NODE_TAG && (int) tag != ValueTag.ATTRIBUTE_NODE_TAG) { buildIndexItem(deweyId, type, result, epath); } } private void buildIndexItem(String deweyId, String type, String[] result, String parentPath) { //Create an Index element IndexElement test = new IndexElement(deweyId, type, result[1]); String path = test.epath(); path = StringUtils.replace(path, parentPath, ""); //Parser doesn't like / so paths are saved as name.name.... String luceneParentPath = parentPath.replaceAll("/", "."); if (!type.equals("doc")) { path = path.replaceFirst("/", ":"); } else { luceneParentPath = ""; } //Parser doesn't like / so paths are saved as name.name.... path = path.replaceAll("/", "."); //Add this element to the array (they will be added in reverse order. String fullItem = luceneParentPath + path + "." + test.type(); results.add(new ComplexItem(new StringField("item", fullItem, Field.Store.YES), test.id())); } private String[] printDecimal(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDecimalPointable dp = pp.takeOne(XSDecimalPointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertDecimal(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private void printNodeTree(TaggedValuePointable tvp, String deweyId, String path) throws IOException { if (ntp != null) { throw new IllegalStateException("Nested NodeTreePointable found"); } ntp = pp.takeOne(NodeTreePointable.class); TaggedValuePointable rootTVP = pp.takeOne(TaggedValuePointable.class); try { tvp.getValue(ntp); ntp.getRootNode(rootTVP); printTaggedValuePointable(rootTVP, deweyId, path); } finally { pp.giveBack(rootTVP); pp.giveBack(ntp); ntp = null; } } private String[] printCommentNode(TaggedValuePointable tvp, String path) { String[] result = { "", path }; TextOrCommentNodePointable tcnp = pp.takeOne(TextOrCommentNodePointable.class); UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); try { tvp.getValue(tcnp); tcnp.getValue(ntp, utf8sp); result = printString(utf8sp, path); } finally { pp.giveBack(tcnp); pp.giveBack(utf8sp); } return result; } private String[] printTextNode(TaggedValuePointable tvp, String path) { String[] result = { "", path }; TextOrCommentNodePointable tcnp = pp.takeOne(TextOrCommentNodePointable.class); UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); try { tvp.getValue(tcnp); tcnp.getValue(ntp, utf8sp); result = printString(utf8sp, path); } finally { pp.giveBack(tcnp); pp.giveBack(utf8sp); } return result; } private void printAttributeNode(TaggedValuePointable tvp, String deweyId, String path) throws IOException { String[] result = { "", path }; AttributeNodePointable anp = pp.takeOne(AttributeNodePointable.class); CodedQNamePointable cqp = pp.takeOne(CodedQNamePointable.class); UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); TaggedValuePointable valueTVP = pp.takeOne(TaggedValuePointable.class); try { tvp.getValue(anp); anp.getName(cqp); result = printPrefixedQName(cqp, utf8sp, path); buildIndexItem(deweyId, "attribute", result, path); anp.getValue(ntp, valueTVP); String attributeValueId = deweyId + ".0"; printTaggedValuePointable(valueTVP, attributeValueId, result[1]); } finally { pp.giveBack(valueTVP); pp.giveBack(utf8sp); pp.giveBack(anp); pp.giveBack(cqp); } } private void printElementNode(TaggedValuePointable tvp, String deweyId, String path) throws IOException { String[] result = { "", path }; ElementNodePointable enp = pp.takeOne(ElementNodePointable.class); CodedQNamePointable cqp = pp.takeOne(CodedQNamePointable.class); UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); SequencePointable seqp = pp.takeOne(SequencePointable.class); try { tvp.getValue(enp); enp.getName(cqp); result = printPrefixedQName(cqp, utf8sp, path); buildIndexItem(deweyId, "element", result, path); enp.getAttributeSequence(ntp, seqp); int numattributes = 0; if (seqp.getByteArray() != null && seqp.getEntryCount() > 0) { printSequence(seqp, deweyId, 0, result[1]); numattributes = seqp.getEntryCount(); } enp.getChildrenSequence(ntp, seqp); if (seqp.getByteArray() != null) { printSequence(seqp, deweyId, numattributes, result[1]); } } finally { pp.giveBack(seqp); pp.giveBack(utf8sp); pp.giveBack(cqp); pp.giveBack(enp); } } private String[] printPrefixedQName(CodedQNamePointable cqp, UTF8StringPointable utf8sp, String path) { ntp.getString(cqp.getLocalCode(), utf8sp); return printString(utf8sp, path); } private void printDocumentNode(TaggedValuePointable tvp, String deweyId, String path) throws IOException { DocumentNodePointable dnp = pp.takeOne(DocumentNodePointable.class); SequencePointable seqp = pp.takeOne(SequencePointable.class); try { tvp.getValue(dnp); dnp.getContent(ntp, seqp); printSequence(seqp, deweyId, 0, path); } finally { pp.giveBack(seqp); pp.giveBack(dnp); } } private void printSequence(TaggedValuePointable tvp, String deweyId, String path) throws IOException { SequencePointable seqp = pp.takeOne(SequencePointable.class); try { tvp.getValue(seqp); printSequence(seqp, deweyId, 0, path); } finally { pp.giveBack(seqp); } } private void printSequence(SequencePointable seqp, String deweyId, int addon, String path) throws IOException { VoidPointable vp = pp.takeOne(VoidPointable.class); try { int len = seqp.getEntryCount(); for (int i = 0; i < len; ++i) { int location = i + addon; String childID = deweyId + "." + Integer.toString(location); seqp.getEntry(i, vp); print(vp.getByteArray(), vp.getStartOffset(), vp.getLength(), childID, path); } } finally { pp.giveBack(vp); } } private String[] printBase64Binary(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSBinaryPointable bp = pp.takeOne(XSBinaryPointable.class); try { tvp.getValue(bp); abvs.reset(); castToString.convertBase64Binary(bp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(bp); } return result; } private String[] printBoolean(TaggedValuePointable tvp, String path) { String[] result = { "", path }; BooleanPointable bp = pp.takeOne(BooleanPointable.class); try { tvp.getValue(bp); result[0] = Boolean.toString(bp.getBoolean()); result[1] = path + "/" + result[0]; } finally { pp.giveBack(bp); } return result; } private String[] printByte(TaggedValuePointable tvp, String path) { String[] result = { "", path }; BytePointable bp = pp.takeOne(BytePointable.class); try { tvp.getValue(bp); result[0] = Byte.toString(bp.byteValue()); result[1] = path + "/" + result[0]; } finally { pp.giveBack(bp); } return result; } private String[] printDouble(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; DoublePointable dp = pp.takeOne(DoublePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertDouble(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printDate(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDatePointable dp = pp.takeOne(XSDatePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertDate(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printDateTime(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDateTimePointable dtp = pp.takeOne(XSDateTimePointable.class); try { tvp.getValue(dtp); abvs.reset(); castToString.convertDatetime(dtp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dtp); } return result; } private String[] printDTDuration(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; LongPointable lp = pp.takeOne(LongPointable.class); try { tvp.getValue(lp); abvs.reset(); castToString.convertDTDuration(lp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(lp); } return result; } private String[] printDuration(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDurationPointable dp = pp.takeOne(XSDurationPointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertDuration(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printFloat(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; FloatPointable fp = pp.takeOne(FloatPointable.class); try { tvp.getValue(fp); abvs.reset(); castToString.convertFloat(fp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(fp); } return result; } private String[] printGDay(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDatePointable dp = pp.takeOne(XSDatePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertGDay(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printGMonth(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDatePointable dp = pp.takeOne(XSDatePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertGMonth(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printGMonthDay(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDatePointable dp = pp.takeOne(XSDatePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertGMonthDay(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printGYear(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDatePointable dp = pp.takeOne(XSDatePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertGYear(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printGYearMonth(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSDatePointable dp = pp.takeOne(XSDatePointable.class); try { tvp.getValue(dp); abvs.reset(); castToString.convertGYearMonth(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printHexBinary(TaggedValuePointable tvp, String path) throws IOException { String[] result = { "", path }; XSBinaryPointable bp = pp.takeOne(XSBinaryPointable.class); try { tvp.getValue(bp); abvs.reset(); castToString.convertHexBinary(bp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(bp); } return result; } private String[] printInt(TaggedValuePointable tvp, String path) { String[] result = { "", path }; IntegerPointable ip = pp.takeOne(IntegerPointable.class); try { tvp.getValue(ip); result[0] = Integer.toString(ip.intValue()); result[1] = path + "/" + result[0]; } finally { pp.giveBack(ip); } return result; } private String[] printInteger(TaggedValuePointable tvp, String path) { String[] result = { "", path }; LongPointable lp = pp.takeOne(LongPointable.class); try { tvp.getValue(lp); result[0] = Long.toString(lp.longValue()); result[1] = path + "/" + result[0]; } finally { pp.giveBack(lp); } return result; } private String[] printShort(TaggedValuePointable tvp, String path) { ShortPointable sp = pp.takeOne(ShortPointable.class); String[] result = { "", path }; try { tvp.getValue(sp); result[0] = Short.toString(sp.shortValue()); result[1] = path + "/" + result[0]; } finally { pp.giveBack(sp); } return result; } private String[] printQName(TaggedValuePointable tvp, String path) throws IOException { XSQNamePointable dp = pp.takeOne(XSQNamePointable.class); String[] result = { "", path }; try { tvp.getValue(dp); abvs.reset(); castToString.convertQName(dp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(dp); } return result; } private String[] printStringAbvs(String path) { UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); String[] result = { "", path }; try { utf8sp.set(abvs.getByteArray(), abvs.getStartOffset() + 1, abvs.getLength() - 1); result = printString(utf8sp, path); } finally { pp.giveBack(utf8sp); } return result; } private String[] printString(TaggedValuePointable tvp, String path) { UTF8StringPointable utf8sp = pp.takeOne(UTF8StringPointable.class); String[] result = { "", path }; try { tvp.getValue(utf8sp); result = printString(utf8sp, path); } finally { pp.giveBack(utf8sp); } return result; } private String[] printString(UTF8StringPointable utf8sp, String path) { int utfLen = utf8sp.getUTF8Length(); int offset = utf8sp.getMetaDataLength(); String[] result = { "", path }; while (utfLen > 0) { char c = utf8sp.charAt(offset); switch (c) { case '<': result[0] += "<"; break; case '>': result[0] += ">"; break; case '&': result[0] += "&"; break; case '"': result[0] += """; break; case '\'': result[0] += "'"; break; default: result[0] += Character.toString(c); break; } int cLen = utf8sp.charSize(offset); offset += cLen; utfLen -= cLen; } result[1] = path + "/" + result[0]; return result; } private String[] printTime(TaggedValuePointable tvp, String path) throws IOException { XSTimePointable tp = pp.takeOne(XSTimePointable.class); String[] result = { "", path }; try { tvp.getValue(tp); abvs.reset(); castToString.convertTime(tp, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(tp); } return result; } private String[] printYMDuration(TaggedValuePointable tvp, String path) throws IOException { IntegerPointable ip = pp.takeOne(IntegerPointable.class); String[] result = { "", path }; try { tvp.getValue(ip); abvs.reset(); castToString.convertYMDuration(ip, dOut); result = printStringAbvs(path); } catch (Exception e) { throw new IOException(e); } finally { pp.giveBack(ip); } return result; } }