diff options
author | Ben Longbons <b.r.longbons@gmail.com> | 2012-12-27 21:23:46 -0800 |
---|---|---|
committer | Ben Longbons <b.r.longbons@gmail.com> | 2013-01-07 15:31:38 -0800 |
commit | c080e504e4d74027b985b1ed675c172c083cea76 (patch) | |
tree | ac084d16d9d40c0a0c950b66eb62a0e16795d486 /src/common/const_array.hpp | |
parent | ae30173d71d3bfc8514dbe70b6c90c9a3324b8fc (diff) | |
download | tmwa-c080e504e4d74027b985b1ed675c172c083cea76.tar.gz tmwa-c080e504e4d74027b985b1ed675c172c083cea76.tar.bz2 tmwa-c080e504e4d74027b985b1ed675c172c083cea76.tar.xz tmwa-c080e504e4d74027b985b1ed675c172c083cea76.zip |
Use cxxstdio
Diffstat (limited to 'src/common/const_array.hpp')
-rw-r--r-- | src/common/const_array.hpp | 175 |
1 files changed, 175 insertions, 0 deletions
diff --git a/src/common/const_array.hpp b/src/common/const_array.hpp new file mode 100644 index 0000000..12c5d6f --- /dev/null +++ b/src/common/const_array.hpp @@ -0,0 +1,175 @@ +#ifndef CONST_ARRAY_HPP +#define CONST_ARRAY_HPP +// const_array.hpp - just a pointer-to-const and a length +// +// Copyright © 2011-2012 Ben Longbons <b.r.longbons@gmail.com> +// +// This file is part of The Mana World (Athena server) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see <http://www.gnu.org/licenses/>. + +#include "sanity.hpp" + +#include <cstring> + +#include <iterator> +#include <ostream> +#include <string> +#include <vector> + +#ifdef ANNOYING_GCC46_WORKAROUNDS +# warning "like this one" +// constexpr is buggy with templates in this version +# define constexpr /* nothing */ +#endif + +template<class T> +class const_array +{ + const T *d; + size_t n; +public: + typedef const T *iterator; + typedef std::reverse_iterator<iterator> reverse_iterator; + + constexpr + const_array(std::nullptr_t) + : d(nullptr), n(0) + {} + + constexpr + const_array(const T *p, size_t z) + : d(p), n(z) + {} + + constexpr + const_array(const T *b, const T *e) + : d(b), n(e - b) + {} + + const_array(std::initializer_list<T> list) + : d(list.begin()), n(list.size()) + {} + + // Implicit conversion from std::vector + const_array(const std::vector<T>& v) + : d(v.data()), n(v.size()) + {} + + // but disallow conversion from a temporary + const_array(std::vector<T>&&) = delete; + + // All methods are non-const to "encourage" you + // to always pass a const_array by value. + // After all, "const const_array" looks funny. + constexpr + const T *data() { return d; } + constexpr + size_t size() { return n; } + constexpr + bool empty() { return not n; } + constexpr explicit + operator bool() { return n; } + + constexpr + std::pair<const_array, const_array> cut(size_t o) + { + return {const_array(d, o), const_array(d + o, n - o)}; + } + + constexpr + const_array first(size_t o) + { + return cut(o).first; + } + + constexpr + const_array last(size_t l) + { + return cut(size() - l).second; + } + + constexpr + const_array after(size_t o) + { + return cut(o).second; + } + + constexpr + iterator begin() { return d; } + constexpr + iterator end() { return d + n; } + constexpr + reverse_iterator rbegin() { return reverse_iterator(end()); } + constexpr + reverse_iterator rend() { return reverse_iterator(begin()); } + + constexpr + const T& front() { return *begin(); } + constexpr + const T& back() { return *rbegin(); } +}; + +// subclass just provides a simpler name and some conversions +class const_string : public const_array<char> +{ +public: + // Implicit conversion from C string. + constexpr + const_string(const char *z) + : const_array<char>(z, z ? strlen(z) : 0) + {} + + // Same as parent constructor. + constexpr + const_string(const char *s, size_t l) + : const_array<char>(s, l) + {} + + // Same as parent constructor. + constexpr + const_string(const char *b, const char *e) + : const_array<char>(b, e) + {} + + // Same as parent constructor. + const_string(const std::vector<char> s) + : const_array<char>(s) + {} + + // Implicit conversion from C++ string. + const_string(const std::string& s) + : const_array<char>(s.data(), s.size()) + {} + + // but disallow converion from a temporary. + const_string(std::string&&) = delete; + + // allow being sloppy + constexpr + const_string(const_array<char> a) + : const_array<char>(a) + {} +}; +#ifdef ANNOYING_GCC46_WORKAROUNDS +# undef constexpr +#endif + +inline +std::ostream& operator << (std::ostream& o, const_string s) +{ + return o.write(s.data(), s.size()); +} + +#endif // CONST_ARRAY_HPP |