Array.hpp

// This file is part of the Orbbec Astra SDK [https://orbbec3d.com]
// Copyright (c) 2015-2017 Orbbec 3D
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Be excellent to each other.
#ifndef ASTRA_ARRAY_HPP
#define ASTRA_ARRAY_HPP
 
namespace astra {
    template<typename T>
    class Array
    {
    public:
        inline Array() : ptr_(nullptr), size_(0) {}
        inline Array(decltype(nullptr)) : ptr_(nullptr), size_(0) {}
        inline Array(T* ptr, size_t size) : ptr_(ptr), size_(size) {}
        inline Array(T* begin, T* end) : ptr_(begin), size_(end - begin) {}
 
        inline size_t size() const { return size_; }
        inline bool empty() const { return size_ == 0; }
 
        inline T* data() { return ptr_; }
        inline const T* data() const { return ptr_; }
 
        inline T* begin() { return ptr_; }
        inline const T* begin() const { return ptr_; }
        inline T* end() { return ptr_ + size_; }
        inline const T* end() const { return ptr_ + size_; }
 
        inline T& front() { return *ptr_; }
        inline const T& front() const { return *ptr_; }
        inline T& back() { return ptr_[size_ - 1]; }
        inline const T& back() const { return ptr_[size_ - 1]; }
 
        inline T& operator[](size_t index)
        {
            return ptr_[index];
        }
 
        inline const T& operator[](size_t index) const
        {
            return ptr_[index];
        }
 
        inline Array<T> slice(size_t start, size_t end)
        {
            return Array<T>(ptr_ + start, end - start);
        }
 
        inline Array<const T> slice(size_t start, size_t end) const
        {
            return Array<const T>(ptr_ + start, end - start);
        }
 
        inline bool operator==(const Array& other) const
        {
            if (this == &other) { return true; }
            return this->ptr_ == other.ptr_;
        }
 
        inline bool operator!=(const Array& other) const { return !(*this == other); }
 
    private:
        T* ptr_;
        size_t size_;
    };
 
    template<typename T>
    inline Array<T> make_array(T* ptr, std::size_t size)
    {
        return Array<T>(ptr, size);
    }
 
}
 
#endif // ASTRA_ARRAY_HPP