soltools/giparser/gi_list.cxx

   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: gi_list.cxx,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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_soltools.hxx"
  33
  34
  35 #include <gi_list.hxx>
  36
  37
  38 #include <gen_info.hxx>
  39
  40
  41
  42 const char C_cKeySeparator = '/';
  43
  44
  45 List_GenericInfo::List_GenericInfo()
  46 {
  47 }
  48
  49 List_GenericInfo::List_GenericInfo( const List_GenericInfo & i_rList )
  50     :   aChildren(i_rList.aChildren)
  51 {
  52 }
  53
  54 List_GenericInfo::~List_GenericInfo()
  55 {
  56 }
  57
  58 List_GenericInfo &
  59 List_GenericInfo::operator=( const List_GenericInfo & i_rList )
  60 {
  61     aChildren = i_rList.aChildren;
  62     return *this;
  63 }
  64
  65 const GenericInfo *
  66 List_GenericInfo::operator[]( KeyPath i_sKeyPath ) const
  67 {
  68     return const_cast< List_GenericInfo& >(*this)[i_sKeyPath];
  69 }
  70
  71 GenericInfo *
  72 List_GenericInfo::operator[]( KeyPath i_sKeyPath )
  73 {
  74     bool bExists = false;
  75     const char * sNextPathSegment = 0;
  76     sub_iterator it = lower_bound(bExists, sNextPathSegment, i_sKeyPath);
  77
  78     if ( bExists )
  79     {
  80         if ( sNextPathSegment == 0 )
  81             return (*it);
  82         else
  83             return (*it)->SubList()[sNextPathSegment];
  84     }
  85     else
  86     {
  87         return 0;
  88     }
  89 }
  90
  91 bool
  92 List_GenericInfo::InsertInfo( GenericInfo *       let_dpInfo,
  93                               bool                i_bOverwrite )
  94 {
  95     if ( let_dpInfo == 0 )
  96         return false;
  97
  98     bool bExists = false;
  99     const char * sNextPathSegment = 0;
 100     sub_iterator it = lower_bound(bExists, sNextPathSegment, let_dpInfo->Key() );
 101
 102     if ( ! bExists )
 103     {
 104         aChildren.insert( it, let_dpInfo );
 105     }
 106     else if ( i_bOverwrite )
 107     {
 108         delete (*it);
 109         (*it) = let_dpInfo;
 110     }
 111     else
 112     {
 113          delete let_dpInfo;
 114         return false;
 115     }
 116
 117     return true;
 118 }
 119
 120 bool
 121 List_GenericInfo::InsertInfoByPath( GenericInfo *       let_dpInfo,
 122                                     KeyPath             i_sKeyPath,
 123                                     bool                i_bCreatePath,
 124                                     bool                i_bOverwrite )
 125 {
 126     if ( let_dpInfo == 0 )
 127         return false;
 128
 129     if ( i_sKeyPath == 0 ? true : *i_sKeyPath == 0 )
 130          return InsertInfo(let_dpInfo, i_bOverwrite);
 131
 132     bool bExists = false;
 133     const char * sNextPathSegment = 0;
 134     sub_iterator it = lower_bound(bExists, sNextPathSegment, i_sKeyPath);
 135
 136     if ( bExists )
 137     {
 138         return (*it)->SubList().InsertInfoByPath(
 139                                     let_dpInfo,
 140                                     sNextPathSegment,
 141                                     i_bCreatePath,
 142                                     i_bOverwrite );
 143     }
 144     else if ( i_bCreatePath )
 145     {
 146         Simstr aKey( i_sKeyPath,
 147                      0,
 148                      sNextPathSegment -
 149                         ( *sNextPathSegment == 0 ? 0 : 1)
 150                         - i_sKeyPath );
 151
 152         GenericInfo * pNew = new GenericInfo(aKey);
 153         InsertInfo(pNew,false);
 154
 155         return pNew->SubList().InsertInfoByPath(
 156                                     let_dpInfo,
 157                                     sNextPathSegment,
 158                                     i_bCreatePath,
 159                                     i_bOverwrite );
 160     }
 161     else
 162     {
 163          delete let_dpInfo;
 164         return false;
 165     }
 166 }
 167
 168 GenericInfo *
 169 List_GenericInfo::ReleaseInfo( KeyPath i_sKeyPath )
 170 {
 171     bool bExists = false;
 172     const char * sNextPathSegment = 0;
 173     sub_iterator it = lower_bound(bExists, sNextPathSegment, i_sKeyPath );
 174
 175     if ( bExists )
 176     {
 177         if ( *sNextPathSegment == 0 )
 178             return (*it);
 179         else
 180             return (*it)->SubList().ReleaseInfo(sNextPathSegment);
 181     }
 182     else
 183     {
 184          return 0;
 185     }
 186 }
 187
 188 void
 189 List_GenericInfo::DeleteInfo( KeyPath i_sKeyPath )
 190 {
 191     bool bExists = false;
 192     const char * sNextPathSegment = 0;
 193     sub_iterator it = lower_bound(bExists, sNextPathSegment, i_sKeyPath );
 194
 195     if ( bExists )
 196     {
 197         if ( *sNextPathSegment == 0 )
 198         {
 199             aChildren.remove(it);
 200         }
 201         else
 202         {
 203             (*it)->SubList().DeleteInfo(sNextPathSegment);
 204         }
 205     }
 206 }
 207
 208 List_GenericInfo::sub_iterator
 209 List_GenericInfo::lower_bound( bool &              o_bExists,
 210                                const char * &      o_sNextPathSegment,
 211                                KeyPath             i_sKeyPath )
 212 {
 213     o_sNextPathSegment = strchr(i_sKeyPath, '/');
 214     Simstr sKey( i_sKeyPath, (o_sNextPathSegment == 0 ? strlen(i_sKeyPath) : o_sNextPathSegment++ - i_sKeyPath) );
 215     GenericInfo aSearch(sKey);
 216
 217     unsigned low = 0;
 218     unsigned high = aChildren.size();
 219
 220     for ( unsigned cur = high / 2; high > low; cur = (low + high) / 2 )
 221     {
 222         if ( *aChildren[cur] < aSearch )
 223         {
 224             low = cur+1;
 225         }
 226         else
 227         {
 228             high = cur;
 229         }
 230     }   // end for
 231
 232     o_bExists = low < aChildren.size()
 233                     ? !(aSearch < *aChildren[low] )
 234                     : false;
 235     return &aChildren[low];
 236 }
 237