Defect.h

#ifndef ROSE_AST_Defect_H
#define ROSE_AST_Defect_H
 
namespace Rose {
namespace AST {
 
namespace Defects {
 
  enum class Kind {
    any,                     
    integrity_edges,         
    integrity_declarations,  
    integrity_symbols,       
    integrity_types,         
  };
 
  template <Kind kind> struct defect_t;
 
  template <>
  struct defect_t<Kind::any> {
    using self_t = defect_t<Kind::any>;
 
    static std::set<self_t *> all;
 
    template <Kind k, typename... Args>
    static defect_t<k> const & record(Args... args) {
      defect_t<k> * defect = new defect_t<k>(args...);
      all.insert(defect);
      return *defect;
    }
 
    template <typename DefectT, typename... Args>
    static DefectT const & record(Args... args) {
      return record<DefectT::__kind>(args...);
    }
 
    Kind kind;
 
    defect_t<Kind::any>(Kind kind_);
    virtual ~defect_t<Kind::any>();
 
    static void clear(); 
    static void display(std::ostream & out); //<! Calls print on all stored defects
 
    virtual void print(std::ostream & out) const = 0;
  };
}
 
using Defect = Defects::defect_t<Defects::Kind::any>;
 
namespace Defects {
 
  template <>
  struct defect_t<Kind::integrity_edges> : defect_t<Kind::any> {
    static constexpr Kind __kind = Kind::integrity_edges; 
 
    SgNode * source;   
    SgNode * target;   
 
    std::string label; 
    bool traversed;    
    bool container;    
 
    VariantT expected; 
    VariantT found;    
 
    enum class Reason {
      invalid,         
      incompatible,    
      unallocated,     
    } reason;
 
    defect_t<Kind::integrity_edges>(
      SgNode * source_,
      SgNode * target_,
      std::string label_,
      bool traversed_,
      bool container_,
      VariantT expected_,
      VariantT found_,
      Reason reason_
    );
 
    virtual void print(std::ostream & out) const;
  };
}
using IntegrityEdgeDefect = Defects::defect_t<Defects::Kind::integrity_edges>;
 
} }
 
#endif