include/comphelper/sequenceasvector.hxx

   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 #ifndef INCLUDED_COMPHELPER_SEQUENCEASVECTOR_HXX
  21 #define INCLUDED_COMPHELPER_SEQUENCEASVECTOR_HXX
  22
  23 #include <vector>
  24 #include <algorithm>
  25 #include <com/sun/star/uno/Sequence.hxx>
  26
  27 #include <com/sun/star/beans/IllegalTypeException.hpp>
  28
  29 /** This should not be used. Use the functions in
  30  * comphelper/vectortosequence.hxx
  31  * @deprecated
  32  */
  33
  34 namespace comphelper{
  35
  36
  37 /** @short  Implements a stl vector on top of any
  38             uno sequence.
  39
  40     @descr  That provides the possibility to modify
  41             sequences very easy ...
  42             Of course this can be useful only, if
  43             count of modifications is high, so copying
  44             of the sequence make sense!
  45  */
  46 template< class TElementType >
  47 class SequenceAsVector : public ::std::vector< TElementType >
  48 {
  49
  50     // types
  51
  52     public:
  53
  54
  55         /** @short  When inheriting from a template using typename is generally required when using
  56                     types from the base! */
  57         typedef typename ::std::vector< TElementType >::const_iterator const_iterator;
  58
  59
  60         /** @short  When inheriting from a template using typename is generally required when using
  61                     types from the base! */
  62         typedef typename ::std::vector< TElementType >::iterator iterator;
  63
  64
  65     // interface
  66     public:
  67
  68
  69         /** @short  default ctor, to create an empty list.
  70          */
  71         SequenceAsVector()
  72         {}
  73
  74
  75         /** @short  default dtor
  76          */
  77         ~SequenceAsVector()
  78         {}
  79
  80
  81         /** @short  creates a new vector with the given length.
  82
  83             @param  nLength
  84                     the number of elements for the new vector.
  85          */
  86         explicit SequenceAsVector(sal_Int32 nLength) :
  87             ::std::vector< TElementType >( static_cast< size_t >( nLength ) )
  88         {
  89         }
  90
  91
  92         /** @short  creates a new deque from the given uno sequence.
  93
  94             @param  lSource
  95                     contains the new items for this deque.
  96          */
  97         SequenceAsVector(const ::com::sun::star::uno::Sequence< TElementType >& lSource)
  98         {
  99             (*this) << lSource;
 100         }
 101
 102
 103         /** @short      creates a new instance from the given Any, which
 104                         of course must contain a valid sequence using the
 105                         right element type for every item.
 106
 107             @attention  If the given Any is an empty one
 108                         (if its set to VOID), no exception
 109                         is thrown. In such case this instance will
 110                         be created as an empty one too!
 111
 112             @param      aSource
 113                         this any must contain a suitable sequence. :-)
 114
 115             @throw      A com::sun::star::beans::IllegalTypeException
 116                         if an unsupported element inside this Any
 117                         is given. An empty Any reset this instance!
 118          */
 119         SequenceAsVector(const ::com::sun::star::uno::Any& aSource)
 120         {
 121             (*this) << aSource;
 122         }
 123
 124
 125         /** @short  fill this instance from the given uno sequence.
 126
 127             @param  lSource
 128                     contains the new items for this deque.
 129          */
 130         void operator<<(const ::com::sun::star::uno::Sequence< TElementType >& lSource)
 131         {
 132             this->clear();
 133
 134                   sal_Int32     c       = lSource.getLength();
 135             const TElementType* pSource = lSource.getConstArray();
 136
 137             for (sal_Int32 i=0; i<c; ++i)
 138                 this->push_back(pSource[i]);
 139         }
 140
 141
 142         /** @short      fill this instance from the given Any, which
 143                         of course must contain a valid sequence using the
 144                         right element type for every item.
 145
 146             @attention  If the given Any is an empty one
 147                         (if its set to VOID), no exception
 148                         is thrown. In such case this instance will
 149                         be created as an empty one too!
 150
 151             @param      aSource
 152                         this any must contain a suitable sequence. :-)
 153
 154             @throw      A com::sun::star::beans::IllegalTypeException
 155                         if an unsupported element inside this Any
 156                         is given. An empty Any reset this instance!
 157          */
 158         void operator<<(const ::com::sun::star::uno::Any& aSource)
 159         {
 160             // An empty Any reset this instance!
 161             if (!aSource.hasValue())
 162             {
 163                 this->clear();
 164                 return;
 165             }
 166
 167             ::com::sun::star::uno::Sequence< TElementType > lSource;
 168             if (!(aSource >>= lSource))
 169                 throw ::com::sun::star::beans::IllegalTypeException(
 170                         OUString("SequenceAsVector operator<<(Any) was called with an unsupported Any type."),
 171                         ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >());
 172
 173             (*this) << lSource;
 174         }
 175
 176
 177         /** @short  converts this instance to an uno sequence.
 178
 179             @param  lDestination
 180                     target sequence for converting.
 181          */
 182         void operator>>(::com::sun::star::uno::Sequence< TElementType >& lDestination) const
 183         {
 184             sal_Int32 c = static_cast<sal_Int32>(this->size());
 185             lDestination.realloc(c);
 186             TElementType* pDestination = lDestination.getArray();
 187
 188             sal_Int32 i = 0;
 189             for (typename std::vector<TElementType>::const_iterator pThis  = this->begin();
 190                                                                     pThis != this->end()  ;
 191                                                                     ++pThis           )
 192             {
 193                 pDestination[i] = *pThis;
 194                 ++i;
 195             }
 196         }
 197
 198
 199         /** @short  converts this instance to an uno any
 200                     which contains a suitable sequence
 201                     of items of this stl struct.
 202
 203             @param  aDestination
 204                     target any for converting.
 205          */
 206         void operator>>(::com::sun::star::uno::Any& aDestination) const
 207         {
 208             sal_Int32                                       c            = static_cast<sal_Int32>(this->size());
 209             ::com::sun::star::uno::Sequence< TElementType > lDestination(c);
 210             TElementType*                                   pDestination = lDestination.getArray();
 211
 212             sal_Int32 i = 0;
 213             for (typename std::vector<TElementType>::const_iterator pThis  = this->begin();
 214                                                                     pThis != this->end()  ;
 215                                                                     ++pThis           )
 216             {
 217                 pDestination[i] = *pThis;
 218                 ++i;
 219             }
 220
 221             aDestination <<= lDestination;
 222         }
 223
 224
 225         /** @short      converts this deque to a suitable uno
 226                         sequence which contains all items.
 227
 228             @attention  It return a const sequence to prevent
 229                         the outside code against using of this
 230                         return value as [in/]out parameter for
 231                         direct function calls!
 232                         Of course it can be casted to non const
 233                         ... but then it's a problem of the outside
 234                         code :-)
 235
 236             @return     A (const!) sequence, which contains all items of
 237                         this deque.
 238          */
 239         const ::com::sun::star::uno::Sequence< TElementType > getAsConstList() const
 240         {
 241             ::com::sun::star::uno::Sequence< TElementType > lDestination;
 242             (*this) >> lDestination;
 243             return lDestination;
 244         }
 245 };
 246
 247 } // namespace comphelper
 248
 249 #endif // INCLUDED_COMPHELPER_SEQUENCEASVECTOR_HXX
 250
 251 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */