Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* ====================================================================
     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.poi.hwpf.model;
 
 import java.util.List;
 
The piece table for matching up character positions to bits of text. This mostly works in bytes, but the TextPieces themselves work in characters. This does the icky convertion.

Author(s):
Ryan Ackley
 
 public class TextPieceTable implements CharIndexTranslator
 {
     private static final POILogger logger = POILogFactory
             .getLoggerTextPieceTable.class );
 
     // int _multiple;
     int _cpMin;
     protected ArrayList<TextPiece_textPieces = new ArrayList<TextPiece>();
     protected ArrayList<TextPiece_textPiecesFCOrder = new ArrayList<TextPiece>();
 
     public TextPieceTable()
     {
     }
 
     public TextPieceTablebyte[] documentStreambyte[] tableStream,
             int offsetint sizeint fcMin )
     {
         // get our plex of PieceDescriptors
         PlexOfCps pieceTable = new PlexOfCpstableStreamoffsetsize,
                 PieceDescriptor.getSizeInBytes() );
 
         int length = pieceTable.length();
         PieceDescriptor[] pieces = new PieceDescriptor[length];
 
         // iterate through piece descriptors raw bytes and create
         // PieceDescriptor objects
         for ( int x = 0; x < lengthx++ )
         {
             GenericPropertyNode node = pieceTable.getPropertyx );
             pieces[x] = new PieceDescriptornode.getBytes(), 0 );
         }
 
         // Figure out the cp of the earliest text piece
         // Note that text pieces don't have to be stored in order!
          = pieces[0].getFilePosition() - fcMin;
         for ( int x = 0; x < pieces.lengthx++ )
         {
             int start = pieces[x].getFilePosition() - fcMin;
             if ( start <  )
             {
                  = start;
             }
         }
 
         // using the PieceDescriptors, build our list of TextPieces.
         for ( int x = 0; x < pieces.lengthx++ )
         {
             int start = pieces[x].getFilePosition();
             GenericPropertyNode node = pieceTable.getPropertyx );
 
             // Grab the start and end, which are in characters
             int nodeStartChars = node.getStart();
             int nodeEndChars = node.getEnd();
 
             // What's the relationship between bytes and characters?
             boolean unicode = pieces[x].isUnicode();
             int multiple = 1;
             if ( unicode )
             {
                 multiple = 2;
            }
            // Figure out the length, in bytes and chars
            int textSizeChars = ( nodeEndChars - nodeStartChars );
            int textSizeBytes = textSizeChars * multiple;
            // Grab the data that makes up the piece
            byte[] buf = new byte[textSizeBytes];
            System.arraycopydocumentStreamstartbuf, 0, textSizeBytes );
            // And now build the piece
            final TextPiece newTextPiece = new TextPiecenodeStartCharsnodeEndCharsbuf,
                    pieces[x] );
            .addnewTextPiece );
        }
        // In the interest of our sanity, now sort the text pieces
        // into order, if they're not already
        Collections.sort );
         = new ArrayList<TextPiece>(  );
        Collections.sortnew FCComparator() );
    }
    public void addTextPiece piece )
    {
        .addpiece );
        .addpiece );
        Collections.sort );
        Collections.sortnew FCComparator() );
    }

    
Adjust all the text piece after inserting some text into one of them

