CUAligned.h

//
//  CUAligned.h
//  Cornell University Game Library (CUGL)
//
//  This module provides an aligned array that is C++11.  Aligned arrays are
//  added to C++17, but there is no guaranteed Android support for C++17.
//
//  This tempalted class does not uses our standard shared-pointer architecture.
//  We often want to copy or move these arrays, so we have non-trivial constructors
//  for this class. With that said, we do have a static method which allocates
//  a shared pointer.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 6/30/18
#ifndef __CU_ALIGNED_H__
#define __CU_ALIGNED_H__
#include "CUDebug.h"
#include <memory.h>

namespace cugl {
    
#pragma mark -
#pragma mark Aligned Arrays Template
    
template <class T>
class Aligned {
private:
    T*     _pntr;
    void*  _orig;
    size_t _capacity;
    size_t _length;
    size_t _alignm;

#pragma mark -
#pragma mark Constructors
public:
    Aligned() :
    _pntr(nullptr),
    _orig(nullptr),
    _capacity(0),
    _length(0),
    _alignm(0) { }
    
    
    
    Aligned(size_t size, size_t alignment) {
        _capacity = size*sizeof(T)+alignment;
        _length   = size;
        _alignm   = alignment;
        _orig = malloc(_capacity);
        _pntr = (T*)std::align(alignment,_length*sizeof(T),_orig,_capacity);
    }

    Aligned(const Aligned<T>& copy) {
        _capacity = copy._capacity;
        _length   = copy._length;
        _alignm   = copy._alignm;
        _orig = malloc(_capacity);
        _pntr = (T*)std::align(_alignm,_length*sizeof(T),_orig,_capacity);
        std::memcpy(_pntr,copy._pntr,_length*sizeof(T)); // Only copy visible space
    }

    Aligned(Aligned<T>&& other) {
        _capacity = other._capacity;
        _length   = other._length;
        _alignm   = other._alignm;
        _orig = other._orig;
        _pntr = other._pntr;
        other._orig = nullptr;
        other._pntr = nullptr;
    }

    ~Aligned() { dispose(); }
    
    void dispose() {
        if (_orig) free(_orig);
        _pntr = nullptr;
        _orig = nullptr;
        _capacity = 0;
        _length = 0;
    }

    static std::shared_ptr<Aligned<T>> alloc(size_t size, size_t alignment) {
        std::shared_ptr<Aligned<T>> result = std::make_shared<Aligned<T>>();
        return (result->reset(size,alignment) ? result : nullptr);
    }

#pragma mark -
#pragma mark Array Methods

    bool reset(size_t size, size_t alignment) {
        if (_orig) dispose();
        
        _capacity = size*sizeof(T)+alignment;
        _length   = size;
        _alignm   = alignment;
        
        _orig = malloc(_capacity);
        _pntr = (T*)std::align(_alignm,size*sizeof(T),_orig,_capacity);
        return _pntr;
    }
    
    void clear() {
        std::memset(_pntr,0,_length*sizeof(T));
    }
    
    size_t size() const {
        return _length;
    }

#pragma mark -
#pragma mark Copy Behavior

    Aligned<T>& operator=(const Aligned<T>& copy) {
        _capacity = copy._capacity;
        _length   = copy._length;
        _alignm   = copy._alignm;
        _orig = malloc(_capacity);
        _pntr = (T*)std::align(_alignm,_length*sizeof(T),_orig,_capacity);
        std::memcpy(_pntr,copy._pntr,_length*sizeof(T)); // Only copy visible space
        return *this;
    }
    
    Aligned<T>& operator=(Aligned<T>&& other) {
        _capacity = other._capacity;
        _length   = other._length;
        _alignm   = other._alignm;
        _orig = other._orig;
        _pntr = other._pntr;
        other._orig = nullptr;
        other._pntr = nullptr;
        return *this;
    }

#pragma mark -
#pragma mark Pointer Behavior

    operator T*() const {
        return _pntr;
    }
    
    
    T& operator*() {
        return _pntr[0];
    }

    T* operator+(size_t offset) {
        return _pntr+offset;
    }
    
    T& operator[](size_t idx) {
        return _pntr[idx];
    }

    const T& operator[](size_t idx) const {
        return _pntr[idx];
    }
    

};

}

#endif /* __CU_ALIGNED_H__ */