metatile_attribute_inference.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <unordered_set>
#include <vector>
 
#include "gsl/pointers"
 
#include "porytiles/domain/config/metatile_attribute_field_definition.hpp"
 
namespace porytiles {
 
class TextFormatter;
 
inline constexpr auto metatile_attr_inference_tag = "metatile-attribute-inference";
 
struct InferenceEnumMember {
    std::string name;
    std::optional<std::int64_t> value;
};
 
struct InferenceDefine {
    std::string name;
    std::uint32_t value;
};
 
struct InferenceArrayEntry {
    std::string index_name;
    std::optional<std::uint32_t> value;
};
 
enum class BehaviorsHeaderSource {
    absent,       
    unreadable,   
    no_constants, 
    declared,     
};
 
struct BehaviorsHeaderScan {
    BehaviorsHeaderSource source{BehaviorsHeaderSource::absent};
    std::string path; 
};
 
enum class AttributeDeclarationSource {
    no_fieldmap_header,   
    header_unreadable,    
    no_tileset_struct,    
    no_attributes_member, 
    declared,             
};
 
struct AttributeDeclarationScan {
    AttributeDeclarationSource source{AttributeDeclarationSource::no_fieldmap_header};
    std::string element_type;
    std::size_t pointer_depth{0};
    bool is_const{false};
};
 
[[nodiscard]] std::string to_declaration_string(const AttributeDeclarationScan &scan);
 
struct MetatileAttributeScan {
    std::vector<InferenceEnumMember> enum_members; 
    std::vector<InferenceDefine> defines;          
    std::unordered_set<std::string>
        ambiguous_defines; 
    std::vector<InferenceArrayEntry> masks_array; 
    std::vector<InferenceArrayEntry>
        shifts_array;                     
    BehaviorsHeaderScan behaviors_header; 
    AttributeDeclarationScan declaration; 
    std::string header_source;      
    std::string masks_table_source; 
    std::vector<std::string>
        unreadable_sources; 
};
 
enum class FieldConflictKind {
    provider_behaviors_absent,       
    provider_behaviors_unreadable,   
    provider_behaviors_no_constants, 
    provider_no_matching_enum,       
    mask_define_vs_table,            
    shift_vs_mask,                   
};
 
struct InferredFieldConflict {
    std::string field_name;
    FieldConflictKind kind;
    std::string probed;                     
    std::optional<std::uint32_t> declared;  
    std::optional<std::uint32_t> alternate; 
};
 
struct MetatileAttributeCandidateSet {
    std::string origin;
    std::string source;
    MetatileAttributeFieldDefinitions fields;
    std::size_t required_bytes{2};
    std::vector<InferredFieldConflict> conflicts;
};
 
enum class AttributeInferenceStatus {
    valid,        
    invalid,      
    not_provided, 
};
 
struct InferredAttributeDeclaration {
    AttributeDeclarationScan scan;
    std::optional<std::size_t> size;
};
 
struct MetatileAttributeInferenceResult {
    AttributeInferenceStatus status{AttributeInferenceStatus::not_provided};
    std::vector<MetatileAttributeCandidateSet> candidates;
    std::string error_message;
    InferredAttributeDeclaration declaration;
    std::vector<std::string> unrecognized_defines;
};
 
[[nodiscard]] MetatileAttributeInferenceResult
infer_metatile_attribute_candidates(const MetatileAttributeScan &scan, gsl::not_null<const TextFormatter *> format);
 
} // namespace porytiles