dali/public-api/common/dali-vector.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/public-api/common/dali-vector.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <cstring> // for memcpy & memmove
  23
  24 namespace Dali
  25 {
  26 VectorBase::VectorBase()
  27 : mData(nullptr)
  28 {
  29 }
  30
  31 VectorBase::~VectorBase() = default;
  32
  33 VectorBase::SizeType VectorBase::Capacity() const
  34 {
  35   SizeType capacity = 0u;
  36   if(mData)
  37   {
  38     SizeType* metadata = reinterpret_cast<SizeType*>(mData);
  39     capacity           = *(metadata - 2u);
  40   }
  41   return capacity;
  42 }
  43
  44 void VectorBase::Release()
  45 {
  46   if(mData)
  47   {
  48     // adjust pointer to real beginning
  49     SizeType* metadata = reinterpret_cast<SizeType*>(mData);
  50
  51     delete[](metadata - 2u);
  52     mData = nullptr;
  53   }
  54 }
  55
  56 void VectorBase::SetCount(SizeType count)
  57 {
  58   // someone can call Resize( 0u ) before ever populating the vector
  59   if(mData)
  60   {
  61     SizeType* metadata = reinterpret_cast<SizeType*>(mData);
  62     *(metadata - 1u)   = count;
  63   }
  64 }
  65
  66 void VectorBase::Reserve(SizeType capacity, SizeType elementSize)
  67 {
  68   SizeType oldCapacity = Capacity();
  69   SizeType oldCount    = Count();
  70   if(capacity > oldCapacity)
  71   {
  72     const SizeType wholeAllocation = sizeof(SizeType) * 2u + capacity * elementSize;
  73     void*          wholeData       = reinterpret_cast<void*>(new uint8_t[wholeAllocation]);
  74     DALI_ASSERT_ALWAYS(wholeData && "VectorBase::Reserve - Memory allocation failed");
  75
  76 #if defined(DEBUG_ENABLED)
  77     // in debug build this will help identify a vector of uninitialized data
  78     memset(wholeData, 0xaa, wholeAllocation);
  79 #endif
  80     SizeType* metaData = reinterpret_cast<SizeType*>(wholeData);
  81     *metaData++        = capacity;
  82     *metaData++        = oldCount;
  83     if(mData)
  84     {
  85       // copy over the old data
  86       memcpy(metaData, mData, oldCount * elementSize);
  87       // release old buffer
  88       Release();
  89     }
  90     mData = metaData;
  91   }
  92 }
  93
  94 void VectorBase::Copy(const VectorBase& vector, SizeType elementSize)
  95 {
  96   // release old data
  97   Release();
  98   // reserve space based on source capacity
  99   const SizeType capacity = vector.Capacity();
 100   Reserve(capacity, elementSize);
 101   // copy over whole data
 102   const SizeType wholeAllocation = sizeof(SizeType) * 2u + capacity * elementSize;
 103   SizeType*      srcData         = reinterpret_cast<SizeType*>(vector.mData);
 104   SizeType*      dstData         = reinterpret_cast<SizeType*>(mData);
 105   memcpy(dstData - 2u, srcData - 2u, wholeAllocation);
 106 }
 107
 108 void VectorBase::Swap(VectorBase& vector)
 109 {
 110   // just swap the data pointers, metadata will swap as side effect
 111   std::swap(mData, vector.mData);
 112 }
 113
 114 void VectorBase::Erase(char* address, SizeType elementSize)
 115 {
 116   // erase can be called on an unallocated vector
 117   if(mData)
 118   {
 119     uint8_t*       startAddress  = reinterpret_cast<uint8_t*>(address) + elementSize;
 120     const uint8_t* endAddress    = reinterpret_cast<uint8_t*>(mData) + Count() * elementSize;
 121     SizeType       numberOfBytes = endAddress - startAddress;
 122     // addresses overlap so use memmove
 123     memmove(address, startAddress, numberOfBytes);
 124     SetCount(Count() - 1u);
 125   }
 126 }
 127
 128 char* VectorBase::Erase(char* first, char* last, SizeType elementSize)
 129 {
 130   char* next = nullptr;
 131
 132   if(mData)
 133   {
 134     uint8_t*       startAddress  = reinterpret_cast<uint8_t*>(last);
 135     const uint8_t* endAddress    = reinterpret_cast<uint8_t*>(mData) + Count() * elementSize;
 136     SizeType       numberOfBytes = endAddress - startAddress;
 137     // addresses overlap so use memmove
 138     memmove(first, startAddress, numberOfBytes);
 139     SetCount(Count() - (last - first) / elementSize);
 140
 141     next = first;
 142   }
 143
 144   return next;
 145 }
 146
 147 void VectorBase::CopyMemory(char* destination, const char* source, size_t numberOfBytes)
 148 {
 149   if(((source < destination) && (source + numberOfBytes > destination)) ||
 150      ((destination < source) && (destination + numberOfBytes > source)))
 151   {
 152     // If there is overlap, use memmove.
 153     memmove(destination, source, numberOfBytes);
 154   }
 155   else
 156   {
 157     // It's safe to use memcpy if there isn't overlap.
 158     memcpy(destination, source, numberOfBytes);
 159   }
 160 }
 161
 162 } // namespace Dali