LCOV - code coverage report
Current view: top level - rsc/source/res - rsccont.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 224 367 61.0 %
Date: 2014-11-03 Functions: 28 37 75.7 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #include <stdlib.h>
      21             : #include <stdio.h>
      22             : #include <string.h>
      23             : 
      24             : #include <rsccont.hxx>
      25             : 
      26             : #include <tools/rcid.h>
      27             : 
      28       41658 : void ENTRY_STRUCT::Destroy()
      29             : {
      30       41658 :     aName.Destroy();
      31       41658 :     if( aInst.IsInst() )
      32             :     {
      33       41658 :         aInst.pClass->Destroy( aInst );
      34       41658 :         rtl_freeMemory( aInst.pData );
      35             :     }
      36       41658 : }
      37             : 
      38        4190 : RscBaseCont::RscBaseCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper,
      39             :                           bool bNoIdent )
      40             :     : RscTop( nId, nTypeId, pSuper )
      41        4190 :     , nSize( 0 )
      42             : {
      43        4190 :     pTypeClass = NULL;
      44        4190 :     pTypeClass1 = NULL;
      45        4190 :     bNoId = bNoIdent;
      46        4190 :     nOffInstData = RscTop::Size();
      47        4190 :     nSize = nOffInstData + ALIGNED_SIZE( sizeof( RscBaseContInst ) );
      48        4190 : }
      49             : 
      50        4609 : RscBaseCont::~RscBaseCont()
      51             : {
      52        4609 : }
      53             : 
      54           0 : RSCCLASS_TYPE RscBaseCont::GetClassType() const
      55             : {
      56           0 :     return RSCCLASS_COMPLEX;
      57             : }
      58             : 
      59       48123 : void RscBaseCont::DestroyElements( RscBaseContInst * pClassData )
      60             : {
      61       48123 :     if( pClassData->nEntries )
      62             :     {
      63       38126 :         for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
      64             :         {
      65       33308 :             pClassData->pEntries[ i ].Destroy();
      66             :         }
      67        4818 :         rtl_freeMemory( pClassData->pEntries );
      68        4818 :         pClassData->pEntries = NULL;
      69        4818 :         pClassData->nEntries = 0;
      70             :     }
      71       48123 : }
      72             : 
      73       46643 : RSCINST RscBaseCont::Create( RSCINST * pInst, const RSCINST & rDflt,
      74             :                              bool bOwnClass )
      75             : {
      76       46643 :     RSCINST aInst;
      77             :     RscBaseContInst * pClassData;
      78             : 
      79       46643 :     if( !pInst )
      80             :     {
      81        1982 :         aInst.pClass = this;
      82        1982 :         aInst.pData = (CLASS_DATA) rtl_allocateMemory( Size() );
      83             :     }
      84             :     else
      85       44661 :         aInst = *pInst;
      86             : 
      87       46643 :     if( !bOwnClass && rDflt.IsInst() )
      88         154 :         bOwnClass = rDflt.pClass->InHierarchy( this );
      89             : 
      90       46643 :     RscTop::Create( &aInst, rDflt, bOwnClass );
      91             : 
      92       46643 :     pClassData = (RscBaseContInst *)(aInst.pData + nOffInstData);
      93       46643 :     pClassData->nEntries = 0;
      94       46643 :     pClassData->pEntries = NULL;
      95       46643 :     pClassData->bDflt = true;
      96             : 
      97       46643 :     if( bOwnClass )
      98             :     {
      99             :         RscBaseContInst *   pDfltClassData;
     100         154 :         RSCINST         aDfltI;
     101             : 
     102         154 :         pDfltClassData = (RscBaseContInst *)(rDflt.pData + nOffInstData);
     103             : 
     104         154 :         if( 0 != pDfltClassData->nEntries )
     105             :         {
     106           0 :             *pClassData = *pDfltClassData;
     107             :             pClassData->pEntries =
     108             :                 (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
     109           0 :                                                     * pClassData->nEntries );
     110           0 :             for (sal_uInt32 i = 0; i < pClassData->nEntries; i++ )
     111             :             {
     112           0 :                 pClassData->pEntries[ i ].Create();
     113           0 :                 pClassData->pEntries[ i ].aName =
     114           0 :                                     pDfltClassData->pEntries[ i ].aName;
     115           0 :                 aDfltI = pDfltClassData->pEntries[ i ].aInst;
     116             :                 pClassData->pEntries[ i ].aInst =
     117           0 :                                     aDfltI.pClass->Create( NULL, aDfltI );
     118             :             }
     119             :         }
     120             :     }
     121             : 
     122       46643 :     return aInst;
     123             : }
     124             : 
     125       46643 : void RscBaseCont::Destroy( const RSCINST & rInst )
     126             : {
     127             :     RscBaseContInst * pClassData;
     128             : 
     129       46643 :     RscTop::Destroy( rInst);
     130             : 
     131       46643 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     132       46643 :     DestroyElements( pClassData );
     133       46643 : }
     134             : 
     135       14534 : RSCINST RscBaseCont::SearchElePos( const RSCINST & rInst, const RscId & rEleName,
     136             :                                    RscTop * pClass, sal_uInt32 nPos )
     137             : {
     138             :     RscBaseContInst * pClassData;
     139             : 
     140       14534 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     141       14534 :     if( !pClass )
     142           0 :         pClass = pTypeClass;
     143             : 
     144       14534 :     if( rEleName.IsId() )
     145             :     {
     146     1140246 :         for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
     147             :         {
     148     1125966 :             if( pClassData->pEntries[ i ].aName == rEleName &&
     149         254 :                 pClassData->pEntries[ i ].aInst.pClass == pClass )
     150             :             {
     151           0 :                 return( pClassData->pEntries[ i ].aInst );
     152             :             }
     153             :         }
     154             :     }
     155       14534 :     return RSCINST();
     156             : }
     157             : 
     158       14534 : RSCINST RscBaseCont::SearchEle( const RSCINST & rInst, const RscId & rEleName,
     159             :                                 RscTop * pClass )
     160             : {
     161       14534 :     return SearchElePos( rInst, rEleName, pClass, 0 );
     162             : }
     163             : 
     164       41658 : ERRTYPE RscBaseCont::GetElement( const RSCINST & rInst, const RscId & rEleName,
     165             :                                  RscTop * pCreateClass,
     166             :                                  const RSCINST & rCreateInst, RSCINST * pGetInst )
     167             : {
     168             :     RscBaseContInst * pClassData;
     169       41658 :     RSCINST           aTmpI;
     170       41658 :     ERRTYPE           aError;
     171             : 
     172       41658 :     if( !bNoId && !rEleName.IsId() )
     173           0 :         aError = WRN_CONT_NOID;
     174             : 
     175       41658 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     176             : 
     177       41658 :     if( pCreateClass )
     178             :     {
     179       37903 :         if( !pCreateClass->InHierarchy( pTypeClass ) )
     180             :         {
     181        5188 :             if( pTypeClass1 )
     182             :             {
     183        5188 :                 if( !pCreateClass->InHierarchy( pTypeClass1 ) )
     184             :                 {
     185           0 :                     return ERR_CONT_INVALIDTYPE;
     186             :                 }
     187             :             }
     188             :             else
     189             :             {
     190           0 :                 return ERR_CONT_INVALIDTYPE;
     191             :             }
     192             :         }
     193             :     }
     194             :     else
     195        3755 :         pCreateClass = pTypeClass;
     196             : 
     197       41658 :     pClassData->bDflt = false;
     198             : 
     199       41658 :     if( !bNoId )
     200       14534 :         aTmpI = SearchEle( rInst, rEleName, pCreateClass );
     201             :     // Eintrag gefunden
     202       41658 :     if( aTmpI.IsInst() )
     203             :     {
     204           0 :         aError = WRN_CONT_DOUBLEID;
     205           0 :         if( rCreateInst.IsInst() )
     206             :         {
     207           0 :             aTmpI.pClass->Destroy( aTmpI );
     208           0 :             aTmpI.pClass->Create( &aTmpI, rCreateInst );
     209             :         }
     210             :     }
     211             :     else
     212             :     {
     213       41658 :         if( pClassData->pEntries )
     214             :         {
     215             :             pClassData->pEntries =
     216             :                 (ENTRY_STRUCT *)rtl_reallocateMemory( pClassData->pEntries,
     217       36840 :                          sizeof( ENTRY_STRUCT ) * (pClassData->nEntries +1) );
     218             :         }
     219             :         else
     220             :         {
     221             :             pClassData->pEntries =
     222             :                 (ENTRY_STRUCT *)rtl_allocateMemory( sizeof( ENTRY_STRUCT )
     223        4818 :                                                 * (pClassData->nEntries +1) );
     224             :         }
     225             : 
     226       41658 :         pClassData->pEntries[ pClassData->nEntries ].Create();
     227       41658 :         pClassData->pEntries[ pClassData->nEntries ].aName = rEleName;
     228             : 
     229       41658 :         if( rCreateInst.IsInst() )
     230             :         {
     231             :             // Instanz mit CreateInst-Daten initialisieren
     232             :             pClassData->pEntries[ pClassData->nEntries ].aInst =
     233           0 :                 pCreateClass->Create( NULL, rCreateInst );
     234             :         }
     235             :         else
     236             :         {
     237             :             pClassData->pEntries[ pClassData->nEntries ].aInst =
     238       41658 :                 pCreateClass->Create( NULL, RSCINST() );
     239             :         }
     240             : 
     241       41658 :         pClassData->nEntries++;
     242       41658 :         aTmpI = pClassData->pEntries[ pClassData->nEntries -1 ].aInst;
     243             :     }
     244             : 
     245       41658 :     *pGetInst = aTmpI;
     246       41658 :     return aError;
     247             : }
     248             : 
     249        4560 : sal_uInt32 RscBaseCont::GetCount( const RSCINST & rInst )
     250             : {
     251             :     RscBaseContInst * pClassData;
     252             : 
     253        4560 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     254        4560 :     return pClassData->nEntries;
     255             : }
     256             : 
     257           0 : RSCINST RscBaseCont::GetPosEle( const RSCINST & rInst, sal_uInt32 nPos )
     258             : {
     259             :     RscBaseContInst * pClassData;
     260             : 
     261           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     262             : 
     263           0 :     if( nPos < pClassData->nEntries )
     264           0 :         return( pClassData->pEntries[ nPos ].aInst );
     265           0 :     return RSCINST();
     266             : }
     267             : 
     268           0 : ERRTYPE RscBaseCont::MovePosEle( const RSCINST & rInst, sal_uInt32 nDestPos,
     269             :                                  sal_uInt32 nSourcePos )
     270             : {
     271           0 :     ERRTYPE aError;
     272             :     RscBaseContInst * pClassData;
     273             : 
     274           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     275             : 
     276           0 :     if( (nDestPos < pClassData->nEntries) && (nSourcePos < pClassData->nEntries) )
     277             :     {
     278           0 :         ENTRY_STRUCT aEntry;
     279           0 :         int nInc = 1;
     280           0 :         sal_uInt32 i = 0;
     281             : 
     282             :         // Quelle Merken
     283           0 :         aEntry = pClassData->pEntries[ nSourcePos ];
     284             :         // Richtung der for-Schleife bestimmen
     285           0 :         if( nDestPos < nSourcePos )
     286           0 :             nInc = -1;
     287             : 
     288           0 :         for( i = nSourcePos; i != nDestPos; i += nInc )
     289           0 :             pClassData->pEntries[ i ] = pClassData->pEntries[ i + nInc ];
     290             : 
     291             :         // Zuweisung Quelle auf Ziel
     292           0 :         pClassData->pEntries[ nDestPos ] = aEntry;
     293             :     }
     294             :     else
     295           0 :         aError = ERR_RSCCONT;
     296             : 
     297           0 :     return aError;
     298             : }
     299             : 
     300           0 : ERRTYPE RscBaseCont::SetPosRscId( const RSCINST & rInst, sal_uInt32 nPos,
     301             :                                   const RscId & rId )
     302             : {
     303             :     RscBaseContInst * pClassData;
     304           0 :     RSCINST           aTmpI;
     305           0 :     ERRTYPE           aError;
     306             : 
     307           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     308             : 
     309           0 :     if( nPos < pClassData->nEntries )
     310             :     {
     311           0 :         if( ! (rId == pClassData->pEntries[ nPos ].aName) )
     312             :             aTmpI = SearchEle( rInst, rId,
     313           0 :                                pClassData->pEntries[ nPos ].aInst.pClass );
     314           0 :         if( !aTmpI.IsInst() )
     315           0 :             pClassData->pEntries[ nPos ].aName = rId;
     316             :         else
     317           0 :             aError = ERR_RSCCONT;
     318             :     }
     319             :     else
     320           0 :         aError = ERR_RSCCONT;
     321             : 
     322           0 :     return aError;
     323             : }
     324             : 
     325           0 : SUBINFO_STRUCT RscBaseCont::GetInfoEle( const RSCINST & rInst, sal_uInt32 nPos )
     326             : {
     327             :     RscBaseContInst * pClassData;
     328           0 :     SUBINFO_STRUCT  aInfo;
     329             : 
     330           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     331             : 
     332           0 :     if( nPos < pClassData->nEntries )
     333             :     {
     334           0 :         aInfo.aId = pClassData->pEntries[ nPos ].aName;
     335           0 :         aInfo.nPos = nPos;
     336           0 :         aInfo.pClass = pClassData->pEntries[ nPos ].aInst.pClass;
     337             :     }
     338           0 :     return aInfo;
     339             : }
     340             : 
     341         876 : ERRTYPE RscBaseCont::SetString( const RSCINST & rInst, const char * pStr )
     342             : {
     343             :     RscBaseContInst * pClassData;
     344         876 :     RSCINST aTmpI;
     345         876 :     ERRTYPE aError;
     346             :     char    *pTmpStr;
     347             : 
     348         876 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     349             : 
     350             :     // otherwise infinite recursion is possible
     351         876 :     if( RSC_NOTYPE == pTypeClass->GetTypId() )
     352             :     {
     353         876 :         aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
     354         876 :         aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
     355             : 
     356         876 :         if( aError.IsOk() )
     357          60 :             aError = aTmpI.pClass->SetString( aTmpI, pStr );
     358             :         else
     359             :         {
     360         816 :             aError.Clear();
     361         816 :             DeletePos( rInst, pClassData->nEntries -1 );
     362         816 :             aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
     363         816 :             aError = aTmpI.pClass->GetString( aTmpI, &pTmpStr );
     364         816 :             if( aError.IsOk() )
     365         726 :                 aError = aTmpI.pClass->SetString( aTmpI, pStr );
     366             :         }
     367             : 
     368         876 :         if( aError.IsError() )
     369          90 :             DeletePos( rInst, pClassData->nEntries -1 );
     370             :     }
     371             :     else
     372           0 :         aError = ERR_UNKNOWN_METHOD;
     373             : 
     374         876 :     return aError;
     375             : }
     376             : 
     377        4462 : ERRTYPE RscBaseCont::SetNumber( const RSCINST & rInst, sal_Int32 lValue )
     378             : {
     379             :     RscBaseContInst * pClassData;
     380        4462 :     RSCINST aTmpI;
     381        4462 :     ERRTYPE aError;
     382             :     sal_Int32   lNumber;
     383             : 
     384        4462 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     385             : 
     386             :     // otherwise infinite recursion is possible
     387        4462 :     if( RSC_NOTYPE == pTypeClass->GetTypId() )
     388             :     {
     389        4462 :         aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
     390        4462 :         aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
     391             : 
     392        4462 :         if( aError.IsOk() )
     393        4462 :             aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
     394             :         else
     395             :         {
     396           0 :             aError.Clear();
     397           0 :             DeletePos( rInst, pClassData->nEntries -1 );
     398           0 :             aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
     399           0 :             aError = aTmpI.pClass->GetNumber( aTmpI, &lNumber );
     400           0 :             if( aError.IsOk() )
     401           0 :                 aError = aTmpI.pClass->SetNumber( aTmpI, lValue );
     402             :         }
     403        4462 :         if( aError.IsError() )
     404           0 :             DeletePos( rInst, pClassData->nEntries -1 );
     405             :     }
     406             :     else
     407           0 :         aError = ERR_UNKNOWN_METHOD;
     408             : 
     409        4462 :     return aError;
     410             : }
     411             : 
     412           0 : ERRTYPE RscBaseCont::SetBool( const RSCINST & rInst,
     413             :                               bool bValue)
     414             : {
     415             :     RscBaseContInst * pClassData;
     416           0 :     RSCINST aTmpI;
     417           0 :     ERRTYPE aError;
     418             :     bool    bBool;
     419             : 
     420           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     421             : 
     422             :     // otherwise infinite recursion is possible
     423           0 :     if( RSC_NOTYPE == pTypeClass->GetTypId() )
     424             :     {
     425           0 :         aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
     426           0 :         aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
     427             : 
     428           0 :         if( aError.IsOk() )
     429           0 :             aError = aTmpI.pClass->SetBool( aTmpI, bValue );
     430             :         else
     431             :         {
     432           0 :             aError.Clear();
     433           0 :             DeletePos( rInst, pClassData->nEntries -1 );
     434           0 :             aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
     435           0 :             aError = aTmpI.pClass->GetBool( aTmpI, &bBool );
     436           0 :             if( aError.IsOk() )
     437           0 :                 aError = aTmpI.pClass->SetBool( aTmpI, bValue );
     438             :         }
     439             : 
     440           0 :         if( aError.IsError() )
     441           0 :             DeletePos( rInst, pClassData->nEntries -1 );
     442             :     }
     443             :     else
     444           0 :         aError = ERR_UNKNOWN_METHOD;
     445             : 
     446           0 :     return aError;
     447             : }
     448             : 
     449           0 : ERRTYPE RscBaseCont::SetConst( const RSCINST & rInst,
     450             :                                Atom nValueId,
     451             :                                sal_Int32 lValue)
     452             : {
     453             :     RscBaseContInst * pClassData;
     454           0 :     RSCINST aTmpI;
     455           0 :     ERRTYPE aError;
     456             :     Atom    nConst;
     457             : 
     458           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     459             : 
     460             :     // otherwise infinite recursion is possible
     461           0 :     if( RSC_NOTYPE == pTypeClass->GetTypId() )
     462             :     {
     463           0 :         aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
     464           0 :         aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
     465             : 
     466           0 :         if( aError.IsOk() )
     467           0 :             aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
     468             :         else
     469             :         {
     470           0 :             aError.Clear();
     471           0 :             DeletePos( rInst, pClassData->nEntries -1 );
     472           0 :             aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
     473           0 :             aError = aTmpI.pClass->GetConst( aTmpI, &nConst );
     474           0 :             if( aError.IsOk() )
     475           0 :                 aError = aTmpI.pClass->SetConst( aTmpI, nValueId, lValue );
     476             :         }
     477             : 
     478           0 :         if( aError.IsError() )
     479           0 :             DeletePos( rInst, pClassData->nEntries -1 );
     480             :     }
     481             :     else
     482           0 :         aError = ERR_UNKNOWN_METHOD;
     483             : 
     484           0 :     return aError;
     485             : }
     486             : 
     487        5127 : ERRTYPE RscBaseCont::SetRef( const RSCINST & rInst, const RscId & rRefId )
     488             : {
     489             :     RscBaseContInst * pClassData;
     490        5127 :     RSCINST aTmpI;
     491        5127 :     ERRTYPE aError;
     492        5127 :     RscId   aId;
     493             : 
     494        5127 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     495             : 
     496             :     // otherwise infinite recursion is possible
     497        5127 :     if( RSC_NOTYPE == pTypeClass->GetTypId() )
     498             :     {
     499        5127 :         aError = GetElement( rInst, RscId(), pTypeClass, RSCINST(), &aTmpI );
     500        5127 :         aError = aTmpI.pClass->GetRef( aTmpI, &aId );
     501             : 
     502        5127 :         if( aError.IsOk() )
     503         665 :             aError = aTmpI.pClass->SetRef( aTmpI, rRefId );
     504             :         else
     505             :         {
     506        4462 :             aError.Clear();
     507        4462 :             DeletePos( rInst, pClassData->nEntries -1 );
     508        4462 :             aError = GetElement( rInst, RscId(), pTypeClass1, RSCINST(), &aTmpI );
     509        4462 :             aError = aTmpI.pClass->GetRef( aTmpI, &aId );
     510        4462 :             if( aError.IsOk() )
     511        4462 :                 aError = aTmpI.pClass->SetNumber( aTmpI, rRefId );
     512             :         }
     513             : 
     514        5127 :         if( aError.IsError() )
     515        4462 :             DeletePos( rInst, pClassData->nEntries -1 );
     516             :     }
     517             :     else
     518           0 :         aError = ERR_UNKNOWN_METHOD;
     519             : 
     520        5127 :     return aError;
     521             : }
     522             : 
     523           0 : bool RscBaseCont::IsConsistent( const RSCINST & rInst )
     524             : {
     525           0 :     sal_uInt32  i = 0;
     526             :     RscBaseContInst * pClassData;
     527             :     bool    bRet;
     528             : 
     529           0 :     bRet = RscTop::IsConsistent( rInst );
     530             : 
     531           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     532             : 
     533             :     // auf doppelten Id Testen und Reihenfolge beibehalten
     534             :     // Komplexitaet = n^2 / 2
     535           0 :     for( i = 0; i < pClassData->nEntries; i++ )
     536             :     {
     537           0 :         if( !bNoId )
     538             :         {
     539           0 :             if( (sal_Int32)pClassData->pEntries[ i ].aName > 0x7FFF ||
     540           0 :                 (sal_Int32)pClassData->pEntries[ i ].aName < 1 )
     541             :             {
     542           0 :                 bRet = false;
     543             :             }
     544           0 :             else if( SearchElePos( rInst, pClassData->pEntries[ i ].aName,
     545           0 :                                    pClassData->pEntries[ i ].aInst.pClass, i +1 ).IsInst() )
     546             :             {
     547           0 :                  bRet = false;
     548             :             }
     549             :         }
     550           0 :         if( ! pClassData->pEntries[ i ].aInst.pClass->
     551           0 :             IsConsistent( pClassData->pEntries[ i ].aInst ) )
     552             :         {
     553           0 :             bRet = false;
     554             :         }
     555             :     }
     556             : 
     557           0 :     return bRet;
     558             : }
     559             : 
     560         154 : void RscBaseCont::SetToDefault( const RSCINST & rInst )
     561             : {
     562         154 :     sal_uInt32  i = 0;
     563             :     RscBaseContInst * pClassData;
     564             : 
     565         154 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     566             : 
     567         154 :     for( i = 0; i < pClassData->nEntries; i++ )
     568             :     {
     569           0 :         pClassData->pEntries[ i ].aInst.pClass->
     570           0 :                   SetToDefault( pClassData->pEntries[ i ].aInst );
     571             :     }
     572             : 
     573         154 :     RscTop::SetToDefault( rInst );
     574         154 : }
     575             : 
     576         220 : bool RscBaseCont::IsDefault( const RSCINST & rInst )
     577             : {
     578         220 :     sal_uInt32  i = 0;
     579             :     RscBaseContInst * pClassData;
     580             : 
     581         220 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     582             : 
     583         220 :     if( !pClassData->bDflt )
     584         220 :         return false;
     585             : 
     586           0 :     for( i = 0; i < pClassData->nEntries; i++ )
     587             :     {
     588           0 :         if( ! pClassData->pEntries[ i ].aInst.pClass->
     589           0 :             IsDefault( pClassData->pEntries[ i ].aInst ) )
     590             :         {
     591           0 :             return( false );
     592             :         }
     593             :     }
     594             : 
     595           0 :     return RscTop::IsDefault( rInst );
     596             : }
     597             : 
     598        1858 : bool RscBaseCont::IsValueDefault( const RSCINST & rInst, CLASS_DATA pDef )
     599             : {
     600             :     RscBaseContInst * pClassData;
     601             : 
     602        1858 :     if( !RscTop::IsValueDefault( rInst, pDef ) )
     603           0 :         return false;
     604             : 
     605        1858 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     606             : 
     607        1858 :     if( pClassData->nEntries )
     608        1137 :         return false;
     609             :     else
     610         721 :         return true;
     611             : }
     612             : 
     613           0 : void RscBaseCont::Delete( const RSCINST & rInst, RscTop * pClass,
     614             :                           const RscId & rId )
     615             : {
     616           0 :     sal_uInt32  i = 0;
     617             :     RscBaseContInst * pClassData;
     618             : 
     619           0 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     620           0 :     if( !pClass )
     621           0 :         pClass = pTypeClass;
     622             : 
     623           0 :     for( i = 0; i < pClassData->nEntries; i++ )
     624             :     {
     625           0 :         if( pClassData->pEntries[ i ].aName == rId )
     626             :         {
     627           0 :             if( pClassData->pEntries[ i ].aInst.pClass == pClass || !pClass )
     628             :             {
     629           0 :                 DeletePos( rInst, i );
     630           0 :                 return;
     631             :             }
     632             :         }
     633             :     }
     634             : 
     635             : }
     636             : 
     637        9830 : void RscBaseCont::DeletePos( const RSCINST & rInst, sal_uInt32 nPos )
     638             : {
     639             :     RscBaseContInst *   pClassData;
     640             : 
     641        9830 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     642             : 
     643        9830 :     if( nPos < pClassData->nEntries )
     644             :     {
     645        9830 :         if( 1 == pClassData->nEntries )
     646        1480 :             DestroyElements( pClassData );
     647             :         else
     648             :         {
     649        8350 :             pClassData->pEntries[ nPos ].Destroy();
     650        8350 :             pClassData->nEntries--;
     651             : 
     652        8350 :             for (sal_uInt32 i = nPos; i < pClassData->nEntries; i++ )
     653           0 :                 pClassData->pEntries[ i ] = pClassData->pEntries[ i + 1 ];
     654             : 
     655             :         }
     656             :     }
     657        9830 : }
     658             : 
     659       22975 : void RscBaseCont::ContWriteSrc( const RSCINST & rInst, FILE * fOutput,
     660             :                                 RscTypCont * pTC, sal_uInt32 nTab,
     661             :                                 const char * pVarName )
     662             : {
     663       22975 :     sal_uInt32  i = 0, t = 0;
     664             :     RscBaseContInst * pClassData;
     665             : 
     666       22975 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     667             : 
     668       38889 :     for( i = 0; i < pClassData->nEntries; i++ )
     669             :     {
     670       51937 :         for( t = 0; t < nTab; t++ )
     671       36023 :             fputc( '\t', fOutput );
     672             : 
     673       47742 :         pClassData->pEntries[ i ].aInst.pClass->
     674       15914 :                   WriteSrcHeader( pClassData->pEntries[ i ].aInst,
     675             :                                   fOutput, pTC, nTab,
     676       63656 :                                   pClassData->pEntries[ i ].aName, pVarName );
     677       15914 :         fprintf( fOutput, ";\n" );
     678             :     }
     679       22975 : }
     680             : 
     681       39477 : ERRTYPE RscBaseCont::ContWriteRc( const RSCINST & rInst, RscWriteRc & rMem,
     682             :                                   RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
     683             : {
     684             :     RscBaseContInst * pClassData;
     685       39477 :     ERRTYPE       aError;
     686             : 
     687       39477 :     if( bExtra || bNoId )
     688             :     { // Nur Subresourcen schreiben, wenn bExtra == true
     689       34437 :         pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     690             : 
     691       50354 :         for (sal_uInt32 i = 0; i < pClassData->nEntries && aError.IsOk(); i++ )
     692             :         {
     693       79585 :             aError = pClassData->pEntries[ i ].aInst.pClass->
     694       15917 :                          WriteRcHeader( pClassData->pEntries[ i ].aInst,
     695             :                                         rMem, pTC,
     696       15917 :                                         pClassData->pEntries[ i ].aName,
     697       31834 :                                         nDeep, bExtra );
     698             :         }
     699             :     }
     700             : 
     701       39477 :     return aError ;
     702             : }
     703             : 
     704       21838 : void RscBaseCont::WriteSrc( const RSCINST & rInst, FILE * fOutput,
     705             :                             RscTypCont * pTC, sal_uInt32 nTab,
     706             :                             const char * pVarName )
     707             : {
     708       21838 :     RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
     709       21838 :     ContWriteSrc( rInst, fOutput, pTC, nTab, pVarName );
     710       21838 : }
     711             : 
     712       38752 : ERRTYPE RscBaseCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
     713             :                               RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
     714             : {
     715       38752 :     ERRTYPE       aError;
     716             : 
     717       38752 :     aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
     718       38752 :     if( aError.IsOk() )
     719       38752 :         aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
     720             : 
     721       38752 :     return aError;
     722             : }
     723             : 
     724        3771 : RscContWriteSrc::RscContWriteSrc( Atom nId, sal_uInt32 nTypeId,
     725             :                                   RscTop * pSuper, bool bNoIdent )
     726        3771 :     : RscBaseCont( nId, nTypeId, pSuper, bNoIdent )
     727             : {
     728        3771 : }
     729             : 
     730        1137 : void RscContWriteSrc::WriteSrc( const RSCINST & rInst, FILE * fOutput,
     731             :                                 RscTypCont * pTC, sal_uInt32 nTab,
     732             :                                 const char * pVarName )
     733             : {
     734             :     sal_uInt32  i;
     735             : 
     736        1137 :     RscTop::WriteSrc( rInst, fOutput, pTC, nTab, pVarName );
     737             : 
     738        1137 :     fprintf( fOutput, "\n" );
     739        3679 :     for( i = 0; i < nTab; i++ )
     740        2542 :         fputc( '\t', fOutput );
     741             : 
     742        1137 :     fprintf( fOutput, "{\n" );
     743             : 
     744        1137 :     ContWriteSrc( rInst, fOutput, pTC, nTab +1, pVarName );
     745             : 
     746        3679 :     for( i = 0; i < nTab; i++ )
     747        2542 :         fputc( '\t', fOutput );
     748             : 
     749        1137 :     fprintf( fOutput, "}" );
     750        1137 : }
     751             : 
     752        3352 : RscCont::RscCont( Atom nId, sal_uInt32 nTypeId, RscTop * pSuper, bool bNoIdent )
     753        3352 :     : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
     754             : {
     755        3352 : }
     756             : 
     757         725 : ERRTYPE RscCont::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
     758             :                                  RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
     759             : {
     760             :     RscBaseContInst * pClassData;
     761         725 :     ERRTYPE aError;
     762             : 
     763         725 :     aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
     764             : 
     765         725 :     pClassData = (RscBaseContInst *)(rInst.pData + nOffInstData);
     766             : 
     767         725 :     rMem.Put( pClassData->nEntries );
     768             : 
     769         725 :     if( aError.IsOk() )
     770         725 :         aError = ContWriteRc( rInst, rMem, pTC, nDeep, bExtra );
     771             : 
     772         725 :     return aError;
     773             : }
     774             : 
     775         419 : RscContExtraData::RscContExtraData( Atom nId, sal_uInt32 nTypeId,
     776             :                                     RscTop * pSuper, bool bNoIdent )
     777         419 :     : RscContWriteSrc( nId, nTypeId, pSuper, bNoIdent )
     778             : {
     779         419 : }
     780             : 
     781       21896 : ERRTYPE RscContExtraData::WriteRc( const RSCINST & rInst, RscWriteRc & rMem,
     782             :                                    RscTypCont * pTC, sal_uInt32 nDeep, bool bExtra )
     783             : {
     784       21896 :     ERRTYPE aError;
     785             : 
     786       21896 :     if( bExtra )
     787       16856 :         aError = RscContWriteSrc::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
     788             :     else
     789        5040 :         aError = RscTop::WriteRc( rInst, rMem, pTC, nDeep, bExtra );
     790             : 
     791       21896 :     return aError;
     792             : }
     793             : 
     794             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10