Serializable.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_SERIALIZABLE
#define COM_DAFER45_TBTK_SERIALIZABLE
 
#include "TBTK/SpinMatrix.h"
#include "TBTK/Statistics.h"
#include "TBTK/TBTKMacros.h"
 
#include <complex>
#include <sstream>
#include <type_traits>
#include <vector>
 
namespace TBTK{
 
//Forward declaration of classes that are pseudo-Serializable (that implements
//the Serializable interface non-virtually).
class Index;
class HoppingAmplitude;
template<typename DataType> class CArray;
 
class Serializable{
public:
    enum class Mode {Debug, Binary, XML, JSON};
 
    virtual std::string serialize(Mode mode) const = 0;
 
    static bool hasID(const std::string &serialization, Mode mode);
 
    static std::string getID(const std::string &serialization, Mode mode);
 
    static std::string extractComponent(
        const std::string &serialization,
        const std::string &containerID,
        const std::string &componentID,
        const std::string &componentName,
        Mode mode
    );
protected:
    static bool validate(
        const std::string &serialization,
        const std::string &id,
        Mode mode
    );
 
    static std::string getContent(
        const std::string &serialization,
        Mode mode
    );
 
    static std::vector<std::string> split(
        const std::string &content,
        Mode mode
    );
 
    template<typename DataType>
    static typename std::enable_if<!std::is_pointer<DataType>::value, std::string>::type serialize(const DataType &data, Mode mode);
    template<typename DataType>
    static typename std::enable_if<std::is_pointer<DataType>::value, std::string>::type serialize(const DataType &data, Mode mode);
 
    template<typename DataType>
    static DataType deserialize(
        const std::string &serialization,
        Mode mode
    );
private:
    static std::string _serialize(bool b, Mode mode);
 
    static void _deserialize(
        const std::string &serialization,
        bool *b,
        Mode mode
    );
 
    static std::string _serialize(int i, Mode mode);
 
    static void _deserialize(
        const std::string &serialization,
        int *i,
        Mode mode
    );
 
    static std::string _serialize(unsigned int u, Mode mode);
 
    static void _deserialize(
        const std::string &serialization,
        unsigned int *u,
        Mode mode
    );
 
    static std::string _serialize(double d, Mode mode);
 
    static void _deserialize(
        const std::string &serialization,
        double *d,
        Mode mode
    );
 
    static std::string _serialize(std::complex<double> c, Mode mode);
 
    static void _deserialize(
        const std::string &serialization,
        std::complex<double> *c,
        Mode mode
    );
 
    static std::string _serialize(Statistics s, Mode mode);
 
    static void _deserialize(
        const std::string &serialization,
        Statistics *s,
        Mode mode
    );
protected:
    static std::string extract(
        const std::string &serialization,
        Mode mode,
        std::string component
    );
 
