rdbmaker/inc/codemaker/registry.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: registry.hxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef _CODEMAKER_REGISTRY_HXX_
  32 #define _CODEMAKER_REGISTRY_HXX_
  33
  34 #include <rtl/alloc.h>
  35 #include <osl/interlck.h>
  36 #include        <registry/registry.hxx>
  37 #include "registry/reader.hxx"
  38 #include "registry/version.h"
  39 #include        <codemaker/options.hxx>
  40
  41 struct TypeReader_Impl
  42 {
  43         TypeReader_Impl(const sal_uInt8* buffer,
  44                                     sal_uInt32 bufferLen,
  45                                     sal_Bool copyData)
  46                 : m_refCount(0)
  47                 , m_copyData(copyData)
  48                 , m_blopSize(bufferLen)
  49                 , m_pBlop(buffer)
  50                 {
  51                         if (copyData)
  52                         {
  53                                 m_pBlop = (sal_uInt8*)rtl_allocateMemory(bufferLen);
  54                                 rtl_copyMemory((void*)m_pBlop, buffer, bufferLen);
  55                         } else
  56                         {
  57                                 m_blopSize = bufferLen;
  58                                 m_pBlop = buffer;
  59                         }
  60
  61                         m_pReader = new typereg::Reader(
  62                 m_pBlop, m_blopSize, false, TYPEREG_VERSION_1);
  63                 }
  64
  65         ~TypeReader_Impl()
  66                 {
  67                         if (m_copyData && m_pReader)
  68                         {
  69                                 delete m_pReader;
  70                         }
  71                 }
  72
  73         sal_Int32                       m_refCount;
  74         sal_Bool                        m_copyData;
  75         sal_Int32                       m_blopSize;
  76         const sal_uInt8*        m_pBlop;
  77         typereg::Reader*        m_pReader;
  78 };
  79
  80 class TypeReader
  81 {
  82 /*
  83         inline TypeReader(const RegistryTypeReader_Api* pApi,
  84                                                           const sal_uInt8* buffer,
  85                                                           sal_uInt32 bufferLen,
  86                                                           sal_Bool copyData);
  87 */
  88 public:
  89         inline TypeReader()
  90                 : m_pImpl(NULL)
  91         {}
  92
  93         inline TypeReader(        const sal_uInt8* buffer,
  94                                                           sal_uInt32 bufferLen,
  95                                                           sal_Bool copyData)
  96         {
  97                 m_pImpl = new TypeReader_Impl(buffer, bufferLen, copyData);
  98                 acquire();
  99         }
 100
 101         inline TypeReader(const TypeReader& toCopy)
 102                 : m_pImpl(toCopy.m_pImpl)
 103         {
 104                 acquire();
 105         }
 106
 107     inline ~TypeReader()
 108         {
 109                 release();
 110         }
 111
 112     inline void acquire()
 113         {
 114                 if (m_pImpl)
 115                         osl_incrementInterlockedCount(&m_pImpl->m_refCount);
 116         }
 117
 118         inline void release()
 119         {
 120                 if (m_pImpl && 0 == osl_decrementInterlockedCount(&m_pImpl->m_refCount))
 121                 {
 122                         delete m_pImpl;
 123                 }
 124         }
 125
 126         inline TypeReader& operator = ( const TypeReader& value )
 127         {
 128                 release();
 129                 m_pImpl = value.m_pImpl;
 130                 acquire();
 131                 return *this;
 132         }
 133
 134         inline sal_Bool                 isValid() const
 135                 {
 136                         if (m_pImpl)
 137                                 return m_pImpl->m_pReader->isValid();
 138                         else
 139                                 return sal_False;
 140                 }
 141
 142         inline RTTypeClass                              getTypeClass() const
 143                 { return m_pImpl->m_pReader->getTypeClass(); }
 144         inline const ::rtl::OString     getTypeName() const
 145                 { return inGlobalSet( m_pImpl->m_pReader->getTypeName() ); }
 146     inline sal_uInt16 getSuperTypeCount() const
 147         { return m_pImpl->m_pReader->getSuperTypeCount(); }
 148         inline const ::rtl::OString     getSuperTypeName(sal_uInt16 index) const
 149                 { return inGlobalSet( m_pImpl->m_pReader->getSuperTypeName(index) ); }
 150         inline const ::rtl::OString     getDoku() const
 151                 { return inGlobalSet( m_pImpl->m_pReader->getDocumentation() ); }
 152         inline const ::rtl::OString     getFileName() const
 153                 { return inGlobalSet( m_pImpl->m_pReader->getFileName() ); }
 154         inline sal_uInt32                               getFieldCount() const
 155                 { return m_pImpl->m_pReader->getFieldCount(); }
 156         inline const ::rtl::OString     getFieldName( sal_uInt16 index ) const
 157                 { return inGlobalSet( m_pImpl->m_pReader->getFieldName(index) ); }
 158         inline const ::rtl::OString             getFieldType( sal_uInt16 index ) const
 159                 { return inGlobalSet( m_pImpl->m_pReader->getFieldTypeName(index) ); }
 160         inline RTFieldAccess                    getFieldAccess( sal_uInt16 index ) const
 161                 { return m_pImpl->m_pReader->getFieldFlags(index); }
 162         inline RTConstValue                             getFieldConstValue( sal_uInt16 index ) const
 163                 { return m_pImpl->m_pReader->getFieldValue(index); }
 164         inline const ::rtl::OString     getFieldDoku( sal_uInt16 index ) const
 165                 { return inGlobalSet( m_pImpl->m_pReader->getFieldDocumentation(index) ); }
 166         inline const ::rtl::OString     getFieldFileName( sal_uInt16 index ) const
 167                 { return inGlobalSet( m_pImpl->m_pReader->getFieldFileName(index) ); }
 168         inline sal_uInt32                               getMethodCount() const
 169                 { return m_pImpl->m_pReader->getMethodCount(); }
 170         inline const ::rtl::OString     getMethodName( sal_uInt16 index ) const
 171                 { return inGlobalSet( m_pImpl->m_pReader->getMethodName(index) ); }
 172         inline sal_uInt32                       getMethodParamCount( sal_uInt16 index ) const
 173                 { return m_pImpl->m_pReader->getMethodParameterCount(index); }
 174         inline const ::rtl::OString     getMethodParamType( sal_uInt16 index, sal_uInt16 paramIndex ) const
 175                 { return inGlobalSet( m_pImpl->m_pReader->getMethodParameterTypeName(index,paramIndex) ); }
 176         inline const ::rtl::OString     getMethodParamName( sal_uInt16 index, sal_uInt16 paramIndex ) const
 177                 { return inGlobalSet( m_pImpl->m_pReader->getMethodParameterName(index,paramIndex) ); }
 178         inline RTParamMode                              getMethodParamMode( sal_uInt16 index, sal_uInt16 paramIndex ) const
 179                 { return m_pImpl->m_pReader->getMethodParameterFlags(index,paramIndex); }
 180         inline sal_uInt32                       getMethodExcCount( sal_uInt16 index ) const
 181                 { return m_pImpl->m_pReader->getMethodExceptionCount(index); }
 182         inline const ::rtl::OString     getMethodExcType( sal_uInt16 index, sal_uInt16 excIndex ) const
 183                 { return inGlobalSet( m_pImpl->m_pReader->getMethodExceptionTypeName(index,excIndex) ); }
 184         inline const ::rtl::OString     getMethodReturnType( sal_uInt16 index ) const
 185                 { return inGlobalSet( m_pImpl->m_pReader->getMethodReturnTypeName(index) ); }
 186         inline RTMethodMode                             getMethodMode( sal_uInt16 index ) const
 187                 { return m_pImpl->m_pReader->getMethodFlags(index); }
 188         inline const ::rtl::OString     getMethodDoku( sal_uInt16 index ) const
 189                 { return inGlobalSet( m_pImpl->m_pReader->getMethodDocumentation(index) ); }
 190
 191         inline sal_uInt32                               getReferenceCount() const
 192                 { return m_pImpl->m_pReader->getReferenceCount(); }
 193         inline const ::rtl::OString     getReferenceName( sal_uInt16 index ) const
 194                 { return inGlobalSet( m_pImpl->m_pReader->getReferenceTypeName(index) ); }
 195         inline RTReferenceType                  getReferenceType( sal_uInt16 index ) const
 196                 { return m_pImpl->m_pReader->getReferenceSort(index); }
 197         inline const ::rtl::OString     getReferenceDoku( sal_uInt16 index ) const
 198                 { return inGlobalSet( m_pImpl->m_pReader->getReferenceDocumentation(index) ); }
 199
 200         inline sal_uInt32 getBlopSize() const
 201                 { return m_pImpl->m_blopSize; }
 202
 203         inline const sal_uInt8* getBlop() const
 204                 { return m_pImpl->m_pBlop; }
 205
 206 private:
 207         TypeReader_Impl* m_pImpl;
 208 };
 209
 210
 211 #endif // _CODEMAKER_REGISTRY_HXX_