Parameters:
listIndex The TextPiece that had characters inserted into
length The number of characters inserted
    public int adjustForInsertint listIndexint length )
    {
        int size = .size();
        TextPiece tp = .getlistIndex );
        // Update with the new end
        tp.setEndtp.getEnd() + length );
        // Now change all subsequent ones
        for ( int x = listIndex + 1; x < sizex++ )
        {
            tp = .getx );
            tp.setStarttp.getStart() + length );
            tp.setEndtp.getEnd() + length );
        }
        // All done
        return length;
    }
    public boolean equalsObject o )
    {
        if (!(o instanceof TextPieceTable)) return false;
        TextPieceTable tpt = (TextPieceTableo;
        int size = tpt._textPieces.size();
        if ( size == .size() )
        {
            for ( int x = 0; x < sizex++ )
            {
                if ( !tpt._textPieces.getx ).equals.getx ) ) )
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    public int getByteIndexint charPos )
    {
        int byteCount = 0;
        for ( TextPiece tp :  )
        {
            if ( charPos >= tp.getEnd() )
            {
                byteCount = tp.getPieceDescriptor().getFilePosition()
                        + ( tp.getEnd() - tp.getStart() )
                        * ( tp.isUnicode() ? 2 : 1 );
                if ( charPos == tp.getEnd() )
                    break;
                continue;
            }
            if ( charPos < tp.getEnd() )
            {
                int left = charPos - tp.getStart();
                byteCount = tp.getPieceDescriptor().getFilePosition() + left
                        * ( tp.isUnicode() ? 2 : 1 );
                break;
            }
        }
        return byteCount;
    }
    @Deprecated
    public int getCharIndexint bytePos )
    {
        return getCharIndexbytePos, 0 );
    }
    @Deprecated
    public int getCharIndexint startBytePosint startCP )
    {
        int charCount = 0;
        int bytePos = lookIndexForwardstartBytePos );
        for ( TextPiece tp :  )
        {
            int pieceStart = tp.getPieceDescriptor().getFilePosition();
            int bytesLength = tp.bytesLength();
            int pieceEnd = pieceStart + bytesLength;
            int toAdd;
            if ( bytePos < pieceStart || bytePos > pieceEnd )
            {
                toAdd = bytesLength;
            }
            else if ( bytePos > pieceStart && bytePos < pieceEnd )
            {
                toAdd = ( bytePos - pieceStart );
            }
            else
            {
                toAdd = bytesLength - ( pieceEnd - bytePos );
            }
            if ( tp.isUnicode() )
            {
                charCount += toAdd / 2;
            }
            else
            {
                charCount += toAdd;
            }
            if ( bytePos >= pieceStart && bytePos <= pieceEnd
                    && charCount >= startCP )
            {
                break;
            }
        }
        return charCount;
    }
    public int[][] getCharIndexRangesint startBytePosInclusive,
            int endBytePosExclusive )
    {
        List<int[]> result = new LinkedList<int[]>();
        for ( TextPiece textPiece :  )
        {
            final int tpStart = textPiece.getPieceDescriptor()
                    .getFilePosition();
            final int tpEnd = textPiece.getPieceDescriptor().getFilePosition()
                    + textPiece.bytesLength();
            if ( startBytePosInclusive > tpEnd )
                continue;
            if ( endBytePosExclusive < tpStart )
                break;
            final int rangeStartBytes = Math.maxtpStart,
                    startBytePosInclusive );
            final int rangeEndBytes = Math.mintpEndendBytePosExclusive );
            final int rangeLengthBytes = rangeEndBytes - rangeStartBytes;
            if ( rangeStartBytes > rangeEndBytes )
                continue;
            final int encodingMultiplier = textPiece.isUnicode() ? 2 : 1;
            final int rangeStartCp = textPiece.getStart()
                    + ( rangeStartBytes - tpStart ) / encodingMultiplier;
            final int rangeEndCp = rangeStartCp + rangeLengthBytes
                    / encodingMultiplier;
            result.addnew int[] { rangeStartCprangeEndCp } );
        }
        return result.toArraynew int[result.size()][] );
    }
    public int getCpMin()
    {
        return ;
    }
    public StringBuilder getText()
    {
        final long start = System.currentTimeMillis();
        // rebuild document paragraphs structure
        StringBuilder docText = new StringBuilder();
        for ( TextPiece textPiece :  )
        {
            String toAppend = textPiece.getStringBuilder().toString();
            int toAppendLength = toAppend.length();
            if ( toAppendLength != textPiece.getEnd() - textPiece.getStart() )
            {
                .log(
                        .,
                        "Text piece has boundaries [",
                        Integer.valueOftextPiece.getStart() ),
                        "; ",
                        Integer.valueOftextPiece.getEnd() ),
                        ") but length ",
                        Integer.valueOftextPiece.getEnd()
                                - textPiece.getStart() ) );
            }
            docText.replacetextPiece.getStart(), textPiece.getStart()
                    + toAppendLengthtoAppend );
        }
        .log."Document text were rebuilded in ",
                Long.valueOf( System.currentTimeMillis() - start ), " ms (",
                Integer.valueOfdocText.length() ), " chars)" );
        return docText;
    }
    public List<TextPiecegetTextPieces()
    {
        return ;
    }
    @Override
    public int hashCode()
    {
        return .size();
    }
    public boolean isIndexInTableint bytePos )
    {
        for ( TextPiece tp :  )
        {
            int pieceStart = tp.getPieceDescriptor().getFilePosition();
            if ( bytePos > pieceStart + tp.bytesLength() )
            {
                continue;
            }
            if ( pieceStart > bytePos )
            {
                return false;
            }
            return true;
        }
        return false;
    }
    boolean isIndexInTableint startBytePosint endBytePos )
    {
        for ( TextPiece tp :  )
        {
            int pieceStart = tp.getPieceDescriptor().getFilePosition();
            if ( startBytePos >= pieceStart + tp.bytesLength() )
            {
                continue;
            }
            int left = Math.maxstartBytePospieceStart );
            int right = Math.minendBytePospieceStart + tp.bytesLength() );
            if ( left >= right )
                return false;
            return true;
        }
        return false;
    }
    public int lookIndexBackwardfinal int startBytePos )
    {
        int bytePos = startBytePos;
        int lastEnd = 0;
        for ( TextPiece tp :  )
        {
            int pieceStart = tp.getPieceDescriptor().getFilePosition();
            if ( bytePos > pieceStart + tp.bytesLength() )
            {
                lastEnd = pieceStart + tp.bytesLength();
                continue;
            }
            if ( pieceStart > bytePos )
            {
                bytePos = lastEnd;
            }
            break;
        }
        return bytePos;
    }
    public int lookIndexForwardfinal int startBytePos )
    {
        if ( .isEmpty() )
            throw new IllegalStateException"Text pieces table is empty" );
        if ( .get( 0 ).getPieceDescriptor().getFilePosition() > startBytePos )
            return .get( 0 ).getPieceDescriptor().getFilePosition();
        if ( .get.size() - 1 )
                .getPieceDescriptor().getFilePosition() <= startBytePos )
            return startBytePos;
        int low = 0;
        int high = .size() - 1;
        while ( low <= high )
        {
            int mid = ( low + high ) >>> 1;
            final TextPiece textPiece = .getmid );
            int midVal = textPiece.getPieceDescriptor().getFilePosition();
            if ( midVal < startBytePos )
                low = mid + 1;
            else if ( midVal > startBytePos )
                high = mid - 1;
            else
                // found piece with exact start
                return textPiece.getPieceDescriptor().getFilePosition();
        }
        assert low == high;
        assert .getlow ).getPieceDescriptor()
                .getFilePosition() < startBytePos;
        // last line can't be current, can it?
        assert .getlow + 1 ).getPieceDescriptor()
                .getFilePosition() > startBytePos;
        // shifting to next piece start
        return .getlow + 1 ).getPieceDescriptor().getFilePosition();
    }
    public byte[] writeToHWPFOutputStream docStream ) throws IOException
    {
        PlexOfCps textPlex = new PlexOfCps( PieceDescriptor.getSizeInBytes() );
        // int fcMin = docStream.getOffset();
        int size = .size();
        for ( int x = 0; x < sizex++ )
        {
            TextPiece next = .getx );
            PieceDescriptor pd = next.getPieceDescriptor();
            int offset = docStream.getOffset();
            int mod = ( offset % . );
            if ( mod != 0 )
            {
                mod = . - mod;
                byte[] buf = new byte[mod];
                docStream.writebuf );
            }
            // set the text piece position to the current docStream offset.
            pd.setFilePositiondocStream.getOffset() );
            // write the text to the docstream and save the piece descriptor to
            // the
            // plex which will be written later to the tableStream.
            docStream.writenext.getRawBytes() );
            // The TextPiece is already in characters, which
            // makes our life much easier
            int nodeStart = next.getStart();
            int nodeEnd = next.getEnd();
            textPlex.addPropertynew GenericPropertyNodenodeStartnodeEnd,
                    pd.toByteArray() ) );
        }
        return textPlex.toByteArray();
    }
    private static class FCComparator implements Comparator<TextPiece>
    {
        public int compareTextPiece textPieceTextPiece textPiece1 )
        {
            if ( textPiece.getPieceDescriptor(). > textPiece1
                    .getPieceDescriptor(). )
            {
                return 1;
            }
            else if ( textPiece.getPieceDescriptor(). < textPiece1
                    .getPieceDescriptor(). )
            {
                return -1;
            }
            else
            {
                return 0;
            }
        }
    }
New to GrepCode? Check out our FAQ X