ArrayState.h

/* Copyright 2017 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_STATE
#define COM_DAFER45_TBTK_ARRAY_STATE

#include "TBTK/AbstractState.h"
#include "TBTK/DefaultOperator.h"
#include "TBTK/TBTKMacros.h"

#include <complex>
#include <sstream>

namespace TBTK{

class ArrayState : public AbstractState{
public:
    ArrayState(
        std::initializer_list<unsigned int> resolution
    );

    virtual ~ArrayState();

    virtual ArrayState* clone() const;

    virtual std::complex<double> getOverlap(const AbstractState &bra) const;

    virtual std::complex<double> getMatrixElement(
        const AbstractState &bra,
        const AbstractOperator &o = DefaultOperator()
    ) const;

    void setAmplitude(
        std::complex<double> amplitude,
        std::initializer_list<unsigned int> element
    );

    void setAmplitude(
        std::complex<double> amplitude,
        const std::vector<unsigned int> &element
    );

    void setAmplitude(
        std::complex<double> amplitude,
        const Index &element
    );

    const std::complex<double>& getAmplitude(
        std::initializer_list<unsigned int> element
    ) const;

    const std::complex<double>& getAmplitude(
        const std::vector<unsigned int> &element
    ) const;

    const std::complex<double>& getAmplitude(
        const Index &element
    ) const;
protected:
    const std::vector<unsigned int>& getResolution() const;
private:
    class Storage{
    public:
        Storage(std::initializer_list<unsigned int> resolution);

        ~Storage();

        void grab();

        bool release();

        void setElement(
            std::complex<double> value,
            std::initializer_list<unsigned int> element
        );

        void setElement(
            std::complex<double> value,
            const std::vector<unsigned int> &element
        );

        void setElement(
            std::complex<double> value,
            const Index &element
        );

        const std::complex<double>& getElement(
            std::initializer_list<unsigned int> element
        ) const;

        const std::complex<double>& getElement(
            const std::vector<unsigned int> &element
        ) const;

        const std::complex<double>& getElement(
            const Index &element
        ) const;

        const std::vector<unsigned int>& getResolution() const;
    private:
        unsigned int referenceCounter;

        std::complex<double> *data;

        std::vector<unsigned int> resolution;
    };

    Storage *storage;
};

inline void ArrayState::Storage::grab(){
    referenceCounter++;
}

inline bool ArrayState::Storage::release(){
    referenceCounter--;
    if(referenceCounter == 0)
        return true;
    else
        return false;
}

inline void ArrayState::setAmplitude(
    std::complex<double> amplitude,
    std::initializer_list<unsigned int> element
){
    storage->setElement(amplitude, element);
}

inline void ArrayState::setAmplitude(
    std::complex<double> amplitude,
    const std::vector<unsigned int> &element
){
    storage->setElement(amplitude, element);
}

inline void ArrayState::setAmplitude(
    std::complex<double> amplitude,
    const Index &element
){
    storage->setElement(amplitude, element);
}

inline const std::complex<double>& ArrayState::getAmplitude(
    std::initializer_list<unsigned int> element
) const{
    return storage->getElement(element);
}

inline const std::complex<double>& ArrayState::getAmplitude(
    const std::vector<unsigned int> &element
) const{
    return storage->getElement(element);
}

inline const std::complex<double>& ArrayState::getAmplitude(
    const Index &element
) const{
    return storage->getElement(element);
}

inline const std::vector<unsigned int>& ArrayState::getResolution() const{
    return storage->getResolution();
}

inline void ArrayState::Storage::setElement(
    std::complex<double> value,
    std::initializer_list<unsigned int> element
){
    unsigned int x = *(element.begin() + 0);
    unsigned int y = *(element.begin() + 1);
    unsigned int z = *(element.begin() + 2);
    data[resolution[2]*(resolution[1]*x + y) + z] = value;
}

inline void ArrayState::Storage::setElement(
    std::complex<double> value,
    const std::vector<unsigned int> &element
){
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    data[resolution[2]*(resolution[1]*x + y) + z] = value;
}

inline void ArrayState::Storage::setElement(
    std::complex<double> value,
    const Index &element
){
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    data[resolution[2]*(resolution[1]*x + y) + z] = value;
}

inline const std::complex<double>& ArrayState::Storage::getElement(
    std::initializer_list<unsigned int> element
) const{
    unsigned int x = *(element.begin() + 0);
    unsigned int y = *(element.begin() + 1);
    unsigned int z = *(element.begin() + 2);
    return data[resolution[2]*(resolution[1]*x + y) + z];
}

inline const std::complex<double>& ArrayState::Storage::getElement(
    const std::vector<unsigned int> &element
) const{
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    return data[resolution[2]*(resolution[1]*x + y) + z];
}

inline const std::complex<double>& ArrayState::Storage::getElement(
    const Index &element
) const{
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    return data[resolution[2]*(resolution[1]*x + y) + z];
}

inline const std::vector<unsigned int>& ArrayState::Storage::getResolution() const{
    return resolution;
}

};  //End of namespace TBTK

#endif