validate.hpp

Go to the documentation of this file.

#ifndef CHIHAYA_VALIDATE_HPP
#define CHIHAYA_VALIDATE_HPP
 
#include "H5Cpp.h"
#include "ritsuko/ritsuko.hpp"
 
#include "subset.hpp"
#include "combine.hpp"
#include "transpose.hpp"
 
#include "dense_array.hpp"
#include "sparse_matrix.hpp"
#include "external_hdf5.hpp"
#include "custom_array.hpp"
#include "constant_array.hpp"
 
#include "dimnames.hpp"
#include "subset_assignment.hpp"
 
#include "unary_arithmetic.hpp"
#include "unary_comparison.hpp"
#include "unary_logic.hpp"
#include "unary_math.hpp"
#include "unary_special_check.hpp"
 
#include "binary_arithmetic.hpp"
#include "binary_comparison.hpp"
#include "binary_logic.hpp"
 
#include "matrix_product.hpp"
 
#include "utils_public.hpp"
 
#include <string>
#include <stdexcept>
#include <unordered_map>
#include <functional>
 
namespace chihaya {
 
inline auto default_operation_registry() {
    ValidateRegistry registry;
    registry["subset"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_subset(h, v, o); };
    registry["combine"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_combine(h, v, o); };
    registry["transpose"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_transpose(h, v, o); };
    registry["dimnames"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_dimnames(h, v, o); };
    registry["subset assignment"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_subset_assignment(h, v, o); };
    registry["unary arithmetic"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_unary_arithmetic(h, v, o); };
    registry["unary comparison"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_unary_comparison(h, v, o); };
    registry["unary logic"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_unary_logic(h, v, o); };
    registry["unary math"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_unary_math(h, v, o); };
    registry["unary special check"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_unary_special_check(h, v, o); };
    registry["binary arithmetic"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_binary_arithmetic(h, v, o); };
    registry["binary comparison"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_binary_comparison(h, v, o); };
    registry["binary logic"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_binary_logic(h, v, o); };
    registry["matrix product"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_matrix_product(h, v, o); };
    return registry;
}
 
inline auto default_array_registry() {
    ValidateRegistry registry;
    registry["dense array"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_dense_array(h, v, o); };
    registry["sparse matrix"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_sparse_matrix(h, v, o); };
    registry["constant array"] = [](const H5::Group& h, const ritsuko::Version& v, const Options& o) -> ArrayDetails { return validate_constant_array(h, v, o); };
    return registry;
}
inline ArrayDetails validate(const H5::Group& group, const ritsuko::Version& version, const Options& options) {
    std::string dtype;
    try {
        auto ahandle = group.openAttribute("delayed_type");
        dtype = read_scalar_string_attribute(ahandle);
    } catch (...) {
        std::throw_with_nested(std::runtime_error("failed to validate the 'delayed_type' attribute"));
    }
 
    ArrayDetails output;
    if (dtype == "array") {
        std::string atype;
        try {
            auto ahandle = group.openAttribute("delayed_array");
            atype = read_scalar_string_attribute(ahandle);
        } catch (...) {
            std::throw_with_nested(std::runtime_error("failed to validate the 'delayed_array' attribute"));
        }
 
        const auto& custom = options.array_validate_registry;
        auto cit = custom.find(atype);
        if (cit != custom.end()) {
            try {
                output = (cit->second)(group, version, options);
            } catch (...) {
                std::throw_with_nested(std::runtime_error("failed to validate delayed array of type '" + atype + "'"));
            }
 
        } else {
            static const auto global = default_array_registry();
            auto git = global.find(atype);
            if (git != global.end()) {
                try {
                    output = (git->second)(group, version, options);
                } catch (...) {
                    std::throw_with_nested(std::runtime_error("failed to validate delayed array of type '" + atype + "'"));
                }
 
            } else if (atype.rfind("custom ", 0) != std::string::npos) {
                try {
                    output = validate_custom_array(group, version, options);
                } catch (...) {
                    std::throw_with_nested(std::runtime_error("failed to validate delayed array of type '" + atype + "'"));
                }
 
            } else if (atype.rfind("external hdf5 ", 0) != std::string::npos && version.lt(1, 1, 0)) {
                try {
                    output = validate_external_hdf5(group, version, options);
                } catch (...) {
                    std::throw_with_nested(std::runtime_error("failed to validate delayed array of type '" + atype + "'"));
                }
 
            } else {
                throw std::runtime_error("unknown array type '" + atype + "'");
            }
        }
 
    } else if (dtype == "operation") {
        std::string otype;
        try {
            auto ohandle = group.openAttribute("delayed_operation");
            otype = read_scalar_string_attribute(ohandle);
        } catch (...) {
            std::throw_with_nested(std::runtime_error("failed to validate the 'delayed_operation' attribute"));
        }
 
        const auto& custom = options.operation_validate_registry;
        auto cit = custom.find(otype);
        if (cit != custom.end()) {
            try {
                output = (cit->second)(group, version, options);
            } catch (...) {
                std::throw_with_nested(std::runtime_error("failed to validate delayed operation of type '" + otype + "'"));
            }
 
        } else {
            static const auto global = default_operation_registry();
            auto git = global.find(otype);
            if (git != global.end()) {
                try {
                    output = (git->second)(group, version, options);
                } catch (...) {
                    std::throw_with_nested(std::runtime_error("failed to validate delayed operation of type '" + otype + "'"));
                }
 
            } else {
                throw std::runtime_error("unknown operation type '" + otype + "'");
            }
        }
 
    } else {
        throw std::runtime_error("unknown delayed type '" + dtype + "'");
    }
 
    return output;
}
 
inline ritsuko::Version extract_version(const H5::Group& group) {
    ritsuko::Version version;
 
    if (group.attrExists("delayed_version")) {
        try {
            auto vhandle = group.openAttribute("delayed_version");
            auto vstring = read_scalar_string_attribute(vhandle);
            if (vstring == "1.0.0") {
                version.major = 1;
            } else {
                version = ritsuko::parse_version_string(vstring.c_str(), vstring.size(), /* skip_patch = */ true);
            }
        } catch (...) {
            std::throw_with_nested(std::runtime_error("failed to validate the 'delayed_version' attribute"));
        }
    } else {
        version.minor = 99;
    }
 
    return version;
}
 
inline ArrayDetails validate(const H5::Group& group, const Options& options) {
    return validate(group, extract_version(group), options);
}
 
inline ArrayDetails validate(const std::string& path, const std::string& name, const Options& options) {
    try {
        H5::H5File handle(path, H5F_ACC_RDONLY);
        auto ghandle = handle.openGroup(name);
        return validate(ghandle, options);
    } catch (...) {
        std::throw_with_nested(std::runtime_error("failed to validate '" + name + "' in '" + path + "'"));
    }
}
 
inline ArrayDetails validate(const std::string& path, const std::string& name) {
    return validate(path, name, {});
}
 
}
 
#endif