store/workben/t_base.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include "sal/types.h"
  31 #include "osl/diagnose.h"
  32 #include "osl/thread.h"
  33 #include "rtl/memory.h"
  34 #include "rtl/ustring.hxx"
  35
  36 #include "object.hxx"
  37 #include "storbase.hxx"
  38 #include "storbios.hxx"
  39 #include "lockbyte.hxx"
  40
  41 using namespace store;
  42
  43 #define TEST_PAGESIZE 1024
  44
  45 /*========================================================================
  46  *
  47  * OTestObject.
  48  *
  49  *======================================================================*/
  50 class OTestObject : public store::OStoreObject
  51 {
  52 public:
  53     OTestObject (void);
  54
  55     virtual sal_Bool SAL_CALL isKindOf (sal_uInt32 nTypeId);
  56
  57 protected:
  58     virtual ~OTestObject (void);
  59 };
  60
  61 OTestObject::OTestObject (void)
  62 {
  63 }
  64
  65 OTestObject::~OTestObject (void)
  66 {
  67 }
  68
  69 sal_Bool SAL_CALL OTestObject::isKindOf (sal_uInt32 nTypeId)
  70 {
  71     return (nTypeId == 42);
  72 }
  73
  74 namespace store
  75 {
  76 static OTestObject* SAL_CALL query (IStoreHandle *pHandle, OTestObject*)
  77 {
  78     if (pHandle && pHandle->isKindOf (42))
  79         return static_cast<OTestObject*>(pHandle);
  80     else
  81         return 0;
  82 }
  83 }
  84
  85 /*========================================================================
  86  *
  87  * OTestBIOS.
  88  *
  89  *======================================================================*/
  90 namespace store
  91 {
  92
  93 class OTestBIOS : public store::OStorePageBIOS
  94 {
  95     typedef store::OStorePageBIOS base;
  96
  97     friend OTestBIOS* SAL_CALL query<> (IStoreHandle * pHandle, OTestBIOS *);
  98
  99 public:
 100     OTestBIOS (void);
 101
 102     virtual storeError initialize (
 103         ILockBytes *    pLockBytes,
 104         storeAccessMode eAccessMode,
 105         sal_uInt16 &    rnPageSize);
 106
 107     virtual sal_Bool SAL_CALL isKindOf (sal_uInt32 nTypeId);
 108
 109 protected:
 110     virtual ~OTestBIOS (void);
 111 };
 112
 113 } // namespace store
 114
 115 OTestBIOS::OTestBIOS (void)
 116 {
 117 }
 118
 119 OTestBIOS::~OTestBIOS (void)
 120 {
 121 }
 122
 123 sal_Bool SAL_CALL OTestBIOS::isKindOf (sal_uInt32 nTypeId)
 124 {
 125     return (nTypeId == 4242);
 126 }
 127
 128 storeError OTestBIOS::initialize (
 129     ILockBytes *pLockBytes, storeAccessMode eAccessMode, sal_uInt16 & rnPageSize)
 130 {
 131     return base::initialize (pLockBytes, eAccessMode, rnPageSize);
 132 }
 133
 134 namespace store
 135 {
 136 template<> OTestBIOS* SAL_CALL query (IStoreHandle *pHandle, OTestBIOS*)
 137 {
 138     if (pHandle && pHandle->isKindOf (4242))
 139         return static_cast<OTestBIOS*>(pHandle);
 140     else
 141         return 0;
 142 }
 143 }
 144
 145 /*========================================================================
 146  *
 147  * __store_test_handle.
 148  *
 149  *======================================================================*/
 150 static void __store_test_handle (void* Handle)
 151 {
 152     IStoreHandle *pHandle = static_cast<IStoreHandle*>(Handle);
 153     if (pHandle)
 154     {
 155         pHandle->acquire();
 156         pHandle->isKindOf (42);
 157         pHandle->release();
 158     }
 159
 160     OTestObject *pObj = query (pHandle, static_cast<OTestObject*>(0));
 161     if (pObj)
 162     {
 163         pObj->acquire();
 164         pObj->isKindOf (42);
 165         pObj->release();
 166     }
 167 }
 168
 169 /*========================================================================
 170  *
 171  * unicode.
 172  *
 173  *======================================================================*/
 174 static void __store_string_newFromUnicode_WithLength (
 175     rtl_String **newString, const sal_Unicode *value, sal_Int32 length)
 176 {
 177     rtl_uString2String (
 178         newString,
 179         value, length,
 180         RTL_TEXTENCODING_UTF8,
 181         OUSTRING_TO_OSTRING_CVTFLAGS);
 182 }
 183
 184 static void __store_string_newFromUnicode (
 185     rtl_String **newString, const sal_Unicode *value)
 186 {
 187     __store_string_newFromUnicode_WithLength (
 188         newString, value, rtl_ustr_getLength (value));
 189 }
 190
 191 static storeError __store_namei (
 192     const sal_Unicode *pszPath,
 193     const sal_Unicode *pszName,
 194     OStorePageKey     &rKey)
 195 {
 196     rtl::OString aName (
 197         pszName, rtl_ustr_getLength (pszName), RTL_TEXTENCODING_UTF8);
 198
 199     rtl_String *pszNameA = 0;
 200     __store_string_newFromUnicode (&pszNameA, pszName);
 201
 202     storeError eErrCode = store_E_NameTooLong;
 203     if (pszNameA->length < sal_Int32(sizeof(sal_Char[STORE_MAXIMUM_NAMESIZE])))
 204     {
 205         rtl_String *pszPathA = 0;
 206         __store_string_newFromUnicode (&pszPathA, pszPath);
 207
 208         rKey.m_nLow  = rtl_crc32 (0, pszNameA->buffer, pszNameA->length);
 209         rKey.m_nHigh = rtl_crc32 (0, pszPathA->buffer, pszPathA->length);
 210
 211         rtl_string_release (pszPathA);
 212         eErrCode = store_E_None;
 213     }
 214
 215     rtl_string_release (pszNameA);
 216     return eErrCode;
 217 }
 218
 219 static sal_Size __store_convertTextToUnicode (
 220     rtl_TextToUnicodeConverter hConvert,
 221     const sal_Char *pszText, sal_Size nTextLen,
 222     sal_Unicode    *pBuffer, sal_Size nBuffer)
 223 {
 224     sal_uInt32 nInfo = 0;
 225     sal_Size   nSrcLen = 0;
 226
 227     sal_Int32 nDstLen = rtl_convertTextToUnicode (
 228         hConvert, 0,
 229         pszText, nTextLen,
 230         pBuffer, nBuffer,
 231         OSTRING_TO_OUSTRING_CVTFLAGS,
 232         &nInfo, &nSrcLen);
 233
 234     pBuffer[nDstLen] = 0;
 235     return nDstLen;
 236 }
 237
 238 struct MyFindData
 239 {
 240     sal_Unicode m_pszName[STORE_MAXIMUM_NAMESIZE];
 241     sal_Int32   m_nLength;
 242     sal_uInt32  m_nAttrib;
 243     sal_uInt32  m_nSize;
 244     sal_uInt32  m_nReserved;
 245 };
 246
 247 static void __store_testUnicode (const sal_Char *pszFilename)
 248 {
 249     // ...
 250     rtl_TextToUnicodeConverter hConvert;
 251     hConvert = rtl_createTextToUnicodeConverter (RTL_TEXTENCODING_UTF8);
 252
 253     MyFindData it;
 254     rtl_zeroMemory (&it, sizeof(it));
 255
 256     sal_Int32 n = rtl_str_getLength (pszFilename);
 257     n = __store_convertTextToUnicode (
 258         hConvert, pszFilename, n,
 259         it.m_pszName, STORE_MAXIMUM_NAMESIZE - 1);
 260     if (it.m_nLength > n)
 261         rtl_zeroMemory (
 262             &it.m_pszName[n], ((it.m_nLength - n) * sizeof(sal_Unicode)));
 263     it.m_nLength = n;
 264
 265     rtl_destroyTextToUnicodeConverter (hConvert);
 266
 267     // ...
 268     rtl_String  *pszFileA = NULL;
 269     rtl_uString *pszFileW = NULL;
 270
 271     // rtl_uString_newFromAscii (&pszFileW, pszFilename);
 272
 273     // ...
 274     rtl_string_newFromStr (&pszFileA, pszFilename);
 275
 276     rtl_string2UString (
 277         &pszFileW,
 278         pszFileA->buffer, pszFileA->length,
 279         RTL_TEXTENCODING_MS_1252,
 280         OSTRING_TO_OUSTRING_CVTFLAGS);
 281
 282     rtl_string_release (pszFileA);
 283
 284     // ...
 285     OStorePageKey aKey;
 286     __store_namei (pszFileW->buffer, pszFileW->buffer, aKey);
 287
 288     // ...
 289     rtl_uString2String (
 290         &pszFileA,
 291         pszFileW->buffer, pszFileW->length,
 292         RTL_TEXTENCODING_UTF8,
 293         OUSTRING_TO_OSTRING_CVTFLAGS);
 294
 295     rtl_uString_release (pszFileW);
 296
 297     // ...
 298     rtl_string_release (pszFileA);
 299 }
 300
 301 /*========================================================================
 302  *
 303  * main.
 304  *
 305  *======================================================================*/
 306 int SAL_CALL main (int argc, char **argv)
 307 {
 308     OSL_PRECOND(argc > 1, "t_base: error: insufficient number of arguments.");
 309     if (argc < 2)
 310         return 0;
 311
 312     __store_testUnicode (argv[1]);
 313
 314     rtl::Reference<ILockBytes> xLockBytes;
 315
 316     rtl::OUString aFilename (
 317         argv[1], rtl_str_getLength(argv[1]),
 318         osl_getThreadTextEncoding());
 319
 320     storeError eErrCode = FileLockBytes_createInstance (
 321         xLockBytes, aFilename.pData, store_AccessReadCreate);
 322     if (eErrCode != store_E_None)
 323         return eErrCode;
 324
 325
 326     rtl::Reference<OTestObject> xObject (new OTestObject());
 327     __store_test_handle (&*xObject);
 328
 329     rtl::Reference<OTestBIOS> xBIOS (new OTestBIOS());
 330     __store_test_handle (&*xBIOS);
 331
 332
 333     if (!xBIOS.is())
 334         return 0;
 335
 336     sal_uInt16 nPageSize = TEST_PAGESIZE;
 337     eErrCode = xBIOS->initialize (&*xLockBytes, store_AccessReadWrite, nPageSize);
 338     if (eErrCode != store_E_None)
 339     {
 340         // Check reason.
 341         if (eErrCode != store_E_NotExists)
 342             return eErrCode;
 343
 344         // Create.
 345         eErrCode = xBIOS->initialize (&*xLockBytes, store_AccessReadCreate, nPageSize);
 346         if (eErrCode != store_E_None)
 347             return eErrCode;
 348     }
 349     xLockBytes.clear();
 350
 351     sal_Char pBuffer[TEST_PAGESIZE];
 352     rtl_zeroMemory (pBuffer, sizeof (pBuffer));
 353     rtl_copyMemory (pBuffer, argv[0], rtl_str_getLength(argv[0]) + 1);
 354
 355     eErrCode = xBIOS->write (TEST_PAGESIZE, pBuffer, sizeof (pBuffer));
 356     if (eErrCode != store_E_None)
 357         return eErrCode;
 358
 359     xBIOS.clear();
 360     return 0;
 361 }
 362
 363 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */