connectivity/source/drivers/macab/MacabHeader.cxx

   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
  21 #include "MacabHeader.hxx"
  22 #include "MacabRecord.hxx"
  23 #include "macabutilities.hxx"
  24
  25 #include <math.h>
  26 #include <com/sun/star/sdbc/DataType.hpp>
  27 #include <connectivity/dbconversion.hxx>
  28
  29 using namespace connectivity::macab;
  30 using namespace com::sun::star::sdbc;
  31 using namespace com::sun::star::util;
  32 using namespace ::dbtools;
  33
  34
  35 MacabHeader::MacabHeader(const sal_Int32 _size, macabfield **_fields)
  36 {
  37     sal_Int32 i;
  38     size = _size;
  39     fields = new macabfield *[size];
  40     for(i = 0; i < size; i++)
  41     {
  42         if(_fields[i] == NULL)
  43         {
  44             fields[i] = NULL;
  45         }
  46         else
  47         {
  48             /* The constructor duplicates the macabfields it gets because they
  49              * are either deleted later or used for other purposes.
  50              */
  51             fields[i] = new macabfield;
  52             fields[i]->type = _fields[i]->type;
  53             fields[i]->value = _fields[i]->value;
  54             if (fields[i]->value)
  55                 CFRetain(fields[i]->value);
  56         }
  57     }
  58
  59 }
  60
  61
  62 MacabHeader::MacabHeader()
  63 {
  64     size = 0;
  65     fields = NULL;
  66 }
  67
  68
  69 MacabHeader::~MacabHeader()
  70 {
  71 }
  72
  73
  74 void MacabHeader::operator+= (const MacabHeader *r)
  75 {
  76     /* Add one MacabHeader to another. Anything not already in the header is
  77      * added to the end of it.
  78      */
  79     sal_Int32 rSize = r->getSize();
  80     if(rSize != 0) // If the new header does actually have fields
  81     {
  82         /* If our header is currently empty, just copy all of the fields from
  83          * the new header to this one.
  84          */
  85         if(size == 0)
  86         {
  87             sal_Int32 i;
  88             size = rSize;
  89             fields = new macabfield *[size];
  90             for(i = 0; i < size; i++)
  91             {
  92                 fields[i] = r->copy(i);
  93             }
  94         }
  95
  96         /* Otherwise, only add the duplicates. We do this with a two-pass
  97          * approach. First, find out how many fields to add, then reallocate
  98          * the size of the fields array and add the old ones at the end.
  99          * (More precisely, we create a _new_ fields array with the new length
 100          * allocated to it, then get all of the fields from the current
 101          * fields array to it, then copy the non-duplicates from the new
 102          * header to the end.)
 103          */
 104         else
 105         {
 106             sal_Int32 i;
 107             sal_Int32 numToAdd = 0, numAdded = 0;
 108             macabfield **newFields;
 109             for( i = 0; i < rSize; i++)
 110             {
 111                 if(!contains(r->get(i)))
 112                 {
 113                     numToAdd++;
 114                 }
 115             }
 116
 117             newFields = new macabfield *[size+numToAdd];
 118             for(i = 0; i < size; i++)
 119             {
 120                 newFields[i] = copy(i);
 121             }
 122
 123             for( i = 0; i < rSize; i++)
 124             {
 125                 if(!contains(r->get(i)))
 126                 {
 127                     newFields[size+numAdded] = r->copy(i);
 128                     numAdded++;
 129                     if(numAdded == numToAdd)
 130                         break;
 131                 }
 132             }
 133
 134             releaseFields();
 135             delete [] fields;
 136             size += numAdded;
 137             fields = newFields;
 138         }
 139     }
 140 }
 141
 142
 143 OUString MacabHeader::getString(const sal_Int32 i) const
 144 {
 145     OUString nRet;
 146
 147     if(i < size)
 148     {
 149         if(fields[i] == NULL || fields[i]->value == NULL || CFGetTypeID(fields[i]->value) != CFStringGetTypeID())
 150             return OUString();
 151         try
 152         {
 153             nRet = CFStringToOUString( (CFStringRef) fields[i]->value);
 154         }
 155         catch(...){ }
 156     }
 157
 158     return nRet;
 159 }
 160
 161
 162 void MacabHeader::sortRecord()
 163 {
 164     sortRecord(0,size);
 165 }
 166
 167
 168 macabfield **MacabHeader::sortRecord(const sal_Int32 _start, const sal_Int32 _length)
 169 {
 170     /* Sort using mergesort. Because it uses mergesort, it is recursive and
 171      * not in place (so it creates a new array at every step of the
 172      * recursion), so if you prefer to use a different sort, please feel
 173      * free to implement it.
 174      */
 175     macabfield** sorted = new macabfield *[_length];
 176     if(_length <= 2)
 177     {
 178         if(_length == 2)
 179         {
 180             if(compareFields(fields[_start], fields[_start+1]) > 0)
 181             {
 182                 sorted[0] = get(_start+1);
 183                 sorted[1] = get(_start);
 184             }
 185             else
 186             {
 187                 sorted[0] = get(_start);
 188                 sorted[1] = get(_start+1);
 189             }
 190         }
 191         else if(_length == 1)
 192         {
 193             sorted[0] = get(_start);
 194         }
 195     }
 196     else
 197     {
 198         sal_Int32 halfLength = floor(_length/2);
 199         sal_Int32 fp = 0, lp = 0;
 200         sal_Int32 i;
 201         macabfield **firstHalf = new macabfield *[halfLength];
 202         macabfield **lastHalf = new macabfield *[_length - halfLength];
 203
 204         firstHalf = sortRecord(_start, halfLength);
 205         lastHalf = sortRecord(_start+halfLength, _length-halfLength);
 206         for(i = 0; i < _length; i++)
 207         {
 208             if(compareFields(firstHalf[fp],lastHalf[lp]) < 0)
 209             {
 210                 sorted[i] = firstHalf[fp++];
 211                 if(fp == halfLength)
 212                 {
 213                     for( i++; i < _length; i++)
 214                     {
 215                         sorted[i] = lastHalf[lp++];
 216                     }
 217                     break;
 218                 }
 219             }
 220             else
 221             {
 222                 sorted[i] = lastHalf[lp++];
 223                 if(lp == _length - halfLength)
 224                 {
 225                     for( i++; i < _length; i++)
 226                     {
 227                         sorted[i] = firstHalf[fp++];
 228                     }
 229                     break;
 230                 }
 231             }
 232         }
 233         if(_length == size)
 234         {
 235             fields = sorted;
 236         }
 237     }
 238     return sorted;
 239 }
 240
 241 sal_Int32 MacabHeader::compareFields(const macabfield *_field1, const macabfield *_field2)
 242 {
 243     /* Comparing two fields in a MacabHeader is different than comparing two
 244      * fields in a MacabRecord. It starts in the same way (if one of the two
 245      * fields is NULL, it belongs after the other, so it is considered
 246      * "greater"). But, then, all headers are CFStrings, no matter what
 247      * type they claim to be (since they actually hold the expected type for
 248      * the records with that header). That being said, all we have to do is
 249      * the built-in CFStringCompare.
 250      */
 251     if(_field1 == _field2)
 252         return 0;
 253     if(_field1 == NULL)
 254         return 1;
 255     if(_field2 == NULL)
 256         return -1;
 257
 258     CFComparisonResult result = CFStringCompare(
 259         (CFStringRef) _field1->value,
 260         (CFStringRef) _field2->value,
 261         0); // 0 = no options (like ignore case)
 262
 263     return (sal_Int32) result;
 264 }
 265
 266
 267 sal_Int32 MacabHeader::getColumnNumber(const OUString& s) const
 268 {
 269     sal_Int32 i;
 270     for(i = 0; i < size; i++)
 271     {
 272         if(getString(i) == s)
 273             break;
 274     }
 275
 276     if(i == size)
 277         i = -1;
 278
 279     return i;
 280 }
 281
 282
 283 MacabHeader *MacabHeader::begin()
 284 {
 285     return this;
 286 }
 287
 288
 289 MacabHeader::iterator::iterator ()
 290 {
 291 }
 292
 293
 294 MacabHeader::iterator::~iterator ()
 295 {
 296 }
 297
 298 MacabHeader::iterator& MacabHeader::iterator::operator= (MacabHeader *_record)
 299 {
 300     id = 0;
 301     record = _record;
 302     return *this;
 303 }
 304
 305
 306 void MacabHeader::iterator::operator++ ()
 307 {
 308     id++;
 309 }
 310
 311
 312 sal_Bool MacabHeader::iterator::operator!= (const sal_Int32 i) const
 313 {
 314     return(id != i);
 315 }
 316
 317
 318 sal_Bool MacabHeader::iterator::operator== (const sal_Int32 i) const
 319 {
 320     return(id == i);
 321 }
 322
 323
 324 macabfield *MacabHeader::iterator::operator* () const
 325 {
 326     return record->get(id);
 327 }
 328
 329
 330 sal_Int32 MacabHeader::end() const
 331 {
 332     return size;
 333 }
 334
 335 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */