Reference.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Reference_H
#define ROSE_BinaryAnalysis_Partitioner2_Reference_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <set>
 
class SgAsmInstruction;
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
//                                      Reference
 
class Reference {
    FunctionPtr function_;
    BasicBlockPtr bblock_;
    SgAsmInstruction *insn_;
    Sawyer::Optional<rose_addr_t> address_;
public:
    enum Granularity {
        EMPTY,                                      
        ADDRESS,                                    
        INSTRUCTION,                                
        BASIC_BLOCK,                                
        FUNCTION                                    
    };
 
    ~Reference();
 
    explicit Reference(const FunctionPtr&);
 
    explicit Reference(const FunctionPtr&, const BasicBlockPtr&,
                       SgAsmInstruction* = nullptr, const Sawyer::Optional<rose_addr_t>& = Sawyer::Nothing());
 
    explicit Reference(const BasicBlockPtr&, SgAsmInstruction* = nullptr, const Sawyer::Optional<rose_addr_t>& =Sawyer::Nothing());
 
    explicit Reference(SgAsmInstruction*, const Sawyer::Optional<rose_addr_t>& = Sawyer::Nothing());
 
    explicit Reference(rose_addr_t address);
 
    Reference();
    Granularity granularity() const;
 
    bool isEmpty() const;
 
    bool hasFunction() const;
 
    FunctionPtr function() const;
 
    bool hasBasicBlock() const;
 
    BasicBlockPtr basicBlock() const;
 
    bool hasInstruction() const;
 
    SgAsmInstruction* instruction() const;
 
    bool hasExplicitAddress() const;
 
    rose_addr_t address() const;
 
    bool operator==(const Reference &other) const;
 
    bool operator<(const Reference &other) const;
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif