src/io/FIo_DataSetEnumeratorImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file        FIo_DataSetEnumeratorImpl.cpp
  20  * @brief       This is the implementation file for _DataSetEnumeratorImpl class.
  21  */
  22
  23 #include <stdio.h>
  24 #include <semaphore.h>
  25 #include <errno.h>
  26 #include <unique_ptr.h>
  27
  28 #include <FBaseInteger.h>
  29 #include <FBaseDouble.h>
  30 #include <FBaseString.h>
  31 #include <FBaseByteBuffer.h>
  32 #include <FBaseDateTime.h>
  33 #include <FBaseUtilStringUtil.h>
  34 #include <FBaseColLinkedList.h>
  35 #include <FBaseColArrayList.h>
  36 #include <FBaseColIEnumerator.h>
  37 #include <FBaseSysLog.h>
  38
  39 #include <FIoDbTypes.h>
  40 #include <FIo_DataSetEnumeratorImpl.h>
  41 #include <FIo_DataRowImpl.h>
  42
  43 using namespace std;
  44 using namespace Tizen::Base;
  45 using namespace Tizen::Base::Utility;
  46 using namespace Tizen::Base::Runtime;
  47 using namespace Tizen::System;
  48 using namespace Tizen::App;
  49 using namespace Tizen::Base::Collection;
  50
  51 namespace Tizen { namespace Io
  52 {
  53
  54 _DataSetEnumeratorImpl::_DataSetEnumeratorImpl(void)
  55         : __pDataSet(null)
  56         , __pColumnList(null)
  57         , __pCurrentRow(null)
  58         , __columnCount(0)
  59         , __rowCount(0)
  60         , __currentRowIndex(-1)
  61         , __dataSetDeleted(false)
  62 {
  63
  64 }
  65
  66 _DataSetEnumeratorImpl::~_DataSetEnumeratorImpl(void)
  67 {
  68         if (!__dataSetDeleted)
  69         {
  70                 __pEnumImplList->Remove(*this);
  71         }
  72 }
  73
  74 result
  75 _DataSetEnumeratorImpl::MoveNext(void)
  76 {
  77         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
  78                                 "The Object is not constructed.");
  79         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
  80                                 "The dataset is already been deleted.");
  81
  82         if (__currentRowIndex +1  == __rowCount)
  83                 return E_OUT_OF_RANGE;
  84
  85         ++__currentRowIndex;
  86         __pCurrentRow = static_cast<ArrayList*>(__pDataSet->GetAt(__currentRowIndex));
  87
  88         if (__pCurrentRow == null)
  89                 return E_INVALID_STATE;
  90
  91         return E_SUCCESS;
  92 }
  93
  94 result
  95 _DataSetEnumeratorImpl::MovePrevious(void)
  96 {
  97         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
  98                                 "The Object is not constructed.");
  99         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 100                                 "The dataset is already been deleted.");
 101
 102         if (__currentRowIndex == 0)
 103                 return E_OUT_OF_RANGE;
 104
 105         --__currentRowIndex;
 106         __pCurrentRow = static_cast<ArrayList*>(__pDataSet->GetAt(__currentRowIndex));
 107
 108         if (__pCurrentRow == null)
 109                 return E_INVALID_STATE;
 110
 111         return E_SUCCESS;
 112 }
 113
 114 result
 115 _DataSetEnumeratorImpl::MoveFirst(void)
 116 {
 117         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 118                                 "The Object is not constructed.");
 119         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 120                                 "The dataset is already been deleted.");
 121
 122         __currentRowIndex = 0;
 123         __pCurrentRow = static_cast<ArrayList*>(__pDataSet->GetAt(__currentRowIndex));
 124
 125         if (__pCurrentRow == null)
 126                 return E_INVALID_STATE;
 127
 128         return E_SUCCESS;
 129 }
 130
 131 result
 132 _DataSetEnumeratorImpl::MoveLast(void)
 133 {
 134         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 135                                 "The Object is not constructed.");
 136         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 137                                 "The dataset is already been deleted.");
 138
 139         __currentRowIndex = __rowCount -1;
 140         __pCurrentRow = static_cast<ArrayList*>(__pDataSet->GetAt(__currentRowIndex));
 141
 142         if (__pCurrentRow == null)
 143                 return E_INVALID_STATE;
 144
 145         return E_SUCCESS;
 146 }
 147
 148 result
 149 _DataSetEnumeratorImpl::Reset(void)
 150 {
 151         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 152                                 "The Object is not constructed.");
 153         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 154                                 "The dataset is already been deleted.");
 155
 156         __currentRowIndex = -1;
 157         __pCurrentRow = null;
 158
 159         return E_SUCCESS;
 160 }
 161
 162 result
 163 _DataSetEnumeratorImpl::GetIntAt(int columnIndex, int& value) const
 164 {
 165         result r = E_SUCCESS;
 166
 167         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 168                                 "The Object is not constructed.");
 169         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 170                                 "The dataset is already been deleted.");
 171         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 172                                 "Given column index is out of range.");
 173         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 174                                 "The method has tried to fetch the column data of a result set that is not activated.");
 175
 176         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 177         if (pDataItem)
 178         {
 179                 if (pDataItem->type != DB_COLUMNTYPE_INT)
 180                 {
 181                         r = E_TYPE_MISMATCH;
 182                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 183                         goto CATCH;
 184                 }
 185
 186                 value = pDataItem->intValue;
 187         }
 188         return E_SUCCESS;
 189
 190         CATCH:
 191                 return r;
 192 }
 193
 194 result
 195 _DataSetEnumeratorImpl::GetInt64At(int columnIndex, long long& value) const
 196 {
 197         result r = E_SUCCESS;
 198
 199         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 200                                 "The Object is not constructed.");
 201         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 202                                 "The dataset is already been deleted.");
 203         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 204                                 "Given column index is out of range.");
 205         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 206                                 "The method has tried to fetch the column data of a result set that is not activated.");
 207
 208         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 209         if (pDataItem)
 210         {
 211                 if (pDataItem->type != DB_COLUMNTYPE_INT64)
 212                 {
 213                         r = E_TYPE_MISMATCH;
 214                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 215                         goto CATCH;
 216                 }
 217
 218                 value = pDataItem->int64Value;
 219         }
 220         return E_SUCCESS;
 221
 222 CATCH:
 223         return r;
 224 }
 225
 226 result
 227 _DataSetEnumeratorImpl::GetDoubleAt(int columnIndex, double& value) const
 228 {
 229         result r = E_SUCCESS;
 230
 231         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 232                                 "The Object is not constructed.");
 233         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 234                                 "The dataset is already been deleted.");
 235         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 236                                 "Given column index is out of range.");
 237         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 238                                 "The method has tried to fetch the column data of a result set that is not activated.");
 239
 240         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 241         if (pDataItem)
 242         {
 243                 if (pDataItem->type != DB_COLUMNTYPE_DOUBLE)
 244                 {
 245                         r = E_TYPE_MISMATCH;
 246                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 247                         goto CATCH;
 248                 }
 249
 250                 value = pDataItem->doubleValue;
 251         }
 252         return E_SUCCESS;
 253
 254 CATCH:
 255         return r;
 256 }
 257
 258 result
 259 _DataSetEnumeratorImpl::GetStringAt(int columnIndex, String& value) const
 260 {
 261         result r = E_SUCCESS;
 262
 263         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 264                                 "The Object is not constructed.");
 265         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 266                                 "The dataset is already been deleted.");
 267         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 268                                 "Given column index is out of range.");
 269         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 270                                 "The method has tried to fetch the column data of a result set that is not activated.");
 271
 272         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 273         if (pDataItem)
 274         {
 275                 if (pDataItem->type != DB_COLUMNTYPE_TEXT)
 276                 {
 277                         r = E_TYPE_MISMATCH;
 278                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 279                         goto CATCH;
 280                 }
 281
 282                 value = *((String*)pDataItem->pObj);
 283         }
 284
 285 CATCH:
 286         return r;
 287 }
 288
 289 result
 290 _DataSetEnumeratorImpl::GetBlobAt(int columnIndex, ByteBuffer& value) const
 291 {
 292         result r = E_SUCCESS;
 293         ByteBuffer* pBuffer = null;
 294
 295         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 296                                 "The Object is not constructed.");
 297         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 298                                 "The dataset is already been deleted.");
 299         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 300                                 "Given column index is out of range.");
 301         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 302                                 "The method has tried to fetch the column data of a result set that is not activated.");
 303
 304         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 305         if (pDataItem)
 306         {
 307                 if (pDataItem->type != DB_COLUMNTYPE_BLOB)
 308                 {
 309                         r = E_TYPE_MISMATCH;
 310                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 311                         goto CATCH;
 312                 }
 313
 314                 pBuffer = (ByteBuffer*)pDataItem->pObj;
 315                 pBuffer->SetPosition(0);
 316                 r = value.CopyFrom(*pBuffer);
 317         }
 318
 319         // fall thru
 320 CATCH:
 321         return r;
 322 }
 323
 324 result
 325 _DataSetEnumeratorImpl::GetBlobAt(int columnIndex, void* buffer, int size) const
 326 {
 327         result r = E_SUCCESS;
 328         int blobLen = 0;
 329         ByteBuffer* pBuffer = null;
 330
 331         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 332                                 "The Object is not constructed.");
 333         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 334                                 "The dataset is already been deleted.");
 335         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 336                                 "Given column index is out of range.");
 337         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 338                                 "The method has tried to fetch the column data of a result set that is not activated.");
 339
 340         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 341         if (pDataItem)
 342         {
 343                 if (pDataItem->type != DB_COLUMNTYPE_BLOB)
 344                 {
 345                         r = E_TYPE_MISMATCH;
 346                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 347                         goto CATCH;
 348                 }
 349
 350                 pBuffer = (ByteBuffer*)pDataItem->pObj;
 351                 pBuffer->SetPosition(0);
 352                 blobLen = pBuffer->GetLimit();
 353                 memcpy(buffer, pBuffer->GetPointer(), (blobLen < size) ? blobLen : size);
 354         }
 355
 356         if (size < blobLen)
 357         {
 358                 r = E_OVERFLOW;
 359         }
 360
 361         // fall thru
 362 CATCH:
 363         return r;
 364 }
 365
 366 result
 367 _DataSetEnumeratorImpl::GetDateTimeAt(int columnIndex, DateTime& value) const
 368 {
 369         result r = E_SUCCESS;
 370         String* pStr = null;
 371
 372         SysTryReturnResult(NID_IO, __pDataSet != null, E_INVALID_STATE,
 373                                 "The Object is not constructed.");
 374         SysTryReturnResult(NID_IO, __dataSetDeleted != true, E_INVALID_STATE,
 375                                 "The dataset is already been deleted.");
 376         SysTryReturnResult(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, E_INVALID_ARG,
 377                                 "Given column index is out of range.");
 378         SysTryReturnResult(NID_IO, __pCurrentRow != null, E_INVALID_STATE,
 379                                 "The method has tried to fetch the column data of a result set that is not activated.");
 380
 381         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 382         if (pDataItem)
 383         {
 384                 if (pDataItem->type != DB_COLUMNTYPE_TEXT)
 385                 {
 386                         r = E_TYPE_MISMATCH;
 387                         SysLog(NID_IO, "[E_TYPE_MISMATCH] Trying to access column of different type.");
 388                         goto CATCH;
 389                 }
 390
 391                 pStr = (String*)pDataItem->pObj;
 392                 r = DateTime::Parse(*pStr, value);
 393         }
 394
 395         // fall thru
 396 CATCH:
 397         return r;
 398 }
 399
 400 int
 401 _DataSetEnumeratorImpl::GetColumnCount(void) const
 402 {
 403         SysTryReturn(NID_IO, __pDataSet != null, -1, E_INVALID_STATE,
 404                                 "[E_INVALID_STATE] The Object is not constructed.");
 405         SysTryReturn(NID_IO, __dataSetDeleted != true, -1, E_INVALID_STATE,
 406                                 "[E_INVALID_STATE] The dataset is already been deleted.");
 407
 408         return __columnCount;
 409 }
 410
 411 DbColumnType
 412 _DataSetEnumeratorImpl::GetColumnType(int columnIndex) const
 413 {
 414         DbColumnType type = DB_COLUMNTYPE_UNDEFINED;
 415
 416         SysTryReturn(NID_IO, __pDataSet != null, DB_COLUMNTYPE_UNDEFINED, E_INVALID_STATE,
 417                                 "[E_INVALID_STATE] The instance is not constructed.");
 418         SysTryReturn(NID_IO, __dataSetDeleted != true, DB_COLUMNTYPE_UNDEFINED, E_INVALID_STATE,
 419                                 "[E_INVALID_STATE] The dataset is already been deleted.");
 420         SysTryReturn(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, DB_COLUMNTYPE_UNDEFINED, E_INVALID_ARG,
 421                                 "[E_INVALID_ARG] Given column index is out of range.");
 422
 423         if (__pCurrentRow)
 424         {
 425                 _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 426                 if (!pDataItem)
 427                 {
 428                         SetLastResult(E_INVALID_STATE);
 429                         return DB_COLUMNTYPE_UNDEFINED;
 430                 }
 431
 432                 switch (pDataItem->type)
 433                 {
 434                 case DB_COLUMNTYPE_INT:
 435                 case DB_COLUMNTYPE_INT64:
 436                 case DB_COLUMNTYPE_DOUBLE:
 437                 case DB_COLUMNTYPE_TEXT:
 438                 case DB_COLUMNTYPE_BLOB:
 439                 case DB_COLUMNTYPE_NULL:
 440                         type = pDataItem->type;
 441                         break;
 442
 443                 default:
 444                         SetLastResult(E_INVALID_STATE);
 445                         break;
 446                 }
 447         }
 448
 449         return type;
 450 }
 451
 452 String
 453 _DataSetEnumeratorImpl::GetColumnName(int columnIndex) const
 454 {
 455         SysTryReturn(NID_IO, __pDataSet != null, null, E_INVALID_STATE,
 456                                 "[E_INVALID_STATE] The instance is not constructed.");
 457         SysTryReturn(NID_IO, __dataSetDeleted != true, null, E_INVALID_STATE,
 458                                 "[E_INVALID_STATE] The dataset is already been deleted.");
 459         SysTryReturn(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, null, E_INVALID_ARG,
 460                                 "[E_INVALID_ARG] Given column index is out of range.");
 461
 462
 463         String* pString = dynamic_cast <String *> (__pColumnList->GetAt(columnIndex));
 464
 465         if (!pString)
 466         {
 467                 SetLastResult(E_INVALID_STATE);
 468                 return String("");
 469         }
 470
 471         return String(pString->GetPointer());
 472 }
 473
 474 int
 475 _DataSetEnumeratorImpl::GetColumnSize(int columnIndex) const
 476 {
 477         int bytes = 0;
 478
 479         SysTryReturn(NID_IO, __pDataSet != null, -1, E_INVALID_STATE,
 480                 "[E_INVALID_STATE] The instance is not constructed.");
 481         SysTryReturn(NID_IO, __dataSetDeleted != true, -1, E_INVALID_STATE,
 482                                 "[E_INVALID_STATE] The dataset is already been deleted.");
 483         SysTryReturn(NID_IO, columnIndex >= 0 && columnIndex < __columnCount, -1, E_INVALID_ARG,
 484                                 "[E_INVALID_ARG] Given column index is out of range.");
 485         SysTryReturn(NID_IO, __pCurrentRow != null, -1, E_INVALID_STATE,
 486                                 "[E_INVALID_STATE] The method has tried to fetch the column data of a result set that is not activated.");
 487
 488         _DataItem* pDataItem = dynamic_cast < _DataItem* >(__pCurrentRow->GetAt(columnIndex));
 489         if (!pDataItem)
 490         {
 491                 SetLastResult(E_INVALID_STATE);
 492                 return 0;
 493         }
 494
 495         bytes = pDataItem->size;
 496         //SysLog(NID_IO, "Size is %d", bytes);
 497
 498         return bytes;
 499 }
 500
 501 _DataSetEnumeratorImpl*
 502 _DataSetEnumeratorImpl::GetInstance(DataSetEnumerator& dataSetEnumerator)
 503 {
 504         return dataSetEnumerator.__pDataSetEnumeratorImpl;
 505 }
 506
 507 const _DataSetEnumeratorImpl*
 508 _DataSetEnumeratorImpl::GetInstance(const DataSetEnumerator& dataSetEnumerator)
 509 {
 510         return dataSetEnumerator.__pDataSetEnumeratorImpl;
 511 }
 512
 513 DataSetEnumerator*
 514 _DataSetEnumeratorImpl::CreateDataSetEnumeratorInstanceN(void)
 515 {
 516         unique_ptr<DataSetEnumerator> pDataSetEnumerator(new (std::nothrow) DataSetEnumerator());
 517         SysTryReturn(NID_IO, pDataSetEnumerator != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 518         return pDataSetEnumerator.release();
 519 }
 520
 521 }} // Tizen::Io
 522