BasisStateSet.h

/* Copyright 2019 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_BASIS_STATE_SET
#define COM_DAFER45_TBTK_BASIS_STATE_SET

#include "TBTK/AbstractState.h"
#include "TBTK/IndexedDataTree.h"
#include "TBTK/Serializable.h"
#include "TBTK/TBTKMacros.h"

#include <vector>

namespace TBTK{

class BasisStateSet : public Serializable{
public:
    BasisStateSet();

    BasisStateSet(const std::string &serializeation, Mode mode);

    virtual ~BasisStateSet();

    void add(const AbstractState &state);

    AbstractState& get(const Index &index);

    const AbstractState& get(const Index &index) const;

    class Iterator;
    class ConstIterator;
private:
    template<bool isConstIterator>
    class _Iterator{
    public:
        typedef typename std::conditional<
            isConstIterator,
            const AbstractState&,
            AbstractState&
        >::type BasisStateReferenceType;

        void operator++();

        BasisStateReferenceType operator*();

        bool operator==(const _Iterator &rhs);

        bool operator!=(const _Iterator &rhs);
    private:
        typedef typename std::conditional<
            isConstIterator,
            IndexedDataTree<AbstractState*>::ConstIterator,
            IndexedDataTree<AbstractState*>::Iterator
        >::type IteratorType;

        IteratorType iterator;

        IteratorType iteratorEnd;

        friend class Iterator;
        friend class ConstIterator;

        typedef typename std::conditional<
            isConstIterator,
            const IndexedDataTree<AbstractState*>,
            IndexedDataTree<AbstractState*>
        >::type BasisStateTreeType;

        _Iterator(
            BasisStateTreeType &basisStateTree,
            bool end = false
        );
    };
public:
    class Iterator : public _Iterator<false>{
    private:
        Iterator(
            IndexedDataTree<AbstractState*> &basisStateTree,
            bool end = false
        ) : _Iterator(basisStateTree, end){};

        friend class BasisStateSet;
    };

    class ConstIterator : public _Iterator<true>{
    private:
        ConstIterator(
            const IndexedDataTree<
                AbstractState*
            > &basisStateTree,
            bool end = false
        ) : _Iterator(basisStateTree, end){};

        friend class BasisStateSet;
    };

    BasisStateSet::Iterator begin();

    BasisStateSet::ConstIterator begin() const;

    BasisStateSet::ConstIterator cbegin() const;

    BasisStateSet::Iterator end();

    BasisStateSet::ConstIterator end() const;

    BasisStateSet::ConstIterator cend() const;

    virtual std::string serialize(Mode mode) const;

    unsigned int getSizeInBytes() const;
private:
    IndexedDataTree<AbstractState*> basisStateTree;
};

inline void BasisStateSet::add(const AbstractState &state){
    basisStateTree.add(
        state.clone(),
        state.getIndex()
    );
}

inline AbstractState& BasisStateSet::get(const Index &index){
    return *basisStateTree.get(index);
}

inline const AbstractState& BasisStateSet::get(const Index &index) const{
    return *basisStateTree.get(index);
}

inline unsigned int BasisStateSet::getSizeInBytes() const{
    TBTKNotYetImplemented("BasisStateSet::getSizeInBytes()");
}

template<bool isConstIterator>
BasisStateSet::_Iterator<isConstIterator>::_Iterator(
    BasisStateTreeType &basisStateTree,
    bool end
) :
        iterator(
        end ? basisStateTree.end() : basisStateTree.begin()
    ),
        iteratorEnd(basisStateTree.end())
{
}

template<bool isConstIterator>
void BasisStateSet::_Iterator<isConstIterator>::operator++(){
    if(iterator != iteratorEnd)
        ++iterator;
}

template<bool isConstIterator>
typename BasisStateSet::_Iterator<isConstIterator>::BasisStateReferenceType
BasisStateSet::_Iterator<isConstIterator>::operator*(){
    return *(*iterator);
}

template<bool isConstIterator>
bool BasisStateSet::_Iterator<isConstIterator>::operator==(
    const _Iterator<isConstIterator> &rhs
){
    if(iterator == rhs.iterator)
        return true;
    else
        return false;
}

template<bool isConstIterator>
bool BasisStateSet::_Iterator<isConstIterator>::operator!=(
    const _Iterator<isConstIterator> &rhs
){
    if(iterator != rhs.iterator)
        return true;
    else
        return false;
}

};  //End of namespace TBTK

#endif