mcl/include/cybozu/array.hpp

#pragma once

/**
	@file
	@brief scoped array and aligned array

	@author MITSUNARI Shigeo(@herumi)
*/
#include <new>
#include <utility>
#ifdef _WIN32
	#include <malloc.h>
#else
	#include <stdlib.h>
#endif
#include <cybozu/inttype.hpp>

namespace cybozu {

inline void *AlignedMalloc(size_t size, size_t alignment)
{
#ifdef _WIN32
	return _aligned_malloc(size, alignment);
#else
	void *p;
	int ret = posix_memalign(&p, alignment, size);
	return (ret == 0) ? p : 0;
#endif
}

inline void AlignedFree(void *p)
{
#ifdef _WIN32
	if (p == 0) return;
	_aligned_free(p);
#else
	free(p);
#endif
}

template<class T>
class ScopedArray {
	T *p_;
	size_t size_;
	ScopedArray(const ScopedArray&);
	void operator=(const ScopedArray&);
public:
	explicit ScopedArray(size_t size)
		: p_(new T[size])
		, size_(size)
	{
	}
	~ScopedArray()
	{
		delete[] p_;
	}
	T& operator[](size_t idx) CYBOZU_NOEXCEPT { return p_[idx]; }
	const T& operator[](size_t idx) const CYBOZU_NOEXCEPT { return p_[idx]; }
	size_t size() const CYBOZU_NOEXCEPT { return size_; }
	bool empty() const CYBOZU_NOEXCEPT { return size_ == 0; }
	T* begin() CYBOZU_NOEXCEPT { return p_; }
	T* end() CYBOZU_NOEXCEPT { return p_ + size_; }
	const T* begin() const CYBOZU_NOEXCEPT { return p_; }
	const T* end() const CYBOZU_NOEXCEPT { return p_ + size_; }
    T* data() CYBOZU_NOEXCEPT { return p_; }
    const T* data() const CYBOZU_NOEXCEPT { return p_; }
};

/**
	T must be POD type
	16byte aligment array
*/
template<class T, size_t N = 16, bool defaultDoClear = true>
class AlignedArray {
	T *p_;
	size_t size_;
	size_t allocSize_;
	T *alloc(size_t size) const
	{
		T *p = static_cast<T*>(AlignedMalloc(size * sizeof(T), N));
		if (p == 0) throw std::bad_alloc();
		return p;
	}
	void copy(T *dst, const T *src, size_t n) const
	{
		for (size_t i = 0; i < n; i++) dst[i] = src[i];
	}
	void setZero(T *p, size_t n) const
	{
		for (size_t i = 0; i < n; i++) p[i] = 0;
	}
	/*
		alloc allocN and copy [p, p + copyN) to new p_
		don't modify size_
	*/
	void allocCopy(size_t allocN, const T *p, size_t copyN)
	{
		T *q = alloc(allocN);
		copy(q, p, copyN);
		AlignedFree(p_);
		p_ = q;
		allocSize_ = allocN;
	}
public:
	/*
		don't clear buffer with zero if doClear is false
	*/
	explicit AlignedArray(size_t size = 0, bool doClear = defaultDoClear)
		: p_(0)
		, size_(0)
		, allocSize_(0)
	{
		resize(size, doClear);
	}
	AlignedArray(const AlignedArray& rhs)
		: p_(0)
		, size_(0)
		, allocSize_(0)
	{
		*this = rhs;
	}
	AlignedArray& operator=(const AlignedArray& rhs)
	{
		if (allocSize_ < rhs.size_) {
			allocCopy(rhs.size_, rhs.p_, rhs.size_);
		} else {
			copy(p_, rhs.p_, rhs.size_);
		}
		size_ = rhs.size_;
		return *this;
	}
#if (CYBOZU_CPP_VERSION >= CYBOZU_CPP_VERSION_CPP11)
	AlignedArray(AlignedArray&& rhs) CYBOZU_NOEXCEPT
		: p_(rhs.p_)
		, size_(rhs.size_)
		, allocSize_(rhs.allocSize_)
	{
		rhs.p_ = 0;
		rhs.size_ = 0;
		rhs.allocSize_ = 0;
	}
	AlignedArray& operator=(AlignedArray&& rhs) CYBOZU_NOEXCEPT
	{
		swap(rhs);
		rhs.clear();
		return *this;
	}
#endif
	/*
		don't clear buffer with zero if doClear is false
		@note don't free if shrinked
	*/
	void resize(size_t size, bool doClear = defaultDoClear)
	{
		// shrink
		if (size <= size_) {
			size_ = size;
			return;
		}
		// realloc if necessary
		if (size > allocSize_) {
			allocCopy(size, p_, size_);
		}
		if (doClear) setZero(p_ + size_, size - size_);
		size_ = size;
	}
	void clear() // not free
	{
		size_ = 0;
	}
	~AlignedArray()
	{
		AlignedFree(p_);
	}
	void swap(AlignedArray& rhs) CYBOZU_NOEXCEPT
	{
		std::swap(p_, rhs.p_);
		std::swap(size_, rhs.size_);
		std::swap(allocSize_, rhs.allocSize_);
	}
	T& operator[](size_t idx) CYBOZU_NOEXCEPT { return p_[idx]; }
	const T& operator[](size_t idx) const CYBOZU_NOEXCEPT { return p_[idx]; }
	size_t size() const CYBOZU_NOEXCEPT { return size_; }
	bool empty() const CYBOZU_NOEXCEPT { return size_ == 0; }
	T* begin() CYBOZU_NOEXCEPT { return p_; }
	T* end() CYBOZU_NOEXCEPT { return p_ + size_; }
	const T* begin() const CYBOZU_NOEXCEPT { return p_; }
	const T* end() const CYBOZU_NOEXCEPT { return p_ + size_; }
    T* data() CYBOZU_NOEXCEPT { return p_; }
    const T* data() const CYBOZU_NOEXCEPT { return p_; }
#if (CYBOZU_CPP_VERSION >= CYBOZU_CPP_VERSION_CPP11)
	const T* cbegin() const CYBOZU_NOEXCEPT { return p_; }
	const T* cend() const CYBOZU_NOEXCEPT { return p_ + size_; }
#endif
};

} // cybozu