array.hpp

Go to the documentation of this file.

// Author:  Mario S. Könz <mskoenz@gmx.net>
// Date:    15.06.2013 23:45:24 EDT
// File:    array.hpp

/* This program is free software. It comes without any warranty, to
 * the extent permitted by applicable law. You can redistribute it
 * and/or modify it under the terms of the Do What The Fuck You Want
 * To Public License, Version 2, as published by Sam Hocevar. See
 * http://www.wtfpl.net/ or COPYING for more details. */

#ifndef __ARRAY_HEADER
#define __ARRAY_HEADER

#include "ard_assert.hpp"

namespace ustd {
    template<typename T, uint16_t N>
    class array {
    public:
        typedef T value_type;
        typedef uint16_t size_type;
        //------------------- ctors -------------------
        array() {
            for(size_type i = 0; i < N; ++i) {
                array_[i] = T();
            }
        }
        array(T const & init) {
            for(size_type i = 0; i < N; ++i) {
                array_[i] = init;
            }
        }
        array(array const & arg) {
            for(size_type i = 0; i < N; ++i) {
                array_[i] = arg.array_[i];
            }
        }
        array & operator=(array const & rhs) {
            for(size_type i = 0; i < N; ++i)
                array_[i] = rhs.array_[i];
            return (*this);
        }
        //------------------- getter -------------------
        T & operator[](size_type const & pos) {
            ASSERT(pos >= 0)
            ASSERT(pos < N)
            return array_[pos];
        }
        T const & operator[](size_type const & pos) const {
            ASSERT(pos >= 0)
            ASSERT(pos < N)
            return array_[pos];
        }
        T * data() {
            return array_;
        }
        //------------------- size/capacity -------------------
        constexpr size_type size() {
            return N;
        }
        //------------------- iterator -------------------
        //~ struct iterator {
            //~ iterator(array & arr, size_type const & pos): arr_(arr), pos_(pos) {
            //~ }
            //~ iterator & operator++() {
                //~ ++pos_;
                //~ return (*this);
            //~ }
            //~ bool operator!=(iterator const & rhs) const {
                //~ return pos_ != rhs.pos_;
            //~ }
            //~ value_type & operator*() {
                //~ return arr_[pos_];
            //~ }
            //~ array & arr_;
            //~ size_type pos_;
        //~ };
        //~ iterator begin() {
            //~ return iterator((*this), 0);
        //~ }
        //~ iterator end() {
            //~ return iterator((*this), N);
        //~ }
        //------------------- print & serialize-------------------
        template<typename S>
        void print(S & os) const {
            os << F("[");
            for(size_type i = 0; i < N; ++i) {
                os << array_[i];
                if(i != N - 1)
                    os << F(", ");
            }
            os << F("]");
        }
        template<typename Archive>
        void serialize(Archive & ar) {
            for(size_type i = 0; i< N; ++i)
                ar & array_[i];
        }
        //------------------- custom operations / not in std -------------------
        void clear() {
            for(size_type i = 0; i< N; ++i)
                array_[i] = T();
        }
    private:
        T array_[N];
    };
}//end namespace ustd


#endif //__ARRAY_HEADER