libs/agg/agg_array.h

149         const T* data() const { return m_array; }
150               T* data()       { return m_array; }
160     // of a fixed size. The data is continous in memory
175         // Set new capacity. All data is lost, size is set to zero.
179         // Allocate n elements. All data is lost,
198         void deserialize(const int8u* data, unsigned byte_size);
205         const T* data() const { return m_array; }
206               T* data()       { return m_array; }
248                 T* data = pod_allocator<T>::allocate(new_size);
249                 memcpy(data, m_array, m_size * sizeof(T));
251                 m_array = data;
292     void pod_vector<T>::deserialize(const int8u* data, unsigned byte_size)
296         if(byte_size) memcpy(m_array, data, byte_size * sizeof(T));
317     // It doesn't reallocate memory but instead, uses blocks of data of size
318     // of (1 << S), that is, power of two. The data is NOT contiguous in memory,
365         template<class DataAccessor> void add_data(DataAccessor& data)
367             while(data.size())
369                 add(*data);
370                 ++data;
448         void deserialize(const int8u* data, unsigned byte_size);
450                          const int8u* data, unsigned byte_size);
453         void deserialize(ByteAccessor data)
456             unsigned elem_size = data.size() / sizeof(T);
463                     *ptr++ = *data;
464                     ++data;
471         void deserialize(unsigned start, const T& empty_val, ByteAccessor data)
478             unsigned elem_size = data.size() / sizeof(T);
493                     *ptr++ = *data;
494                     ++data;
730     void pod_bvector<T, S>::deserialize(const int8u* data, unsigned byte_size)
737             memcpy(ptr, data, sizeof(T));
739             data += sizeof(T);
748                                         const int8u* data, unsigned byte_size)
760                 memcpy(&((*this)[start + i]), data, sizeof(T));
765                 memcpy(ptr, data, sizeof(T));
768             data += sizeof(T);
774     // Allocator for arbitrary POD data. Most usable in different cache
785             int8u*   data;
797                     pod_allocator<int8u>::deallocate(blk->data, blk->size);
878             m_blocks[m_num_blocks].data =