    friend class Index;
    friend class HoppingAmplitude;
    friend class SourceAmplitude;
    friend class OverlapAmplitude;
    template<typename DataType> friend class CArray;
};
 
//#ifndef TBTK_DISABLE_NLOHMANN_JSON
template<typename DataType>
typename std::enable_if<!std::is_pointer<DataType>::value, std::string>::type Serializable::serialize(const DataType &data, Mode mode){
    return data.serialize(mode);
}
 
template<typename DataType>
typename std::enable_if<std::is_pointer<DataType>::value, std::string>::type Serializable::serialize(const DataType &data, Mode mode){
    return data->serialize(mode);
}
/*template<typename DataType>
typename std::enable_if<true, std::string>::type Serializable::serialize(const DataType &data, Mode mode){
    return data->serialize(mode);
}*/
//#endif
 
template<>
inline std::string Serializable::serialize(const bool &data, Mode mode){
    return _serialize(data, mode);
}
 
template<>
inline std::string Serializable::serialize(const double &data, Mode mode){
    return _serialize(data, mode);
}
 
template<>
inline std::string Serializable::serialize(
    const std::complex<double> &data,
    Mode mode
){
    return _serialize(data, mode);
}
 
template<>
inline std::string Serializable::serialize(const int &data, Mode mode){
    return _serialize(data, mode);
}
 
template<>
inline std::string Serializable::serialize(const unsigned int &data, Mode mode){
    return _serialize(data, mode);
}
 
template<>
inline std::string Serializable::serialize(const SpinMatrix &data, Mode mode){
    TBTKNotYetImplemented("Serializable::serialize<SpinMatrix>()");
}
 
template<>
inline std::string Serializable::serialize(const Statistics &data, Mode mode){
    return _serialize(data, mode);
}
 
template<>
inline std::string Serializable::serialize(
    const std::vector<std::complex<double>> &data,
    Mode mode
){
    TBTKNotYetImplemented(
        "Serializable::serialize<std::vector<std::complex<double>>>()"
    );
}
 
template<typename DataType>
DataType Serializable::deserialize(const std::string &serialization, Mode mode){
    return DataType(serialization, mode);
}
 
template<>
inline int Serializable::deserialize(const std::string &serialization, Mode mode){
    int i;
    _deserialize(serialization, &i, mode);
    return i;
}
 
template<>
inline unsigned int Serializable::deserialize(const std::string &serialization, Mode mode){
    unsigned int i;
    _deserialize(serialization, &i, mode);
    return i;
}
 
template<>
inline double Serializable::deserialize(const std::string &serialization, Mode mode){
    double d;
    _deserialize(serialization, &d, mode);
    return d;
}
 
template<>
inline std::complex<double> Serializable::deserialize(
    const std::string &serialization,
    Mode mode
){
    std::complex<double> c;
    _deserialize(serialization, &c, mode);
    return c;
}
 
template<>
inline SpinMatrix Serializable::deserialize(
    const std::string &serialization,
    Mode mode
){
    TBTKNotYetImplemented("Serializable::deserialize<SpinMatrix>()");
}
 
template<>
inline Statistics Serializable::deserialize(
    const std::string &serialization,
    Mode mode
){
    Statistics s;
    _deserialize(serialization, &s, mode);
    return s;
}
 
template<>
inline std::vector<std::complex<double>> Serializable::deserialize(
    const std::string &serialization,
    Mode mode
){
    TBTKNotYetImplemented(
        "Serializable::deserialize<std::vector<std::complex<double>>>()"
    );
}
 
inline std::string Serializable::_serialize(bool b, Mode mode){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss << b;
 
        return ss.str();
    }
    default:
        TBTKExit(
            "Serializable::serialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline void Serializable::_deserialize(
    const std::string &serialization,
    bool *b,
    Mode mode
){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss.str(serialization);
        ss >> *b;
 
        break;
    }
    default:
        TBTKExit(
            "Serializable::deserialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline std::string Serializable::_serialize(int i, Mode mode){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss << i;
 
        return ss.str();
    }
    default:
        TBTKExit(
            "Serializable::serialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline void Serializable::_deserialize(
    const std::string &serialization,
    int *i,
    Mode mode
){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss.str(serialization);
        ss >> *i;
 
        break;
    }
    default:
        TBTKExit(
            "Serializable::deserialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline std::string Serializable::_serialize(unsigned int u, Mode mode){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss << u;
 
        return ss.str();
    }
    default:
        TBTKExit(
            "Serializable::serialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline void Serializable::_deserialize(
    const std::string &serialization,
    unsigned int *u,
    Mode mode
){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss.str(serialization);
        ss >> *u;
 
        break;
    }
    default:
        TBTKExit(
            "Serializable::deserialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline std::string Serializable::_serialize(double d, Mode mode){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss << d;
 
        return ss.str();
    }
    default:
        TBTKExit(
            "Serializable::serialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline void Serializable::_deserialize(
    const std::string &serialization,
    double *d,
    Mode mode
){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss.str(serialization);
        ss >> *d;
 
        break;
    }
    default:
        TBTKExit(
            "Serializable::deserialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline std::string Serializable::_serialize(std::complex<double> c, Mode mode){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss << c;
 
        return ss.str();
    }
    default:
        TBTKExit(
            "Serializable::serialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline void Serializable::_deserialize(
    const std::string &serialization,
    std::complex<double> *c,
    Mode mode
){
    switch(mode){
    case Mode::Debug:
    case Mode::JSON:
    {
        std::stringstream ss;
        ss.str(serialization);
        ss >> *c;
 
        break;
    }
    default:
        TBTKExit(
            "Serializable::deserialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline std::string Serializable::_serialize(Statistics statistics, Mode mode){
    switch(mode){
    case Mode::Debug:
    {
        std::stringstream ss;
        switch(statistics){
        case Statistics::FermiDirac:
        case Statistics::BoseEinstein:
            ss << static_cast<int>(statistics);
            break;
        default:
            TBTKExit(
                "Serializable::serialize()",
                "Unknown Statistics type '" << static_cast<int>(statistics) << "'",
                "This should never happen, contact the developer."
            );
        }
 
        return ss.str();
    }
    case Mode::JSON:
    {
        std::stringstream ss;
        switch(statistics){
        case Statistics::FermiDirac:
            ss << "FermiDirac";
            break;
        case Statistics::BoseEinstein:
            ss << "BoseEinstein";
            break;
        default:
            TBTKExit(
                "Serializable::serialize()",
                "Unknown Statistics type '" << static_cast<int>(statistics) << "'",
                "This should never happen, contact the developer."
            );
        }
 
        return ss.str();
    }
    default:
        TBTKExit(
            "Serializable::serialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
inline void Serializable::_deserialize(
    const std::string &serialization,
    Statistics *statistics,
    Mode mode
){
    switch(mode){
    case Mode::Debug:
    {
        std::stringstream ss;
        ss.str(serialization);
        int i;
        ss >> i;
        switch(i){
        case static_cast<int>(Statistics::FermiDirac):
            *statistics = Statistics::FermiDirac;
            break;
        case static_cast<int>(Statistics::BoseEinstein):
            *statistics = Statistics::BoseEinstein;
            break;
        default:
            TBTKExit(
                "Serializable::serialize()",
                "Unknown Statistics type '" << i << "'",
                "The serialization string is either corrupted"
                << " or the the serialization was created with"
                << " a newer version of TBTK that supports"
                << " more types of Statistics."
            );
        }
 
        break;
    }
    case Mode::JSON:
    {
        if(serialization.compare("FermiDirac") == 0){
            *statistics = Statistics::FermiDirac;
        }
        else if(serialization.compare("BoseEinstein") == 0){
            *statistics = Statistics::BoseEinstein;
        }
        else{
            TBTKExit(
                "Serializable::serialize()",
                "Unknown Statistics type '" << serialization
                << "'",
                "The serialization string is either corrupted"
                << " or the the serialization was created with"
                << " a newer version of TBTK that supports"
                << " more types of Statistics."
            );
        }
 
        break;
    }
    default:
        TBTKExit(
            "Serializable::deserialize()",
            "Only Mode::Debug is supported yet.",
            ""
        );
    }
}
 
};  //End namespace TBTK
 
#endif