src/ui/effects/inc/renderer/system/FUiEffects_RendererSystemData.h

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
  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       FUiEffects_RendererSystemData.h
  20  * @brief      The Data class
  21  *
  22  */
  23
  24 #ifndef _FUI_EFFECTS_INTERNAL_RENDERER_SYSTEM_DATA_H_
  25 #define _FUI_EFFECTS_INTERNAL_RENDERER_SYSTEM_DATA_H_
  26
  27 #include <vector>
  28
  29 #include <renderer/system/FUiEffects_RendererSystemDataType.h>
  30
  31 namespace Tizen { namespace Ui { namespace Effects { namespace _Renderer { namespace System
  32 {
  33
  34 /**
  35  * @brief               This class represents the data
  36  */
  37 template<typename ITEM_TYPE = uint8>
  38 class Data
  39 {
  40 public:
  41         typedef ITEM_TYPE ItemType;
  42         typedef std::vector<ItemType> ListType;
  43
  44         typedef typename ListType::reference reference;
  45         typedef typename ListType::const_reference const_reference;
  46         typedef typename ListType::iterator iterator;
  47         typedef typename ListType::const_iterator const_iterator;
  48         typedef typename ListType::size_type size_type;
  49         typedef typename ListType::difference_type difference_type;
  50         typedef typename ListType::value_type value_type;
  51         typedef typename ListType::allocator_type allocator_type;
  52         typedef typename ListType::pointer pointer;
  53         typedef typename ListType::const_pointer const_pointer;
  54         typedef typename ListType::reverse_iterator reverse_iterator;
  55         typedef typename ListType::const_reverse_iterator const_reverse_iterator;
  56
  57 private:
  58         ListType __list;
  59
  60 public:
  61         Data(void);
  62         Data(const Data& data);
  63         explicit Data(size_type size, const ItemType value);
  64         explicit Data(size_type size);
  65
  66         template <class InputIterator>
  67         Data(InputIterator firstIterator, InputIterator lastIterator);
  68
  69         virtual ~Data(void);
  70
  71         Data& operator = (const Data& data);
  72         bool operator == (const Data& data) const;
  73         bool operator != (const Data& data) const;
  74
  75         iterator Begin(void);
  76         const_iterator Begin(void) const;
  77         iterator End(void);
  78         const_iterator End(void) const;
  79
  80         reverse_iterator Rbegin(void);
  81         const_reverse_iterator Rbegin(void) const;
  82         reverse_iterator Rend(void);
  83         const_reverse_iterator Rend(void) const;
  84
  85         size_type Size(void) const;
  86         size_type MaxSize(void) const;
  87         void Resize(size_type size, ItemType value);
  88         void Resize(size_type size);
  89         size_type Capacity(void) const;
  90         bool Empty(void) const;
  91         void Reserve(size_type size);
  92
  93         reference operator[](size_type position);
  94         const_reference operator[](size_type position) const;
  95         reference At(size_type position);
  96         const_reference At(size_type position) const;
  97         reference Front(void);
  98         const_reference Front(void) const;
  99         reference Back(void);
 100         const_reference Back(void) const;
 101
 102         template <class InputIterator>
 103         void Assign(InputIterator firstIterator, InputIterator lastIterator);
 104
 105         void Assign(size_type size, const ItemType value);
 106         void PushBack(const ItemType value);
 107         void PopBack(void);
 108         iterator Insert(iterator position, const ItemType value);
 109         void Insert(iterator position, size_type size, const ItemType value);
 110
 111         template <class InputIterator>
 112         void Insert(iterator position, InputIterator firstIterator, InputIterator lastIterator);
 113
 114         void Copy(const Data& sourceData, size_type sourcePosition, size_type size, size_type destinationPosition);
 115         void Copy(const void* pSourceData, size_type size, size_type destinationPosition);
 116
 117         void CopyTo(value_type* pDestination, size_type position, size_type size) const;
 118
 119         iterator Erase(iterator position);
 120         iterator Erase(iterator firstIterator, iterator lastIterator);
 121         void Swap(Data& data);
 122         void Clear(void);
 123
 124         allocator_type GetAllocator() const;
 125 };
 126
 127 template<typename ITEM_TYPE>
 128 template <class InputIterator>
 129 Data<ITEM_TYPE>::Data(InputIterator firstIterator, InputIterator lastIterator) : __list(firstIterator, lastIterator)
 130 {
 131
 132 }
 133
 134 template<typename ITEM_TYPE>
 135 template <class InputIterator>
 136 void Data<ITEM_TYPE>::Assign(InputIterator firstIterator, InputIterator lastIterator)
 137 {
 138         __list.assign(firstIterator, lastIterator);
 139 }
 140
 141 template<typename ITEM_TYPE>
 142 template <class InputIterator>
 143 void Data<ITEM_TYPE>::Insert(iterator position, InputIterator firstIterator, InputIterator lastIterator)
 144 {
 145         __list.insert(position, firstIterator, lastIterator);
 146 }
 147
 148 template<typename ITEM_TYPE>
 149 Data<ITEM_TYPE>::Data(void) : __list()
 150 {
 151
 152 }
 153
 154 template<typename ITEM_TYPE>
 155 Data<ITEM_TYPE>::Data(const Data& data) : __list(data.__list)
 156 {
 157
 158 }
 159
 160 template<typename ITEM_TYPE>
 161 Data<ITEM_TYPE>::Data(size_type size, const ItemType value ) : __list(size, value)
 162 {
 163
 164 }
 165
 166 template<typename ITEM_TYPE>
 167 Data<ITEM_TYPE>::Data(size_type size) : __list(size)
 168 {
 169
 170 }
 171
 172 template<typename ITEM_TYPE>
 173 Data<ITEM_TYPE>::~Data(void)
 174 {
 175
 176 }
 177
 178 template<typename ITEM_TYPE>
 179 Data<ITEM_TYPE>&
 180 Data<ITEM_TYPE>::operator = (const Data& data)
 181 {
 182         if (this != &data)
 183         {
 184                 __list = data.__list;
 185         }
 186         return* this;
 187 }
 188
 189 template<typename ITEM_TYPE>
 190 bool
 191 Data<ITEM_TYPE>::operator == (const Data<ITEM_TYPE>& data) const
 192 {
 193         return __list == data.__list;
 194 }
 195
 196 template<typename ITEM_TYPE>
 197 bool
 198 Data<ITEM_TYPE>::operator != (const Data<ITEM_TYPE>& data) const
 199 {
 200         return __list != data.__list;
 201 }
 202
 203 template<typename ITEM_TYPE>
 204 typename Data<ITEM_TYPE>::iterator
 205 Data<ITEM_TYPE>::Begin(void)
 206 {
 207         return __list.begin();
 208 }
 209
 210 template<typename ITEM_TYPE>
 211 typename Data<ITEM_TYPE>::const_iterator
 212 Data<ITEM_TYPE>::Begin(void) const
 213 {
 214         return __list.begin();
 215 }
 216
 217 template<typename ITEM_TYPE>
 218 typename Data<ITEM_TYPE>::iterator
 219 Data<ITEM_TYPE>::End(void)
 220 {
 221         return __list.end();
 222 }
 223
 224 template<typename ITEM_TYPE>
 225 typename Data<ITEM_TYPE>::const_iterator
 226 Data<ITEM_TYPE>::End(void) const
 227 {
 228         return __list.end();
 229 }
 230
 231 template<typename ITEM_TYPE>
 232 typename Data<ITEM_TYPE>::reverse_iterator
 233 Data<ITEM_TYPE>::Rbegin(void)
 234 {
 235         return __list.rbegin();
 236 }
 237
 238 template<typename ITEM_TYPE>
 239 typename Data<ITEM_TYPE>::const_reverse_iterator
 240 Data<ITEM_TYPE>::Rbegin(void) const
 241 {
 242         return __list.rbegin();
 243 }
 244
 245 template<typename ITEM_TYPE>
 246 typename Data<ITEM_TYPE>::reverse_iterator
 247 Data<ITEM_TYPE>::Rend(void)
 248 {
 249         return __list.rend();
 250 }
 251
 252 template<typename ITEM_TYPE>
 253 typename Data<ITEM_TYPE>::const_reverse_iterator
 254 Data<ITEM_TYPE>::Rend(void) const
 255 {
 256         return __list.rend();
 257 }
 258
 259 template<typename ITEM_TYPE>
 260 typename Data<ITEM_TYPE>::size_type
 261 Data<ITEM_TYPE>::Size(void) const
 262 {
 263         return __list.size();
 264 }
 265
 266 template<typename ITEM_TYPE>
 267 typename Data<ITEM_TYPE>::size_type
 268 Data<ITEM_TYPE>::MaxSize(void) const
 269 {
 270         return __list.max_size();
 271 }
 272
 273 template<typename ITEM_TYPE>
 274 void
 275 Data<ITEM_TYPE>::Resize(size_type size, ItemType value)
 276 {
 277         __list.resize(size, value);
 278 }
 279
 280 template<typename ITEM_TYPE>
 281 void
 282 Data<ITEM_TYPE>::Resize(size_type size)
 283 {
 284         __list.resize(size);
 285 }
 286
 287 template<typename ITEM_TYPE>
 288 typename Data<ITEM_TYPE>::size_type
 289 Data<ITEM_TYPE>::Capacity(void) const
 290 {
 291         return __list.capacity();
 292 }
 293
 294 template<typename ITEM_TYPE>
 295 bool
 296 Data<ITEM_TYPE>::Empty(void) const
 297 {
 298         return __list.empty();
 299 }
 300
 301 template<typename ITEM_TYPE>
 302 void
 303 Data<ITEM_TYPE>::Reserve(size_type size)
 304 {
 305         __list.reserve(size);
 306 }
 307
 308 template<typename ITEM_TYPE>
 309 typename Data<ITEM_TYPE>::reference
 310 Data<ITEM_TYPE>::operator[](size_type position)
 311 {
 312         return __list[position];
 313 }
 314
 315 template<typename ITEM_TYPE>
 316 typename Data<ITEM_TYPE>::const_reference
 317 Data<ITEM_TYPE>::operator[](size_type position) const
 318 {
 319         return __list[position];
 320 }
 321
 322 template<typename ITEM_TYPE>
 323 typename Data<ITEM_TYPE>::const_reference
 324 Data<ITEM_TYPE>::At(size_type position) const
 325 {
 326         return __list.at(position);
 327 }
 328
 329 template<typename ITEM_TYPE>
 330 typename Data<ITEM_TYPE>::reference
 331 Data<ITEM_TYPE>::At(size_type position)
 332 {
 333         return __list[position];
 334 }
 335
 336 template<typename ITEM_TYPE>
 337 typename Data<ITEM_TYPE>::reference
 338 Data<ITEM_TYPE>::Front(void)
 339 {
 340         return __list.front();
 341 }
 342
 343 template<typename ITEM_TYPE>
 344 typename Data<ITEM_TYPE>::const_reference
 345 Data<ITEM_TYPE>::Front(void) const
 346 {
 347         return __list.front();
 348 }
 349
 350 template<typename ITEM_TYPE>
 351 typename Data<ITEM_TYPE>::reference
 352 Data<ITEM_TYPE>::Back(void)
 353 {
 354         return __list.back();
 355 }
 356
 357 template<typename ITEM_TYPE>
 358 typename Data<ITEM_TYPE>::const_reference
 359 Data<ITEM_TYPE>::Back(void) const
 360 {
 361         return __list.back();
 362 }
 363
 364 template<typename ITEM_TYPE>
 365 void
 366 Data<ITEM_TYPE>::Assign(size_type size, const ItemType value)
 367 {
 368         __list.assign(size, value);
 369 }
 370
 371 template<typename ITEM_TYPE>
 372 void
 373 Data<ITEM_TYPE>::PushBack(const ItemType value)
 374 {
 375         __list.push_back(value);
 376 }
 377
 378 template<typename ITEM_TYPE>
 379 void
 380 Data<ITEM_TYPE>::PopBack(void)
 381 {
 382         __list.pop_back();
 383 }
 384
 385 template<typename ITEM_TYPE>
 386 typename Data<ITEM_TYPE>::iterator
 387 Data<ITEM_TYPE>::Insert(iterator position, const ItemType value)
 388 {
 389         return __list.insert(position, value);
 390 }
 391
 392 template<typename ITEM_TYPE>
 393 void
 394 Data<ITEM_TYPE>::Insert(iterator position, size_type size, const ItemType value)
 395 {
 396         __list.insert(position, size, value);
 397 }
 398
 399 template<typename ITEM_TYPE>
 400 void
 401 Data<ITEM_TYPE>::Copy(const Data& sourceData, size_type sourcePosition, size_type size, size_type destinationPosition)
 402 {
 403         memcpy(&(operator[](destinationPosition)),& sourceData[sourcePosition], size);
 404 }
 405
 406 template<typename ITEM_TYPE>
 407 void
 408 Data<ITEM_TYPE>::Copy(const void* pSourceData, size_type size, size_type destinationPosition)
 409 {
 410         memcpy(&(operator[](destinationPosition)), pSourceData, size);
 411 }
 412
 413 template<typename ITEM_TYPE>
 414 void
 415 Data<ITEM_TYPE>::CopyTo(value_type* pDestination, size_type position, size_type size) const
 416 {
 417         memcpy(pDestination,& __list[position], size);
 418 }
 419
 420 template<typename ITEM_TYPE>
 421 typename Data<ITEM_TYPE>::iterator
 422 Data<ITEM_TYPE>::Erase(iterator position)
 423 {
 424         return __list.erase(position);
 425 }
 426
 427 template<typename ITEM_TYPE>
 428 typename Data<ITEM_TYPE>::iterator
 429 Data<ITEM_TYPE>::Erase(iterator firstIterator, iterator fastIterator)
 430 {
 431         return __list.erase(firstIterator, fastIterator);
 432 }
 433
 434 template<typename ITEM_TYPE>
 435 void
 436 Data<ITEM_TYPE>::Swap(Data& data)
 437 {
 438         __list.swap(data.__list);
 439 }
 440
 441 template<typename ITEM_TYPE>
 442 void
 443 Data<ITEM_TYPE>::Clear(void)
 444 {
 445         __list.clear();
 446 }
 447
 448 template<typename ITEM_TYPE>
 449 typename Data<ITEM_TYPE>::allocator_type
 450 Data<ITEM_TYPE>::GetAllocator(void) const
 451 {
 452         return __list.get_allocator();
 453 }
 454
 455
 456
 457 }}}}} //Tizen::Ui::Effects::_Renderer::System
 458
 459 #endif //_FUI_EFFECTS_INTERNAL_RENDERER_SYSTEM_DATA_H_