Merge changes from the witness.
castano
12 years ago
parent
343d6e1450
commit
327f344bd0
@ -0,0 +1,383 @@
|
||||
// This code is in the public domain -- Ignacio Castaño <castano@gmail.com>
|
||||
|
||||
#pragma once
|
||||
#ifndef NV_CORE_ARRAY_INL
|
||||
#define NV_CORE_ARRAY_INL
|
||||
|
||||
#include "Array.h"
|
||||
|
||||
#include "Stream.h"
|
||||
#include "Utils.h" // swap
|
||||
|
||||
#include <string.h> // memmove
|
||||
#include <new> // for placement new
|
||||
|
||||
|
||||
|
||||
namespace nv
|
||||
{
|
||||
|
||||
// Push an element at the end of the vector.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::push_back( const T & val )
|
||||
{
|
||||
#if 1
|
||||
nvDebugCheck(&val < m_buffer || &val > m_buffer+m_size);
|
||||
|
||||
uint old_size = m_size;
|
||||
uint new_size = m_size + 1;
|
||||
|
||||
setArraySize(new_size);
|
||||
|
||||
construct_range(m_buffer, new_size, old_size, val);
|
||||
#else
|
||||
uint new_size = m_size + 1;
|
||||
|
||||
if (new_size > m_capacity)
|
||||
{
|
||||
// @@ Is there any way to avoid this copy?
|
||||
// @@ Can we create a copy without side effects? Ie. without calls to constructor/destructor. Use alloca + memcpy?
|
||||
// @@ Assert instead of copy?
|
||||
const T copy(val); // create a copy in case value is inside of this array.
|
||||
|
||||
setArraySize(new_size);
|
||||
|
||||
new (m_buffer+new_size-1) T(copy);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_size = new_size;
|
||||
new(m_buffer+new_size-1) T(val);
|
||||
}
|
||||
#endif // 0/1
|
||||
}
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::pushBack( const T & val )
|
||||
{
|
||||
push_back(val);
|
||||
}
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::append( const T & val )
|
||||
{
|
||||
push_back(val);
|
||||
}
|
||||
|
||||
// Qt like push operator.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE Array<T> & Array<T>::operator<< ( T & t )
|
||||
{
|
||||
push_back(t);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Pop the element at the end of the vector.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::pop_back()
|
||||
{
|
||||
nvDebugCheck( m_size > 0 );
|
||||
resize( m_size - 1 );
|
||||
}
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::popBack()
|
||||
{
|
||||
pop_back();
|
||||
}
|
||||
|
||||
// Get back element.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE const T & Array<T>::back() const
|
||||
{
|
||||
nvDebugCheck( m_size > 0 );
|
||||
return m_buffer[m_size-1];
|
||||
}
|
||||
|
||||
// Get back element.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE T & Array<T>::back()
|
||||
{
|
||||
nvDebugCheck( m_size > 0 );
|
||||
return m_buffer[m_size-1];
|
||||
}
|
||||
|
||||
// Get front element.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE const T & Array<T>::front() const
|
||||
{
|
||||
nvDebugCheck( m_size > 0 );
|
||||
return m_buffer[0];
|
||||
}
|
||||
|
||||
// Get front element.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE T & Array<T>::front()
|
||||
{
|
||||
nvDebugCheck( m_size > 0 );
|
||||
return m_buffer[0];
|
||||
}
|
||||
|
||||
// Check if the given element is contained in the array.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE bool Array<T>::contains(const T & e) const
|
||||
{
|
||||
return find(e, NULL);
|
||||
}
|
||||
|
||||
// Return true if element found.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE bool Array<T>::find(const T & element, uint * indexPtr) const
|
||||
{
|
||||
return find(element, 0, m_size, indexPtr);
|
||||
}
|
||||
|
||||
// Return true if element found within the given range.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE bool Array<T>::find(const T & element, uint begin, uint end, uint * indexPtr) const
|
||||
{
|
||||
return ::nv::find(element, m_buffer, begin, end, indexPtr);
|
||||
}
|
||||
|
||||
|
||||
// Remove the element at the given index. This is an expensive operation!
|
||||
template <typename T>
|
||||
void Array<T>::removeAt(uint index)
|
||||
{
|
||||
nvDebugCheck(index >= 0 && index < m_size);
|
||||
|
||||
if (m_size == 1) {
|
||||
clear();
|
||||
}
|
||||
else {
|
||||
m_buffer[index].~T();
|
||||
|
||||
memmove(m_buffer+index, m_buffer+index+1, sizeof(T) * (m_size - 1 - index));
|
||||
m_size--;
|
||||
}
|
||||
}
|
||||
|
||||
// Remove the first instance of the given element.
|
||||
template <typename T>
|
||||
bool Array<T>::remove(const T & element)
|
||||
{
|
||||
uint index;
|
||||
if (find(element, &index)) {
|
||||
removeAt(index);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Insert the given element at the given index shifting all the elements up.
|
||||
template <typename T>
|
||||
void Array<T>::insertAt(uint index, const T & val/*=T()*/)
|
||||
{
|
||||
nvDebugCheck( index >= 0 && index <= m_size );
|
||||
|
||||
setArraySize(m_size + 1);
|
||||
|
||||
if (index < m_size - 1) {
|
||||
memmove(m_buffer+index+1, m_buffer+index, sizeof(T) * (m_size - 1 - index));
|
||||
}
|
||||
|
||||
// Copy-construct into the newly opened slot.
|
||||
new(m_buffer+index) T(val);
|
||||
}
|
||||
|
||||
// Append the given data to our vector.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::append(const Array<T> & other)
|
||||
{
|
||||
append(other.m_buffer, other.m_size);
|
||||
}
|
||||
|
||||
// Append the given data to our vector.
|
||||
template <typename T>
|
||||
void Array<T>::append(const T other[], uint count)
|
||||
{
|
||||
if (count > 0) {
|
||||
const uint old_size = m_size;
|
||||
|
||||
setArraySize(m_size + count);
|
||||
|
||||
for (uint i = 0; i < count; i++ ) {
|
||||
new(m_buffer + old_size + i) T(other[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Remove the given element by replacing it with the last one.
|
||||
template <typename T>
|
||||
void Array<T>::replaceWithLast(uint index)
|
||||
{
|
||||
nvDebugCheck( index < m_size );
|
||||
nv::swap(m_buffer[index], back());
|
||||
(m_buffer+m_size-1)->~T();
|
||||
m_size--;
|
||||
}
|
||||
|
||||
// Resize the vector preserving existing elements.
|
||||
template <typename T>
|
||||
void Array<T>::resize(uint new_size)
|
||||
{
|
||||
uint old_size = m_size;
|
||||
|
||||
// Destruct old elements (if we're shrinking).
|
||||
destroy_range(m_buffer, new_size, old_size);
|
||||
|
||||
setArraySize(new_size);
|
||||
|
||||
// Call default constructors
|
||||
construct_range(m_buffer, new_size, old_size);
|
||||
}
|
||||
|
||||
|
||||
// Resize the vector preserving existing elements and initializing the
|
||||
// new ones with the given value.
|
||||
template <typename T>
|
||||
void Array<T>::resize(uint new_size, const T & elem)
|
||||
{
|
||||
nvDebugCheck(&elem < m_buffer || &elem > m_buffer+m_size);
|
||||
|
||||
uint old_size = m_size;
|
||||
|
||||
// Destruct old elements (if we're shrinking).
|
||||
destroy_range(m_buffer, new_size, old_size);
|
||||
|
||||
setArraySize(new_size);
|
||||
|
||||
// Call copy constructors
|
||||
construct_range(m_buffer, new_size, old_size, elem);
|
||||
}
|
||||
|
||||
// Clear the buffer.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::clear()
|
||||
{
|
||||
// Destruct old elements
|
||||
destroy_range(m_buffer, 0, m_size);
|
||||
|
||||
m_size = 0;
|
||||
}
|
||||
|
||||
// Shrink the allocated vector.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::shrink()
|
||||
{
|
||||
if (m_size < m_capacity) {
|
||||
setArrayCapacity(m_size);
|
||||
}
|
||||
}
|
||||
|
||||
// Preallocate space.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::reserve(uint desired_size)
|
||||
{
|
||||
if (desired_size > m_capacity) {
|
||||
setArrayCapacity(desired_size);
|
||||
}
|
||||
}
|
||||
|
||||
// Copy elements to this array. Resizes it if needed.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE void Array<T>::copy(const T * data, uint count)
|
||||
{
|
||||
destroy_range(m_buffer, count, m_size);
|
||||
|
||||
setArraySize(count);
|
||||
|
||||
::nv::copy(m_buffer, data, count);
|
||||
}
|
||||
|
||||
// Assignment operator.
|
||||
template <typename T>
|
||||
NV_FORCEINLINE Array<T> & Array<T>::operator=( const Array<T> & a )
|
||||
{
|
||||
copy(a.m_buffer, a.m_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Release ownership of allocated memory and returns pointer to it.
|
||||
template <typename T>
|
||||
T * Array<T>::release() {
|
||||
T * tmp = m_buffer;
|
||||
m_buffer = NULL;
|
||||
m_capacity = 0;
|
||||
m_size = 0;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Change array size.
|
||||
template <typename T>
|
||||
inline void Array<T>::setArraySize(uint new_size) {
|
||||
m_size = new_size;
|
||||
|
||||
if (new_size > m_capacity) {
|
||||
uint new_buffer_size;
|
||||
if (m_capacity == 0) {
|
||||
// first allocation is exact
|
||||
new_buffer_size = new_size;
|
||||
}
|
||||
else {
|
||||
// following allocations grow array by 25%
|
||||
new_buffer_size = new_size + (new_size >> 2);
|
||||
}
|
||||
|
||||
setArrayCapacity( new_buffer_size );
|
||||
}
|
||||
}
|
||||
|
||||
// Change array capacity.
|
||||
template <typename T>
|
||||
inline void Array<T>::setArrayCapacity(uint new_capacity) {
|
||||
nvDebugCheck(new_capacity >= m_size);
|
||||
|
||||
if (new_capacity == 0) {
|
||||
// free the buffer.
|
||||
if (m_buffer != NULL) {
|
||||
free<T>(m_buffer);
|
||||
m_buffer = NULL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
// realloc the buffer
|
||||
m_buffer = realloc<T>(m_buffer, new_capacity);
|
||||
}
|
||||
|
||||
m_capacity = new_capacity;
|
||||
}
|
||||
|
||||
// Array serialization.
|
||||
template <typename Typ>
|
||||
inline Stream & operator<< ( Stream & s, Array<Typ> & p )
|
||||
{
|
||||
if (s.isLoading()) {
|
||||
uint size;
|
||||
s << size;
|
||||
p.resize( size );
|
||||
}
|
||||
else {
|
||||
s << p.m_size;
|
||||
}
|
||||
|
||||
for (uint i = 0; i < p.m_size; i++) {
|
||||
s << p.m_buffer[i];
|
||||
}
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
// Swap the members of the two given vectors.
|
||||
template <typename Typ>
|
||||
inline void swap(Array<Typ> & a, Array<Typ> & b)
|
||||
{
|
||||
nv::swap(a.m_buffer, b.m_buffer);
|
||||
nv::swap(a.m_capacity, b.m_capacity);
|
||||
nv::swap(a.m_size, b.m_size);
|
||||
}
|
||||
|
||||
|
||||
} // nv namespace
|
||||
|
||||
#endif // NV_CORE_ARRAY_INL
|
||||
@ -0,0 +1,65 @@
|
||||
// This code is in the public domain -- Ignacio Castaño <castano@gmail.com>
|
||||
|
||||
#pragma once
|
||||
#ifndef NV_CORE_HASH_H
|
||||
#define NV_CORE_HASH_H
|
||||
|
||||
#include "nvcore.h"
|
||||
|
||||
namespace nv
|
||||
{
|
||||
inline uint sdbmHash(const void * data_in, uint size, uint h = 5381)
|
||||
{
|
||||
const uint8 * data = (const uint8 *) data_in;
|
||||
uint i = 0;
|
||||
while (i < size) {
|
||||
h = (h << 16) + (h << 6) - h + (uint) data[i++];
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
// Note that this hash does not handle NaN properly.
|
||||
inline uint sdbmFloatHash(const float * f, uint count, uint h = 5381)
|
||||
{
|
||||
for (uint i = 0; i < count; i++) {
|
||||
//nvDebugCheck(nv::isFinite(*f));
|
||||
union { float f; uint32 i; } x = { f[i] };
|
||||
if (x.i == 0x80000000) x.i = 0;
|
||||
h = sdbmHash(&x, 4, h);
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
// Some hash functors:
|
||||
template <typename Key> struct Hash
|
||||
{
|
||||
uint operator()(const Key & k) const {
|
||||
return sdbmHash(&k, sizeof(Key));
|
||||
}
|
||||
};
|
||||
/*template <> struct Hash<int>
|
||||
{
|
||||
uint operator()(int x) const { return x; }
|
||||
};
|
||||
template <> struct Hash<uint>
|
||||
{
|
||||
uint operator()(uint x) const { return x; }
|
||||
};*/
|
||||
template <> struct Hash<float>
|
||||
{
|
||||
uint operator()(float f) const {
|
||||
return sdbmFloatHash(&f, 1);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Key> struct Equal
|
||||
{
|
||||
bool operator()(const Key & k0, const Key & k1) const {
|
||||
return k0 == k1;
|
||||
}
|
||||
};
|
||||
|
||||
} // nv namespace
|
||||
|
||||
#endif // NV_CORE_HASH_H
|
||||
Loading…
Reference in New Issue