IndexDescriptor.h

Go to the documentation of this file.

/* 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_INDEX_DESCRIPTOR
#define COM_DAFER45_TBTK_INDEX_DESCRIPTOR
 
#include "TBTK/IndexedDataTree.h"
#include "TBTK/IndexException.h"
#include "TBTK/IndexTree.h"
#include "TBTK/Serializable.h"
#include "TBTK/TBTKMacros.h"
 
namespace TBTK{
 
class IndexDescriptor : public Serializable{
public:
    enum class Format {None, Ranges, Custom, Dynamic};
 
    IndexDescriptor();
 
    IndexDescriptor(const std::vector<int> &ranges);
 
    IndexDescriptor(const IndexTree &indexTree);
 
    IndexDescriptor(const IndexDescriptor &indexDescriptor);
 
    IndexDescriptor(IndexDescriptor &&indexDescriptor);
 
    IndexDescriptor(const std::string &serialization, Mode mode);
 
    ~IndexDescriptor();
 
    IndexDescriptor& operator=(const IndexDescriptor &rhs);
 
    IndexDescriptor& operator=(IndexDescriptor &&rhs);
 
    friend bool operator==(
        const IndexDescriptor &lhs,
        const IndexDescriptor &rhs
    );
 
    friend bool operator!=(
        const IndexDescriptor &lhs,
        const IndexDescriptor &rhs
    );
 
    Format getFormat() const;
 
    std::vector<int> getRanges() const;
 
    const IndexTree& getIndexTree() const;
 
    void add(const Index &index);
 
    int getLinearIndex(
        const Index &index,
        bool returnNegativeForMissingIndex = false
    ) const;
 
    unsigned int getSize() const;
 
    bool contains(const Index &index) const;
 
    virtual std::string serialize(Mode mode) const;
private:
    Format format;
 
    class NoneFormat{
    public:
    };
 
    class RangeFormat{
    public:
        unsigned int dimensions;
 
        int *ranges;
    };
 
    class CustomFormat{
    public:
        IndexTree *indexTree;
    };
 
    class DynamicFormat{
    public:
        IndexedDataTree<unsigned int> *indexedDataTree;
 
        unsigned int size;
    };
 
    union Descriptor{
        NoneFormat noneFormat;
        RangeFormat rangeFormat;
        CustomFormat customFormat;
        DynamicFormat dynamicFormat;
    };
 
    Descriptor descriptor;
};
 
inline bool operator!=(const IndexDescriptor &lhs, const IndexDescriptor &rhs){
    return !(rhs == lhs);
}
 
inline IndexDescriptor::Format IndexDescriptor::getFormat() const{
    return format;
}
 
inline std::vector<int> IndexDescriptor::getRanges() const{
    TBTKAssert(
        format == Format::Ranges,
        "IndexDescriptor::setDimensions()",
        "The IndexDescriptor is not of the format Format::Ranges.",
        ""
    );
 
    std::vector<int> ranges;
    for(unsigned int n = 0; n < descriptor.rangeFormat.dimensions; n++)
        ranges.push_back(descriptor.rangeFormat.ranges[n]);
 
    return ranges;
}
 
inline const IndexTree& IndexDescriptor::getIndexTree() const{
    TBTKAssert(
        format == Format::Custom,
        "IndexDescriptor::getIndexTree()",
        "The IndexDescriptor is not of the format Format::Custom.",
        ""
    );
 
    return *descriptor.customFormat.indexTree;
}
 
inline void IndexDescriptor::add(const Index &index){
    TBTKAssert(
        format == Format::Dynamic,
        "IndexDescriptor::add()",
        "The IndexDescriptor is not of the format Format::Dynamic.",
        ""
    );
 
    unsigned int dummy;
    TBTKAssert(
        !descriptor.dynamicFormat.indexedDataTree->get(dummy, index),
        "IndexDescriptor::add()",
        "The IndexDescriptor already contains the Index '"
        << index.toString() << "'.",
        ""
    );
 
    descriptor.dynamicFormat.indexedDataTree->add(
        descriptor.dynamicFormat.size,
        index
    );
    descriptor.dynamicFormat.size++;
}
 
inline int IndexDescriptor::getLinearIndex(
    const Index &index,
    bool returnNegativeForMissingIndex
) const{
    switch(format){
    case Format::Custom:
        return descriptor.customFormat.indexTree->getLinearIndex(
            index,
            IndexTree::SearchMode::MatchWildcards,
            returnNegativeForMissingIndex
        );
    case Format::Dynamic:
    {
        unsigned int linearIndex;
        if(
            descriptor.dynamicFormat.indexedDataTree->get(
                linearIndex,
                index
            )
        ){
            return linearIndex;
        }
        else if(returnNegativeForMissingIndex){
            return -1;
        }
        else{
            throw IndexException(
                "IndexDescriptor::getLinearIndex()",
                TBTKWhere,
                "Index not included in the IndexDescriptor '"
                + index.toString() + "'.",
                ""
            );
        }
    }
    default:
        TBTKExit(
            "IndexDescriptor::getOffset()",
            "The IndexDescriptor is not of the format"
            " Format::Custom or Format::Dynamic.",
            ""
        );
    }
}
 
inline bool IndexDescriptor::contains(const Index &index) const{
    switch(format){
    case Format::Custom:
        if(
            descriptor.customFormat.indexTree->getLinearIndex(
                index,
                IndexTree::SearchMode::StrictMatch,
                true
            ) == -1
        ){
            return false;
        }
        else{
            return true;
        }
    case Format::Dynamic:
    {
        unsigned int dummy;
        if(
            descriptor.dynamicFormat.indexedDataTree->get(
                dummy,
                index
            )
        ){
            return true;
        }
        else{
            return false;
        }
    }
    default:
        TBTKExit(
            "IndexDescriptor::contains()",
            "The IndexDescriptor is not of the format"
            " Format::Custom or Format::Dynamic.",
            ""
        );
    }
}
 
};  //End namespace TBTK
 
#endif