AnnotatedArray.h

Go to the documentation of this file.

/* 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_ANNOTATED_ARRAY
#define COM_DAFER45_TBTK_ANNOTATED_ARRAY
 
#include "TBTK/Array.h"
 
namespace TBTK{
 
template<typename DataType, typename AxesType>
class AnnotatedArray : public Array<DataType>{
public:
    AnnotatedArray();
 
    AnnotatedArray(
        const Array<DataType> &array,
        const std::vector<std::vector<AxesType>> &axes
    );
 
    AnnotatedArray(
        const std::string &serialization,
        Serializable::Mode mode
    );
 
    const std::vector<std::vector<AxesType>>& getAxes() const;
 
    std::string serialize(Serializable::Mode mode) const;
private:
    std::vector<std::vector<AxesType>> axes;
};
 
template<typename DataType, typename AxesType>
AnnotatedArray<DataType, AxesType>::AnnotatedArray(){
}
 
template<typename DataType, typename AxesType>
AnnotatedArray<DataType, AxesType>::AnnotatedArray(
    const Array<DataType> &array,
    const std::vector<std::vector<AxesType>> &axes
) :
    Array<DataType>(array),
    axes(axes)
{
    const std::vector<unsigned int> &ranges = array.getRanges();
    TBTKAssert(
        ranges.size() == axes.size(),
        "AnnotatedArray::AnnotatedArray()",
        "Incompatible dimensions. 'array' has '" << ranges.size()
        << "' dimensions, while 'axes' have '" << axes.size() << "'"
        << " dimensions.",
        ""
    );
    for(unsigned int n = 0; n < ranges.size(); n++){
        TBTKAssert(
            ranges[n] == axes[n].size(),
            "AnnotatedArray::AnnotatedArray()",
            "Incompatible sizes. Dimension '" << n << " of 'array'"
            << " has size '" << ranges[n] << "', but axis '" << n
            << "' has size '" << axes[n].size() << "'.",
            ""
        );
    }
}
 
template<typename DataType, typename AxesType>
AnnotatedArray<DataType, AxesType>::AnnotatedArray(
    const std::string &serialization,
    Serializable::Mode mode
) :
    Array<DataType>(
        Serializable::extractComponent(
            serialization,
            "AnnotatedArray",
            "Array",
            "array",
            mode
        ),
        mode
    )
{
    TBTKAssert(
        Serializable::validate(serialization, "AnnotatedArray", mode),
        "AnnotatedArray::AnnotatedArray()",
        "Unable to parse string as AnnotatedArray '" << serialization
        << "'.",
        ""
    );
 
    switch(mode){
    case Serializable::Mode::JSON:
    {
        try{
            nlohmann::json j
                = nlohmann::json::parse(serialization);
            nlohmann::json jsonAxes = j.at("axes");
            for(
                nlohmann::json::iterator axisIterator
                    = jsonAxes.begin();
                axisIterator != jsonAxes.end();
                ++axisIterator
            ){
                unsigned int axisId
                    = atoi(axisIterator.key().c_str());
                for(unsigned int n = axes.size(); n <= axisId; n++)
                    axes.push_back(std::vector<AxesType>());
                for(
                    nlohmann::json::iterator iterator
                        = axisIterator->begin();
                    iterator != axisIterator->end();
                    ++iterator
                ){
                    axes.back().push_back(
                        Serializable::deserialize<
                            AxesType
                        >(*iterator, mode)
                    );
                }
            }
        }
        catch(nlohmann::json::exception &e){
            TBTKExit(
                "AnnotatedArray::AnnotatedArray()",
                "Unable to parse string as AnnotatedArray '"
                << serialization << "'.",
                ""
            );
        }
 
        break;
    }
    default:
        TBTKExit(
            "AnnotatedArray::AnnotatedArray()",
            "Unable to parse string as AnnotatedArray '"
            << serialization << "'.",
            ""
        );
    }
}
 
template<typename DataType, typename AxesType>
const std::vector<std::vector<AxesType>>& AnnotatedArray<
    DataType,
    AxesType
>::getAxes() const{
    return axes;
}
 
template<typename DataType, typename AxesType>
std::string AnnotatedArray<DataType, AxesType>::serialize(
    Serializable::Mode mode
) const{
    switch(mode){
    case Serializable::Mode::JSON:
    {
        nlohmann::json j;
        j["id"] = "AnnotatedArray";
        j["array"] = nlohmann::json::parse(
            Array<DataType>::serialize(mode)
        );
        j["axes"] = nlohmann::json();
        for(unsigned int n = 0; n < axes.size(); n++){
            std::string index = std::to_string(n);
            j["axes"][index] = nlohmann::json();
            for(unsigned int c = 0; c < axes[n].size(); c++){
                j["axes"][index].push_back(
                    Serializable::serialize(
                        axes[n][c],
                        mode
                    )
                );
            }
        }
 
        return j.dump();
    }
    default:
        TBTKExit(
            "AnnotatedArray::serialize()",
            "Only Serializable::Mode::JSON is supported yet.",
            ""
        );
    }
}
 
}; //End of namesapce TBTK
 
#endif