/*
* Copyright (c), Zeriph Enterprises
* All rights reserved.
*
* Contributor(s):
* Zechariah Perez, omni (at) zeriph (dot) com
*
* THIS SOFTWARE IS PROVIDED BY ZERIPH AND CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ZERIPH AND CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#if !defined(OMNI_STACK_BUFFER_HPP)
#define OMNI_STACK_BUFFER_HPP 1
#include <omni/defs/class_macros.hpp>
#include <omni/string/util.hpp>
#include <cstdarg>
namespace omni {
template <
typename T,
uint16_t SZ >
class stack_buffer
{
public:
typedef const T* const_iterator;
typedef T* iterator;
typedef T value_type;
stack_buffer() :
OMNI_CTOR_FW(
omni::stack_buffer)
m_data()
{
if (SZ ==
0) {
OMNI_ERR_FW(
OMNI_INDEX_OOR_STR,
omni::exceptions::index_out_of_range())
}
std::memset(
this->m_data,
0, SZ);
}
stack_buffer(
const T (&data)[SZ]) :
OMNI_CTOR_FW(
omni::stack_buffer)
m_data()
{
if (SZ ==
0) {
OMNI_ERR_FW(
OMNI_INDEX_OOR_STR,
omni::exceptions::index_out_of_range())
}
std::memcpy(
this->m_data, data, SZ);
}
stack_buffer(T val1, ...) :
OMNI_CTOR_FW(
omni::stack_buffer)
m_data()
{
if (SZ ==
0) {
OMNI_ERR_FW(
OMNI_INDEX_OOR_STR,
omni::exceptions::index_out_of_range())
}
std::va_list args;
va_start(args, val1);
this->m_data[
0] = val1;
for (
std::size_t i =
1; i < SZ; ++i) {
this->m_data[i] =
static_cast<T>(va_arg(args, T));
}
va_end(args);
}
template <
uint16_t OTHER_SZ >
stack_buffer(
const T (&data)[OTHER_SZ]) :
OMNI_CTOR_FW(
omni::stack_buffer)
m_data()
{
if ((OTHER_SZ ==
0) || (OTHER_SZ > SZ)) {
OMNI_ERR_FW(
OMNI_INDEX_OOR_STR,
omni::exceptions::index_out_of_range())
}
std::memset(
this->m_data,
0, SZ);
std::memcpy(
this->m_data, data, OTHER_SZ);
}
stack_buffer(
const stack_buffer& cp) :
OMNI_CTOR_FW(
omni::stack_buffer)
m_data()
{
if (SZ ==
0) {
OMNI_ERR_FW(
OMNI_INDEX_OOR_STR,
omni::exceptions::index_out_of_range())
}
std::memcpy(
this->m_data, cp.m_data, SZ);
}
~stack_buffer()
{
OMNI_TRY_FW
std::memset(
this->m_data,
0, SZ);
OMNI_DTOR_FW
OMNI_CATCH_FW
OMNI_D5_FW(
"destroyed");
}
T& at(
uint16_t index)
{
if (index > SZ) {
OMNI_ERRV_RETV_FW(
OMNI_INDEX_OOR_STR, index,
omni::exceptions::index_out_of_range(index), T())
}
return this->m_data[index];
}
T* back()
{
return this->m_data + SZ;
}
iterator begin()
{
return this->m_data;
}
const_iterator begin()
const
{
return const_cast<
const T*>(&
this->m_data[
0]);
}
std::size_t capacity()
const
{
return SZ;
}
T* data()
{
return this->m_data;
}
const T *
const data()
const
{
return this->m_data;
}
iterator end()
{
return this->m_data + SZ;
}
const_iterator end()
const
{
return this->m_data + SZ;
}
T* front()
{
return this->m_data;
}
void fill(T value)
{
for (
std::size_t i =
0; i < SZ; ++i) {
this->m_data[i] = value;
}
}
std::size_t memory_size()
const
{
return SZ *
sizeof(T);
}
void swap(stack_buffer& other)
{
if (
this != &other) {
std::swap(
this->m_data, other.m_data);
}
}
void swap(T (&data)[SZ])
{
if (&
this->m_data != &data) {
std::swap(
this->m_data, data);
}
}
std::size_t size()
const
{
return SZ;
}
void zeroize()
{
std::memset(
this->m_data,
0,
sizeof(T)*SZ);
}
omni::string_t to_string_t()
const
{
omni::sstream_t s;
s <<
this->m_data;
return s.str();
}
std::string to_string()
const
{
std::stringstream s;
s <<
this->m_data;
return s.str();
}
std::wstring to_wstring()
const
{
std::wstringstream s;
s <<
this->m_data;
return s.str();
}
stack_buffer&
operator=(
const stack_buffer& other)
{
if (
this != &other) {
OMNI_ASSIGN_FW(other)
std::memcpy(
this->m_data, other.m_data, SZ);
}
return *
this;
}
stack_buffer&
operator=(
const T (&data)[SZ])
{
if (&
this->m_data != &data) {
std::memcpy(
this->m_data, data, SZ);
}
return *
this;
}
template <
uint16_t OTHER_SZ >
stack_buffer&
operator=(
const T (&data)[OTHER_SZ])
{
if ((OTHER_SZ ==
0) || (OTHER_SZ > SZ)) {
OMNI_ERR_FW(
OMNI_INDEX_OOR_STR,
omni::exceptions::index_out_of_range())
}
std::memset(
this->m_data,
0, SZ);
std::memcpy(
this->m_data, data, OTHER_SZ);
return *
this;
}
bool operator==(
const stack_buffer& other)
const
{
if (
this != &other) {
return (
std::memcmp(
this->m_data, other.m_data, SZ) ==
0);
}
return true;
}
bool operator==(
const T (&data)[SZ])
const
{
return (
std::memcmp(
this->m_data, data, SZ) ==
0);
}
inline bool operator!=(
const stack_buffer& other)
const
{
return !(*
this == other);
}
inline bool operator!=(
const T (&data)[SZ])
const
{
return !(*
this == data);
}
bool operator<(
const stack_buffer& other)
const
{
if (
this == &other) {
return false; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] >= other.m_data[i]) {
return false;
}
}
return true;
}
bool operator<(
const T (&data)[SZ])
const
{
if (&
this->m_data == &data) {
return false; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] >= data[i]) {
return false;
}
}
return true;
}
bool operator>(
const stack_buffer& other)
const
{
if (
this == &other) {
return false; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] <= other.m_data[i]) {
return false;
}
}
return true;
}
bool operator>(
const T (&data)[SZ])
const
{
if (&
this->m_data == &data) {
return false; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] <= data[i]) {
return false;
}
}
return true;
}
bool operator<=(
const stack_buffer& other)
const
{
if (
this == &other) {
return true; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] > other.m_data[i]) {
return false;
}
}
return true;
}
bool operator<=(
const T (&data)[SZ])
const
{
if (&
this->m_data == &data) {
return true; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] > data[i]) {
return false;
}
}
return true;
}
bool operator>=(
const stack_buffer& other)
const
{
if (
this == &other) {
return true; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] < other.m_data[i]) {
return false;
}
}
return true;
}
bool operator>=(
const T (&data)[SZ])
const
{
if (&
this->m_data == &data) {
return true; }
for (
uint16_t i =
0; i < SZ; ++i) {
if (
this->m_data[i] < data[i]) {
return false;
}
}
return true;
}
operator std::string()
const
{
return this->to_string();
}
operator std::wstring()
const
{
return this->to_wstring();
}
template <
template <
class,
class >
class std_seq_t,
typename std_allocator_t >
operator std_seq_t < T, std_allocator_t >()
const
{
return std_seq_t < T, std_allocator_t >(
this->begin(),
this->end());
}
template <
template <
class,
class >
class std_seq_t >
operator std_seq_t < T,
std::allocator<T> >()
const
{
return std_seq_t < T,
std::allocator<T> >(
this->begin(),
this->end());
}
T
operator[](
std::size_t index)
const
{
return this->m_data[index];
}
T&
operator[](
std::size_t index)
{
return this->m_data[index];
}
operator const T *
const()
const
{
return this->m_data;
}
operator T *
const()
{
return this->m_data;
}
OMNI_MEMBERS_FW(
omni::stack_buffer<T, SZ>)
// disposing,name,type(),hash()
OMNI_OSTREAM_FW(
omni::stack_buffer<T, SZ>)
static
std::size_t max_size()
{
return std::numeric_limits<
uint16_t>::max();
}
private:
T m_data[SZ];
};
}
namespace std {
template <
typename T,
uint16_t SZ >
inline void swap(
omni::stack_buffer<T, SZ>& o1,
omni::stack_buffer<T, SZ>& o2)
{
o1.swap(o2);
}
template <
typename T,
uint16_t SZ >
inline void swap(
omni::stack_buffer<T, SZ>& o1, T (&data)[SZ])
{
o1.swap(data);
}
template <
typename T,
uint16_t SZ >
inline void swap(T (&data)[SZ],
omni::stack_buffer<T, SZ>& o1)
{
o1.swap(data);
}
}
#endif // OMNI_STACK_BUFFER_HPP
