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

   1 /*
   2  * Copyright (c) 2021 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::Replace(void* newData)
  57 {
  58   if(mData)
  59   {
  60     // adjust pointer to real beginning
  61     SizeType* metadata = reinterpret_cast<SizeType*>(mData);
  62
  63     // Cause timming issue, we set new data before metadata delete.
  64     mData = newData;
  65
  66     // delete metadata address after mData setup safety.
  67     delete[](metadata - 2u);
  68   }
  69   else
  70   {
  71     // mData was nullptr. Just copy data address
  72     mData = newData;
  73   }
  74 }
  75
  76 void VectorBase::SetCount(SizeType count)
  77 {
  78   // someone can call Resize( 0u ) before ever populating the vector
  79   if(mData)
  80   {
  81     SizeType* metadata = reinterpret_cast<SizeType*>(mData);
  82     *(metadata - 1u)   = count;
  83   }
  84 }
  85
  86 void VectorBase::Reserve(SizeType capacity, SizeType elementSize)
  87 {
  88   SizeType oldCapacity = Capacity();
  89   SizeType oldCount    = Count();
  90   if(capacity > oldCapacity)
  91   {
  92     const SizeType wholeAllocation = sizeof(SizeType) * 2u + capacity * elementSize;
  93     void*          wholeData       = reinterpret_cast<void*>(new uint8_t[wholeAllocation]);
  94     DALI_ASSERT_ALWAYS(wholeData && "VectorBase::Reserve - Memory allocation failed");
  95
  96 #if defined(DEBUG_ENABLED)
  97     // in debug build this will help identify a vector of uninitialized data
  98     memset(wholeData, 0xaa, wholeAllocation);
  99 #endif
 100     SizeType* metaData = reinterpret_cast<SizeType*>(wholeData);
 101     *metaData++        = capacity;
 102     *metaData++        = oldCount;
 103     if(mData)
 104     {
 105       // copy over the old data
 106       memcpy(metaData, mData, oldCount * elementSize);
 107     }
 108     // release old buffer and set new data as mData
 109     Replace(reinterpret_cast<void*>(metaData));
 110   }
 111 }
 112
 113 void VectorBase::Copy(const VectorBase& vector, SizeType elementSize)
 114 {
 115   // release old data
 116   Release();
 117   // reserve space based on source capacity
 118   const SizeType capacity = vector.Capacity();
 119   Reserve(capacity, elementSize);
 120   // copy over whole data
 121   const SizeType wholeAllocation = sizeof(SizeType) * 2u + capacity * elementSize;
 122   SizeType*      srcData         = reinterpret_cast<SizeType*>(vector.mData);
 123   SizeType*      dstData         = reinterpret_cast<SizeType*>(mData);
 124   memcpy(dstData - 2u, srcData - 2u, wholeAllocation);
 125 }
 126
 127 void VectorBase::Swap(VectorBase& vector)
 128 {
 129   // just swap the data pointers, metadata will swap as side effect
 130   std::swap(mData, vector.mData);
 131 }
 132
 133 void VectorBase::Erase(char* address, SizeType elementSize)
 134 {
 135   // erase can be called on an unallocated vector
 136   if(mData)
 137   {
 138     uint8_t*       startAddress  = reinterpret_cast<uint8_t*>(address) + elementSize;
 139     const uint8_t* endAddress    = reinterpret_cast<uint8_t*>(mData) + Count() * elementSize;
 140     SizeType       numberOfBytes = endAddress - startAddress;
 141     // addresses overlap so use memmove
 142     memmove(address, startAddress, numberOfBytes);
 143     SetCount(Count() - 1u);
 144   }
 145 }
 146
 147 char* VectorBase::Erase(char* first, char* last, SizeType elementSize)
 148 {
 149   char* next = nullptr;
 150
 151   if(mData)
 152   {
 153     uint8_t*       startAddress  = reinterpret_cast<uint8_t*>(last);
 154     const uint8_t* endAddress    = reinterpret_cast<uint8_t*>(mData) + Count() * elementSize;
 155     SizeType       numberOfBytes = endAddress - startAddress;
 156     // addresses overlap so use memmove
 157     memmove(first, startAddress, numberOfBytes);
 158     SetCount(Count() - (last - first) / elementSize);
 159
 160     next = first;
 161   }
 162
 163   return next;
 164 }
 165
 166 void VectorBase::CopyMemory(char* destination, const char* source, size_t numberOfBytes)
 167 {
 168   if(((source < destination) && (source + numberOfBytes > destination)) ||
 169      ((destination < source) && (destination + numberOfBytes > source)))
 170   {
 171     // If there is overlap, use memmove.
 172     memmove(destination, source, numberOfBytes);
 173   }
 174   else
 175   {
 176     // It's safe to use memcpy if there isn't overlap.
 177     memcpy(destination, source, numberOfBytes);
 178   }
 179 }
 180
 181 } // namespace Dali