ArrayManager.h

/* Copyright 2016 Kristofer Björnson
 *
 * 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.
 */

#ifndef COM_DAFER45_TBTK_ARRAY_MANAGER
#define COM_DAFER45_TBTK_ARRAY_MANAGER

#include "Index.h"
#include "Streams.h"

namespace TBTK{
namespace Util{

template<typename T>
class ArrayManager{
public:
    static void* create(const Index &ranges);

    static void* create(const Index &ranges, T fill);

    static void destroy(void *array, const Index &ranges);

    static T* flatten(void *array, const Index &ranges);

    static void* unflatten(T *array, const Index &ranges);

    static void print(void * array, const Index &ranges);
private:
    static void createRecursive(Index ranges, void **result);

    static void createRecursive(Index ranges, void **result, T fill);

    static void destroyRecursive(void *array, Index ranges);

    static void flattenRecursive(void *array, Index ranges, T *result, int offset);

    static void unflattenRecursive(T *array, Index ranges, void **result, int offset);

    static void printRecursive(void *array, Index ranges);
};

template<typename T>
void* ArrayManager<T>::create(const Index &ranges){
    void *result;

    createRecursive(ranges, &result);

    return result;
}

template<typename T>
void ArrayManager<T>::createRecursive(Index ranges, void **result){
    if(ranges.size() == 1){
        *((T**)result) = new T[ranges.at(0)];
    }
    else{
        *((void**)result) = new void*[ranges.at(0)];

        int currentRange = ranges.at(0);
//      ranges.erase(ranges.begin());
        ranges.popFront();
        for(int n = 0; n < currentRange; n++)
            createRecursive(ranges, &(((void**)(*result))[n]));
    }
}

template<typename T>
void* ArrayManager<T>::create(const Index &ranges, T fill){
    void *result;

    createRecursive(ranges, &result, fill);

    return result;
}

template<typename T>
void ArrayManager<T>::createRecursive(Index ranges, void **result, T fill){
    if(ranges.size() == 1){
        *((T**)result) = new T[ranges.at(0)];
        for(int n = 0; n < ranges.at(0); n++)
            (*((T**)result))[n] = fill;
    }
    else{
        *((void**)result) = new void*[ranges.at(0)];

        int currentRange = ranges.at(0);
//      ranges.erase(ranges.begin());
        ranges.popFront();
        for(int n = 0; n < currentRange; n++)
            createRecursive(ranges, &(((void**)(*result))[n]), fill);
    }
}

template<typename T>
void ArrayManager<T>::destroy(void *array, const Index &ranges){
    destroyRecursive(array, ranges);
}

template<typename T>
void ArrayManager<T>::destroyRecursive(void *array, Index ranges){
    if(ranges.size() == 1){
        delete [] (T*)array;
    }
    else{
        int currentRange = ranges.at(0);
//      ranges.erase(ranges.begin());
        ranges.popFront();
        for(int n = 0; n < currentRange; n++)
            destroyRecursive(((void**)array)[n], ranges);

        delete [] (void**)array;
    }
}

template<typename T>
T* ArrayManager<T>::flatten(void *array, const Index &ranges){
    int size = 1;
    for(unsigned int n = 0; n < ranges.size(); n++)
        size *= ranges.at(n);

    T *result = new T[size];

    flattenRecursive(array, ranges, result, 0);

    return result;
}

template<typename T>
void ArrayManager<T>::flattenRecursive(void *array, Index ranges, T *result, int offset){
    if(ranges.size() == 1){
        for(int n = 0; n < ranges.at(0); n++){
            result[offset + n] = ((T*)array)[n];
        }
    }
    else{
        int offsetMultiplier = 1;
        for(unsigned int n = 1; n < ranges.size(); n++)
            offsetMultiplier *= ranges.at(n);

        int currentRange = ranges.at(0);
//      ranges.erase(ranges.begin());
        ranges.popFront();
        for(int n = 0; n < currentRange; n++)
            flattenRecursive(((void**)array)[n], ranges, result, offset + offsetMultiplier*n);
    }
}

template<typename T>
void* ArrayManager<T>::unflatten(T *array, const Index &ranges){
    void *result;

    unflattenRecursive(array, ranges, &result, 0);

    return (void*)result;
}

template<typename T>
void ArrayManager<T>::unflattenRecursive(T *array, Index ranges, void **result, int offset){
    if(ranges.size() == 1){
        *((T**)result) = new T[ranges.at(0)];
        for(int n = 0; n < ranges.at(0); n++)
            (*((T**)result))[n] = array[offset + n];
    }
    else{
        *((void**)result) = new void*[ranges.at(0)];

        int offsetMultiplier = 1;
        for(int n = 1; n < ranges.size(); n++)
            offsetMultiplier *= ranges.at(n);

        int currentRange = ranges.at(0);
//      ranges.erase(ranges.begin());
        ranges.popFront();
        for(int n = 0; n < currentRange; n++)
            unflattenRecursive(array, ranges, &(((void**)(*result))[n]), offset + offsetMultiplier*n);
    }
}

template<typename T>
void ArrayManager<T>::print(void *array, const Index &ranges){
    printRecursive(array, ranges);
}

template<typename T>
void ArrayManager<T>::printRecursive(void *array, Index ranges){
    if(ranges.size() == 1){
        for(int n = 0; n < ranges.at(0); n++)
            Util::Streams::out << ((T*)array)[n] << "\t";
        Util::Streams::out << "\n";
    }
    else{
        int currentRange = ranges.at(0);
        ranges.popFront();
        for(int n = 0; n < currentRange; n++)
            printRecursive(((void**)array)[n], ranges);
        Util::Streams::out << "\n";
    }
}

};  //End of namespace Util
};  //End of namespace TBTK

#endif