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