framework/source/classes/converter.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: converter.cxx,v $
  10  * $Revision: 1.10 $
  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_framework.hxx"
  33 #include <classes/converter.hxx>
  34 #include <rtl/ustrbuf.hxx>
  35
  36 namespace framework{
  37
  38 //-----------------------------------------------------------------------------
  39 /**
  40  * pack every property item of source list into an any entry of destination list
  41  * Resulting list will have follow format then: "sequence< Any(PropertyValue) >".
  42  * If one item couldn't be converted it will be ignored - means target list can
  43  * be smaller then source list. Source list isn't changed anytime.
  44  *
  45  * algorithm:
  46  *      (a) reserve enough space on destination list for all possible entries of
  47  *          source list
  48  *      (b) try to pack every property of source into an any of destination list
  49  *          (b1) count successfully packed entries only
  50  *      (c) use this count of packed entries to resize destination list
  51  *          Because we getted enough space before - that will remove unused items
  52  *          of destination list at the end of it only.
  53  */
  54 css::uno::Sequence< css::uno::Any > Converter::convert_seqProp2seqAny( const css::uno::Sequence< css::beans::PropertyValue >& lSource )
  55 {
  56     sal_Int32 nCount = lSource.getLength();
  57     css::uno::Sequence< css::uno::Any > lDestination(nCount);
  58
  59     for (sal_Int32 nItem=0; nItem<nCount; ++nItem)
  60         lDestination[nItem]<<=lSource[nItem];
  61
  62     return lDestination;
  63 }
  64
  65 //-----------------------------------------------------------------------------
  66 /**
  67  * do the same like convert_seqProp2seqAny() before - but reverse.
  68  * It try to unpack PropertyValue items from given Any's.
  69  */
  70 css::uno::Sequence< css::beans::PropertyValue > Converter::convert_seqAny2seqProp( const css::uno::Sequence< css::uno::Any >& lSource )
  71 {
  72     sal_Int32 nCount = lSource.getLength();
  73     sal_Int32 nRealCount = 0;
  74     css::uno::Sequence< css::beans::PropertyValue > lDestination(nCount);
  75
  76     for (sal_Int32 nItem=0; nItem<nCount; ++nItem)
  77     {
  78         if (lSource[nItem]>>=lDestination[nItem])
  79             ++nRealCount;
  80     }
  81
  82     if (nRealCount!=nCount)
  83         lDestination.realloc(nRealCount);
  84
  85     return lDestination;
  86 }
  87
  88 //-----------------------------------------------------------------------------
  89 /**
  90  * converts a sequence of NamedValue to a sequence of PropertyValue.
  91  */
  92 css::uno::Sequence< css::beans::PropertyValue > Converter::convert_seqNamedVal2seqPropVal( const css::uno::Sequence< css::beans::NamedValue >& lSource )
  93 {
  94     sal_Int32 nCount = lSource.getLength();
  95     css::uno::Sequence< css::beans::PropertyValue > lDestination(nCount);
  96     for (sal_Int32 nItem=0; nItem<nCount; ++nItem)
  97     {
  98         lDestination[nItem].Name  = lSource[nItem].Name ;
  99         lDestination[nItem].Value = lSource[nItem].Value;
 100     }
 101     return lDestination;
 102 }
 103
 104 //-----------------------------------------------------------------------------
 105 /**
 106  * converts a sequence of PropertyValue to a sequence of NamedValue.
 107  */
 108 css::uno::Sequence< css::beans::NamedValue > Converter::convert_seqPropVal2seqNamedVal( const css::uno::Sequence< css::beans::PropertyValue >& lSource )
 109 {
 110     sal_Int32 nCount = lSource.getLength();
 111     css::uno::Sequence< css::beans::NamedValue > lDestination(nCount);
 112     for (sal_Int32 nItem=0; nItem<nCount; ++nItem)
 113     {
 114         lDestination[nItem].Name  = lSource[nItem].Name ;
 115         lDestination[nItem].Value = lSource[nItem].Value;
 116     }
 117     return lDestination;
 118 }
 119
 120 //-----------------------------------------------------------------------------
 121 /**
 122  * converts a sequence of unicode strings into a vector of such items
 123  */
 124 OUStringList Converter::convert_seqOUString2OUStringList( const css::uno::Sequence< ::rtl::OUString >& lSource )
 125 {
 126     OUStringList lDestination;
 127     sal_Int32 nCount = lSource.getLength();
 128
 129     for (sal_Int32 nItem=0; nItem<nCount; ++nItem )
 130     {
 131         lDestination.push_back(lSource[nItem]);
 132     }
 133
 134     return lDestination;
 135 }
 136
 137 //-----------------------------------------------------------------------------
 138 /**
 139  * converts a vector of unicode strings into a sequence of such items
 140  */
 141 css::uno::Sequence< ::rtl::OUString > Converter::convert_OUStringList2seqOUString( const OUStringList& lSource )
 142 {
 143     css::uno::Sequence< ::rtl::OUString > lDestination(lSource.size());
 144     sal_uInt32 nItem = 0;
 145     for (OUStringList::const_iterator pIterator=lSource.begin(); pIterator!=lSource.end(); ++pIterator)
 146     {
 147         lDestination[nItem] = *pIterator;
 148         ++nItem;
 149     }
 150     return lDestination;
 151 }
 152
 153 //-----------------------------------------------------------------------------
 154 /**
 155  * converts an unicode string hash to a sequence<PropertyValue>, where names and values match to key and values.
 156  */
 157 css::uno::Sequence< css::beans::PropertyValue > Converter::convert_OUStringHash2seqProp( const OUStringHash& lSource )
 158 {
 159     css::uno::Sequence< css::beans::PropertyValue > lDestination (lSource.size());
 160     css::beans::PropertyValue*                                          pDestination = lDestination.getArray();
 161     sal_Int32 nItem = 0;
 162     for (OUStringHash::const_iterator pItem=lSource.begin(); pItem!=lSource.end(); ++pItem)
 163     {
 164         pDestination[nItem].Name  =   pItem->first ;
 165         pDestination[nItem].Value <<= pItem->second;
 166         ++nItem;
 167     }
 168     return lDestination;
 169 }
 170
 171 //-----------------------------------------------------------------------------
 172 /**
 173  * converts a sequence<PropertyValue> to an unicode string hash, where keys and values match to names and values.
 174  */
 175 OUStringHash Converter::convert_seqProp2OUStringHash( const css::uno::Sequence< css::beans::PropertyValue >& lSource )
 176 {
 177     OUStringHash lDestination;
 178     sal_Int32                                            nCount  = lSource.getLength();
 179     const css::beans::PropertyValue* pSource = lSource.getConstArray();
 180     for (sal_Int32 nItem=0; nItem<nCount; ++nItem)
 181     {
 182         pSource[nItem].Value >>= lDestination[pSource[nItem].Name];
 183     }
 184     return lDestination;
 185 }
 186
 187 //-----------------------------------------------------------------------------
 188 /**
 189     @short  convert timestamp from String to tools::DateTime notation
 190     @descr  Format: "<day>.<month>.<year>/<hour>:<min>:<sec>"
 191             e.g.  : "1.11.2001/13:45:16"
 192
 193     @param  sString
 194                 timestamp in string notation
 195
 196     @return timestamp in DateTime notation
 197  */
 198 DateTime Converter::convert_String2DateTime( /*IN*/ const ::rtl::OUString& sSource )
 199 {
 200     DateTime  aStamp    ;
 201     sal_Int32 nIndex = 0;
 202
 203     sal_uInt16 nDay = (sal_uInt16)(sSource.getToken( 0, (sal_Unicode)'.', nIndex ).toInt32());
 204     if( nIndex>0 )
 205     {
 206         sal_uInt16 nMonth = (sal_uInt16)(sSource.getToken( 0, (sal_Unicode)'.', nIndex ).toInt32());
 207         if( nIndex>0 )
 208         {
 209             sal_uInt16 nYear = (sal_uInt16)(sSource.getToken( 0, (sal_Unicode)'/', nIndex ).toInt32());
 210             if( nIndex>0 )
 211             {
 212                 sal_uInt32 nHour = sSource.getToken( 0, (sal_Unicode)':', nIndex ).toInt32();
 213                 if( nIndex>0 )
 214                 {
 215                     sal_uInt32 nMin = sSource.getToken( 0, (sal_Unicode)':', nIndex ).toInt32();
 216                     if( nIndex>0 && nIndex<sSource.getLength() )
 217                     {
 218                         sal_uInt32 nSec = sSource.copy( nIndex, sSource.getLength()-nIndex ).toInt32();
 219
 220                         Date aDate( nDay , nMonth, nYear );
 221                         Time aTime( nHour, nMin  , nSec  );
 222                         aStamp = DateTime( aDate, aTime );
 223                     }
 224                 }
 225             }
 226         }
 227     }
 228     return aStamp;
 229 }
 230
 231 //-----------------------------------------------------------------------------
 232 /**
 233     @short  convert timestamp from DateTime to String notation
 234     @descr  Format: "<day>.<month>.<year>/<hour>:<min>:<sec>"
 235             e.g.  : "1.11.2001/13:45:16"
 236
 237     @param  aStamp
 238                 timestamp in DateTime notation
 239
 240     @return timestamp in String notation
 241  */
 242 ::rtl::OUString Converter::convert_DateTime2String( /*IN*/ const DateTime& aSource )
 243 {
 244     ::rtl::OUStringBuffer sBuffer(25);
 245
 246     sBuffer.append( (sal_Int32)aSource.GetDay()   );
 247     sBuffer.append( (sal_Unicode)'.'              );
 248     sBuffer.append( (sal_Int32)aSource.GetMonth() );
 249     sBuffer.append( (sal_Unicode)'.'              );
 250     sBuffer.append( (sal_Int32)aSource.GetYear()  );
 251     sBuffer.append( (sal_Unicode)'/'              );
 252     sBuffer.append( (sal_Int32)aSource.GetHour()  );
 253     sBuffer.append( (sal_Unicode)':'              );
 254     sBuffer.append( (sal_Int32)aSource.GetMin()   );
 255     sBuffer.append( (sal_Unicode)':'              );
 256     sBuffer.append( (sal_Int32)aSource.GetSec()   );
 257
 258     return sBuffer.makeStringAndClear();
 259 }
 260
 261 ::rtl::OUString Converter::convert_DateTime2ISO8601( const DateTime& aSource )
 262 {
 263     ::rtl::OUStringBuffer sBuffer(25);
 264
 265     sal_Int32 nYear  = aSource.GetYear();
 266     sal_Int32 nMonth = aSource.GetMonth();
 267     sal_Int32 nDay   = aSource.GetDay();
 268
 269     sal_Int32 nHour  = aSource.GetHour();
 270     sal_Int32 nMin   = aSource.GetMin();
 271     sal_Int32 nSec   = aSource.GetSec();
 272
 273     // write year formated as "YYYY"
 274     if (nYear<10)
 275         sBuffer.appendAscii("000");
 276     else
 277     if (nYear<100)
 278         sBuffer.appendAscii("00");
 279     else
 280     if (nYear<1000)
 281         sBuffer.appendAscii("0");
 282     sBuffer.append( (sal_Int32)nYear );
 283
 284     sBuffer.appendAscii("-");
 285     // write month formated as "MM"
 286     if (nMonth<10)
 287         sBuffer.appendAscii("0");
 288     sBuffer.append( (sal_Int32)nMonth );
 289
 290     sBuffer.appendAscii("-");
 291     // write day formated as "DD"
 292     if (nDay<10)
 293         sBuffer.appendAscii("0");
 294     sBuffer.append( (sal_Int32)nDay );
 295
 296     sBuffer.appendAscii("T");
 297     // write hours formated as "hh"
 298     if (nHour<10)
 299         sBuffer.appendAscii("0");
 300     sBuffer.append( (sal_Int32)nHour );
 301
 302     sBuffer.appendAscii(":");
 303     // write min formated as "mm"
 304     if (nMin<10)
 305         sBuffer.appendAscii("0");
 306     sBuffer.append( (sal_Int32)nMin );
 307
 308     sBuffer.appendAscii(":");
 309     // write sec formated as "ss"
 310     if (nSec<10)
 311         sBuffer.appendAscii("0");
 312     sBuffer.append( (sal_Int32)nSec );
 313
 314     sBuffer.appendAscii("Z");
 315
 316     return sBuffer.makeStringAndClear();
 317 }
 318
 319 }               //      namespace framework