feature.hpp

Go to the documentation of this file.

#pragma once
#include <absl/hash/hash.h>
 
#include "feature.pb.h"
 
#include "parser.hpp"
 
namespace dcn
{
 
    template <typename H>
    inline H AbslHashValue(H h, const TransformationDef & td) 
    {
        h = H::combine(std::move(h), td.name());
        for (const int32_t & arg : td.args()) {
            h = H::combine(std::move(h), arg);
        }
        return h;
    }
 
    template <typename H>
    inline H AbslHashValue(H h, const Dimension& d) 
    {
        h = H::combine(std::move(h), d.feature_name());
        for (const TransformationDef & t : d.transformations()) {
            h = H::combine(std::move(h), t);
        }
        return h;
    }
 
    template <typename H>
    inline H AbslHashValue(H h, const Feature& f) {
        h = H::combine(std::move(h), f.name());
        for (const Dimension & d : f.dimensions()) {
            h = H::combine(std::move(h), d);
        }
        return h;
    }
 
    std::string constructFeatureSolidityCode(const Feature & feature);
}
 
namespace dcn::parse
{
    std::optional<json> parseToJson(TransformationDef transform_def, use_json_t);
 
    template<>
    std::optional<TransformationDef> parseFromJson(json json, use_json_t);
 
    std::optional<json> parseToJson(Dimension dimension, use_json_t);
 
    template<>
    std::optional<Dimension> parseFromJson(json json, use_json_t);
 
    std::optional<std::string> parseToJson(Dimension dimension, use_protobuf_t);
 
    template<>
    std::optional<Dimension> parseFromJson(std::string json_str, use_protobuf_t);
    
    std::optional<json> parseToJson(Feature feature, use_json_t);
 
    template<>
    std::optional<Feature> parseFromJson(json json_obj, use_json_t);
 
    std::optional<std::string> parseToJson(Feature feature, use_protobuf_t);
 
    template<>
    std::optional<Feature> parseFromJson(std::string json_str, use_protobuf_t);
 
 
    std::optional<json> parseToJson(FeatureRecord feature, use_json_t);
    std::optional<std::string> parseToJson(FeatureRecord feature_record, use_protobuf_t);
 
    template<>
    std::optional<FeatureRecord> parseFromJson(json json_obj, use_json_t);
    
    template<>
    std::optional<FeatureRecord> parseFromJson(std::string json_str, use_protobuf_t);
}