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