lotuswordpro/source/filter/lwpidxmgr.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  The Contents of this file are made available subject to the terms of
   5  *  either of the following licenses
   6  *
   7  *         - GNU Lesser General Public License Version 2.1
   8  *         - Sun Industry Standards Source License Version 1.1
   9  *
  10  *  Sun Microsystems Inc., October, 2000
  11  *
  12  *  GNU Lesser General Public License Version 2.1
  13  *  =============================================
  14  *  Copyright 2000 by Sun Microsystems, Inc.
  15  *  901 San Antonio Road, Palo Alto, CA 94303, USA
  16  *
  17  *  This library is free software; you can redistribute it and/or
  18  *  modify it under the terms of the GNU Lesser General Public
  19  *  License version 2.1, as published by the Free Software Foundation.
  20  *
  21  *  This library is distributed in the hope that it will be useful,
  22  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  *  Lesser General Public License for more details.
  25  *
  26  *  You should have received a copy of the GNU Lesser General Public
  27  *  License along with this library; if not, write to the Free Software
  28  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  29  *  MA  02111-1307  USA
  30  *
  31  *
  32  *  Sun Industry Standards Source License Version 1.1
  33  *  =================================================
  34  *  The contents of this file are subject to the Sun Industry Standards
  35  *  Source License Version 1.1 (the "License"); You may not use this file
  36  *  except in compliance with the License. You may obtain a copy of the
  37  *  License at http://www.openoffice.org/license.html.
  38  *
  39  *  Software provided under this License is provided on an "AS IS" basis,
  40  *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
  41  *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
  42  *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
  43  *  See the License for the specific provisions governing your rights and
  44  *  obligations concerning the Software.
  45  *
  46  *  The Initial Developer of the Original Code is: IBM Corporation
  47  *
  48  *  Copyright: 2008 by IBM Corporation
  49  *
  50  *  All Rights Reserved.
  51  *
  52  *  Contributor(s): _______________________________________
  53  *
  54  *
  55  ************************************************************************/
  56
  57 /**********************************************************************************************************************
  58  * @file
  59  *   index manager implementation
  60  *  Three record types are related with index information, and two ways are used.
  61 *  1. VO_ROOTOBJINDEX works with one or more VO_LEAFOBJINDEX records to
  62 *  provide the map of all object ids and their offsets.
  63 *  VO_ROOTOBJINDEX includes k (object id, offset) and timetable which is used to map index to actual low id
  64  *  2. VO_ROOTLEAFOBJINDEX is used when the file is so small that the number of objects is less than 256(?)
  65  *  VO_ROOTLEAFOBJINDEX contains directly the (object id, offset) map and time table.
  66
  67  * Change History
  68  Jan 2005           Created
  69 **********************************************************************************************************************/
  70
  71 #include "lwpidxmgr.hxx"
  72 #include "lwptools.hxx"
  73
  74 const sal_uInt8 LwpIndexManager::MAXOBJECTIDS = 255;
  75
  76 LwpIndexManager::LwpIndexManager()
  77     :m_nKeyCount(0), m_nLeafCount(0)
  78 {
  79
  80     m_TempVec.resize( LwpIndexManager::MAXOBJECTIDS );
  81
  82 }
  83
  84 LwpIndexManager::~LwpIndexManager()
  85 {
  86     //Clear m_ObjectKeys
  87     std::vector<LwpKey*>::iterator it;
  88
  89     for( it = m_ObjectKeys.begin(); it != m_ObjectKeys.end(); ++it )
  90     {
  91         LwpKey* pKey = *it;
  92         if( pKey )
  93         {
  94             delete pKey;
  95             pKey = NULL;
  96         }
  97     }
  98     m_ObjectKeys.clear();
  99 }
 100
 101 /**
 102  * @descr   Read all index records, VO_ROOTLEAFOBJINDEX, VO_ROOTOBJINDEX, VO_LEAFOBJINDEX
 103  */
 104 void LwpIndexManager::Read(LwpSvStream* pStrm)
 105 {
 106     //Read index obj
 107     LwpObjectHeader ObjHdr;
 108     ObjHdr.Read(*pStrm);
 109     LwpObjectStream* pObjStrm = new LwpObjectStream(pStrm, ObjHdr.IsCompressed(),
 110             static_cast<sal_uInt16>(ObjHdr.GetSize()) );
 111
 112     if( ObjHdr.GetTag() == VO_ROOTLEAFOBJINDEX )
 113     {
 114         ReadLeafData(pObjStrm);
 115         ReadTimeTable(pObjStrm);
 116         delete pObjStrm;
 117     }
 118     else
 119     {
 120         ReadRootData(pObjStrm);
 121         delete pObjStrm;
 122
 123         for (sal_uInt16 k = 0; k < m_nLeafCount; k++)
 124         {
 125             //Read leaf
 126             sal_Int64 nPos = m_ChildIndex[k]+LwpSvStream::LWP_STREAM_BASE;
 127             sal_Int64 nActualPos = pStrm->Seek(nPos);
 128
 129             if (nPos != nActualPos)
 130                 throw BadSeek();
 131
 132             //Old Code
 133             //ReadLeafIndex(pStrm);
 134             //New Code
 135             ReadObjIndex( pStrm );
 136
 137             //Read object in root, these objects are between the leaf objects
 138             if(k!=m_nLeafCount-1)
 139             {
 140                 m_ObjectKeys.push_back(m_RootObjs[k]);
 141                 m_nKeyCount ++;
 142             }
 143         }
 144         m_RootObjs.clear();
 145     }
 146 }
 147
 148 /**
 149  * @descr   Read data in VO_ROOTOBJINDEX
 150  */
 151 void LwpIndexManager::ReadRootData(LwpObjectStream* pObjStrm)
 152 {
 153
 154     sal_uInt16 KeyCount = pObjStrm->QuickReaduInt16();
 155     m_nLeafCount = KeyCount ? KeyCount + 1 : 0;
 156
 157     if(KeyCount)
 158     {
 159         //read object keys
 160         LwpKey* akey = new LwpKey();
 161         akey->id.Read(pObjStrm);
 162         m_RootObjs.push_back(akey);
 163
 164         sal_uInt16 k = 0;
 165
 166         for (k = 1; k < KeyCount; k++)
 167         {
 168             akey = new LwpKey();
 169             akey->id.ReadCompressed(pObjStrm, m_RootObjs[k-1]->id);
 170             m_RootObjs.push_back(akey);
 171         }
 172
 173         for (k = 0; k < KeyCount; k++)
 174             m_RootObjs[k]->offset = pObjStrm->QuickReaduInt32();
 175
 176         //read leaf index offset
 177         for (k = 0; k < m_nLeafCount; k++)
 178             m_ChildIndex[k] = pObjStrm->QuickReaduInt32();
 179     }
 180
 181     ReadTimeTable(pObjStrm);
 182
 183 }
 184
 185 //Add new method to handle ObjIndex data
 186 /**
 187  * @descr   Read data in VO_OBJINDEX
 188  */
 189 void LwpIndexManager::ReadObjIndexData(LwpObjectStream* pObjStrm)
 190 {
 191     sal_uInt16 KeyCount = pObjStrm->QuickReaduInt16();
 192     sal_uInt16 LeafCount = KeyCount + 1;
 193
 194     std::vector<LwpKey*> vObjIndexs;
 195
 196     if(KeyCount)
 197     {
 198         LwpKey* akey = new LwpKey();
 199         akey->id.Read(pObjStrm);
 200         vObjIndexs.push_back(akey);
 201
 202         sal_uInt16 k = 0;
 203
 204         for (k = 1; k < KeyCount; k++)
 205         {
 206             akey = new LwpKey();
 207             akey->id.ReadCompressed(pObjStrm, vObjIndexs[k-1]->id);
 208             vObjIndexs.push_back(akey);
 209         }
 210
 211         for (k = 0; k < KeyCount; k++)
 212             vObjIndexs[k]->offset = pObjStrm->QuickReaduInt32();
 213
 214         for (k = 0; k < LeafCount; k++)
 215             m_TempVec[k] = pObjStrm->QuickReaduInt32();
 216     }
 217
 218     for( sal_uInt16 j=0; j<LeafCount; j++ )
 219     {
 220         sal_Int64 nPos = m_TempVec[j]+LwpSvStream::LWP_STREAM_BASE;
 221         sal_Int64 nActualPos = pObjStrm->GetStream()->Seek(nPos);
 222
 223         if (nPos != nActualPos)
 224             throw BadSeek();
 225
 226         ReadLeafIndex(pObjStrm->GetStream());
 227
 228         if(j!=LeafCount-1)
 229         {
 230             m_ObjectKeys.push_back(vObjIndexs[j]);
 231
 232             m_nKeyCount ++;
 233         }
 234     }
 235
 236     vObjIndexs.clear();
 237     m_TempVec.clear();
 238 }
 239
 240 /**
 241  * @descr   Read VO_OBJINDEX
 242  */
 243 void LwpIndexManager::ReadObjIndex( LwpSvStream *pStrm )
 244 {
 245
 246     LwpObjectHeader ObjHdr;
 247     ObjHdr.Read(*pStrm);
 248     LwpObjectStream* pObjStrm = new LwpObjectStream(pStrm, ObjHdr.IsCompressed(),
 249             static_cast<sal_uInt16>(ObjHdr.GetSize()) );
 250
 251     if( (sal_uInt32)VO_OBJINDEX == ObjHdr.GetTag() )
 252     {
 253         ReadObjIndexData( pObjStrm );
 254     }
 255     else if( (sal_uInt32)VO_LEAFOBJINDEX == ObjHdr.GetTag() )
 256     {
 257         ReadLeafData(pObjStrm);
 258     }
 259
 260     delete pObjStrm;
 261 }
 262
 263 /**
 264  * @descr   Read VO_LEAFOBJINDEX
 265  */
 266 void LwpIndexManager::ReadLeafIndex( LwpSvStream *pStrm )
 267 {
 268     LwpObjectHeader ObjHdr;
 269     ObjHdr.Read(*pStrm);
 270     LwpObjectStream* pObjStrm = new LwpObjectStream(pStrm, ObjHdr.IsCompressed(),
 271             static_cast<sal_uInt16>(ObjHdr.GetSize()) );
 272
 273     ReadLeafData(pObjStrm);
 274
 275     delete pObjStrm;
 276 }
 277 /**
 278  * @descr   Read data in VO_LEAFOBJINDEX
 279  */
 280 void LwpIndexManager::ReadLeafData( LwpObjectStream *pObjStrm )
 281 {
 282     sal_uInt16 KeyCount = pObjStrm->QuickReaduInt16();
 283
 284     if(KeyCount)
 285     {
 286         LwpKey* akey = new LwpKey();
 287         //read object keys: id & offset
 288         akey->id.Read(pObjStrm);
 289         m_ObjectKeys.push_back(akey);
 290
 291         for (sal_uInt8 k = 1; k < KeyCount; k++)
 292         {
 293             akey = new LwpKey();
 294             akey->id.ReadCompressed(pObjStrm, m_ObjectKeys.at(m_nKeyCount+k-1)->id);
 295             m_ObjectKeys.push_back(akey);
 296         }
 297
 298         for (sal_uInt8 j = 0; j < KeyCount; j++)
 299             m_ObjectKeys.at(m_nKeyCount+j)->offset = pObjStrm->QuickReaduInt32();
 300     }
 301     m_nKeyCount += KeyCount;
 302 }
 303 /**
 304  * @descr   Read time table in VO_ROOTLEAFOBJINDEX and VO_ROOTOBJINDEX
 305  */
 306 void LwpIndexManager::ReadTimeTable(LwpObjectStream *pObjStrm)
 307 {
 308     sal_uInt16 nTimeCount = pObjStrm->QuickReaduInt16();
 309
 310     for(sal_uInt16 i=0; i<nTimeCount; ++i)
 311     {
 312         sal_uInt32 atime = pObjStrm->QuickReaduInt32();
 313         m_TimeTable.push_back(atime);
 314     }
 315 }
 316 /**
 317  * @descr       get object offset per the object id
 318  */
 319 sal_uInt32 LwpIndexManager::GetObjOffset( LwpObjectID objid )
 320 {
 321
 322     //sal_uInt16 L, U, M;
 323     sal_uInt32 L, U, M;
 324
 325     L = 0;
 326     U = m_nKeyCount;
 327     while (L != U)
 328     {
 329         M = (L + U) >> 1;
 330
 331         if (objid.GetLow() > m_ObjectKeys[M]->id.GetLow())
 332             L = M + 1;
 333         else if (objid.GetLow() < m_ObjectKeys[M]->id.GetLow())
 334             U = M;
 335         else if (objid.GetHigh() > m_ObjectKeys[M]->id.GetHigh())
 336             L = M + 1;
 337         else if (objid.GetHigh() < m_ObjectKeys[M]->id.GetHigh())
 338             U = M;
 339         else
 340         {
 341             return(m_ObjectKeys[M]->offset);
 342         }
 343     }
 344     return BAD_OFFSET;
 345 }
 346
 347 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */