xmlhelp/source/cxxhelp/provider/db.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include "db.hxx"
  22
  23 #include <rtl/alloc.h>
  24 #include <cstring>
  25
  26 #include <com/sun/star/io/XSeekable.hpp>
  27
  28 using namespace com::sun::star::uno;
  29 using namespace com::sun::star::io;
  30
  31 namespace helpdatafileproxy {
  32
  33 void HDFData::copyToBuffer( const char* pSrcData, int nSize )
  34 {
  35     m_nSize = nSize;
  36     delete [] m_pBuffer;
  37     m_pBuffer = new char[m_nSize+1];
  38     memcpy( m_pBuffer, pSrcData, m_nSize );
  39     m_pBuffer[m_nSize] = 0;
  40 }
  41
  42
  43 // Hdf
  44
  45 bool Hdf::implReadLenAndData( const char* pData, int& riPos, HDFData& rValue )
  46 {
  47     bool bSuccess = false;
  48
  49     // Read key len
  50     const char* pStartPtr = pData + riPos;
  51     char* pEndPtr;
  52     sal_Int32 nKeyLen = strtol( pStartPtr, &pEndPtr, 16 );
  53     if( pEndPtr == pStartPtr )
  54         return bSuccess;
  55     riPos += (pEndPtr - pStartPtr) + 1;
  56
  57     const char* pKeySrc = pData + riPos;
  58     rValue.copyToBuffer( pKeySrc, nKeyLen );
  59     riPos += nKeyLen + 1;
  60
  61     bSuccess = true;
  62     return bSuccess;
  63 }
  64
  65 void Hdf::createHashMap( bool bOptimizeForPerformance )
  66 {
  67     releaseHashMap();
  68     if( bOptimizeForPerformance )
  69     {
  70         if( m_pStringToDataMap != NULL )
  71             return;
  72         m_pStringToDataMap = new StringToDataMap();
  73     }
  74     else
  75     {
  76         if( m_pStringToValPosMap != NULL )
  77             return;
  78         m_pStringToValPosMap = new StringToValPosMap();
  79     }
  80
  81     Reference< XInputStream > xIn = m_xSFA->openFileRead( m_aFileURL );
  82     if( xIn.is() )
  83     {
  84         Sequence< sal_Int8 > aData;
  85         sal_Int32 nSize = m_xSFA->getSize( m_aFileURL );
  86         sal_Int32 nRead = xIn->readBytes( aData, nSize );
  87
  88         const char* pData = reinterpret_cast<const char*>(aData.getConstArray());
  89         int iPos = 0;
  90         while( iPos < nRead )
  91         {
  92             HDFData aDBKey;
  93             if( !implReadLenAndData( pData, iPos, aDBKey ) )
  94                 break;
  95
  96             OString aOKeyStr = aDBKey.getData();
  97
  98             // Read val len
  99             const char* pStartPtr = pData + iPos;
 100             char* pEndPtr;
 101             sal_Int32 nValLen = strtol( pStartPtr, &pEndPtr, 16 );
 102             if( pEndPtr == pStartPtr )
 103                 break;
 104
 105             iPos += (pEndPtr - pStartPtr) + 1;
 106
 107             if( bOptimizeForPerformance )
 108             {
 109                 const char* pValSrc = pData + iPos;
 110                 OString aValStr( pValSrc, nValLen );
 111                 (*m_pStringToDataMap)[aOKeyStr] = aValStr;
 112             }
 113             else
 114             {
 115                 // store value start position
 116                 (*m_pStringToValPosMap)[aOKeyStr] = std::pair<int,int>( iPos, nValLen );
 117             }
 118             iPos += nValLen + 1;
 119         }
 120
 121         xIn->closeInput();
 122     }
 123 }
 124
 125 void Hdf::releaseHashMap()
 126 {
 127     if( m_pStringToDataMap != NULL )
 128     {
 129         delete m_pStringToDataMap;
 130         m_pStringToDataMap = NULL;
 131     }
 132     if( m_pStringToValPosMap != NULL )
 133     {
 134         delete m_pStringToValPosMap;
 135         m_pStringToValPosMap = NULL;
 136     }
 137 }
 138
 139
 140 bool Hdf::getValueForKey( const OString& rKey, HDFData& rValue )
 141 {
 142     bool bSuccess = false;
 143     if( !m_xSFA.is() )
 144         return bSuccess;
 145
 146     try
 147     {
 148
 149     if( m_pStringToDataMap == NULL && m_pStringToValPosMap == NULL )
 150     {
 151         bool bOptimizeForPerformance = false;
 152         createHashMap( bOptimizeForPerformance );
 153     }
 154
 155     if( m_pStringToValPosMap != NULL )
 156     {
 157         StringToValPosMap::const_iterator it = m_pStringToValPosMap->find( rKey );
 158         if( it != m_pStringToValPosMap->end() )
 159         {
 160             const std::pair<int,int>& rValPair = it->second;
 161             int iValuePos = rValPair.first;
 162             int nValueLen = rValPair.second;
 163
 164             Reference< XInputStream > xIn = m_xSFA->openFileRead( m_aFileURL );
 165             if( xIn.is() )
 166             {
 167                 Reference< XSeekable > xXSeekable( xIn, UNO_QUERY );
 168                 if( xXSeekable.is() )
 169                 {
 170                     xXSeekable->seek( iValuePos );
 171
 172                     Sequence< sal_Int8 > aData;
 173                     sal_Int32 nRead = xIn->readBytes( aData, nValueLen );
 174                     if( nRead == nValueLen )
 175                     {
 176                         const char* pData = reinterpret_cast<const sal_Char*>(aData.getConstArray());
 177                         rValue.copyToBuffer( pData, nValueLen );
 178                         bSuccess = true;
 179                     }
 180                 }
 181                 xIn->closeInput();
 182             }
 183         }
 184     }
 185
 186     else if( m_pStringToDataMap != NULL )
 187     {
 188         StringToDataMap::const_iterator it = m_pStringToDataMap->find( rKey );
 189         if( it != m_pStringToDataMap->end() )
 190         {
 191             const OString& rValueStr = it->second;
 192             int nValueLen = rValueStr.getLength();
 193             const char* pData = rValueStr.getStr();
 194             rValue.copyToBuffer( pData, nValueLen );
 195             bSuccess = true;
 196         }
 197     }
 198
 199     }
 200     catch( Exception & )
 201     {
 202         bSuccess = false;
 203     }
 204
 205     return bSuccess;
 206 }
 207
 208 bool Hdf::startIteration()
 209 {
 210     bool bSuccess = false;
 211
 212     sal_Int32 nSize = m_xSFA->getSize( m_aFileURL );
 213
 214     Reference< XInputStream > xIn = m_xSFA->openFileRead( m_aFileURL );
 215     if( xIn.is() )
 216     {
 217         m_nItRead = xIn->readBytes( m_aItData, nSize );
 218         if( m_nItRead == nSize )
 219         {
 220             bSuccess = true;
 221             m_pItData = reinterpret_cast<const char*>(m_aItData.getConstArray());
 222             m_iItPos = 0;
 223         }
 224         else
 225         {
 226             stopIteration();
 227         }
 228     }
 229
 230     return bSuccess;
 231 }
 232
 233 bool Hdf::getNextKeyAndValue( HDFData& rKey, HDFData& rValue )
 234 {
 235     bool bSuccess = false;
 236
 237     if( m_iItPos < m_nItRead )
 238     {
 239         if( implReadLenAndData( m_pItData, m_iItPos, rKey ) )
 240         {
 241             if( implReadLenAndData( m_pItData, m_iItPos, rValue ) )
 242                 bSuccess = true;
 243         }
 244     }
 245
 246     return bSuccess;
 247 }
 248
 249 void Hdf::stopIteration()
 250 {
 251     m_aItData = Sequence<sal_Int8>();
 252     m_pItData = NULL;
 253     m_nItRead = -1;
 254     m_iItPos = -1;
 255 }
 256
 257 } // end of namespace helpdatafileproxy
 258
 259 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */