SourceLocation.h

#ifndef ROSE_SourceLocation_H
#define ROSE_SourceLocation_H
 
#include <Rose/Location.h>
 
#include <boost/filesystem.hpp>
#include <Sawyer/Optional.h>
#include <Sawyer/Synchronization.h>
#include <ostream>
#include <string>
#include <rose_serialize_path.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#endif
 
#include <boost/shared_ptr.hpp>
#include <boost/unordered_set.hpp>
 
#ifdef ROSE_HAVE_CEREAL
#include <cereal/access.hpp>
#include <cereal/cereal.hpp>
#endif
 
namespace Rose {
 
class SourceLocation: public Location {
    using NamePtr = std::shared_ptr<boost::filesystem::path>;
    NamePtr fileName_;                                  // null iff default constructed
    size_t line_;
    Sawyer::Optional<size_t> column_;
 
    // Shared index for file names
    struct NameHasher { size_t operator()(const NamePtr&) const; };
    struct NameEquivalence { bool operator()(const NamePtr&, const NamePtr&) const; };
    using FileNames = boost::unordered_set<NamePtr, NameHasher, NameEquivalence>;
    static SAWYER_THREAD_TRAITS::Mutex classMutex_;     // protects the following static data members
    static FileNames fileNames_;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(fileName_);
        s & BOOST_SERIALIZATION_NVP(line_);
        s & BOOST_SERIALIZATION_NVP(column_);
        registerFileName();                             // necessary for de-serialization; okay to also call for serialization
    }
#endif
 
#ifdef ROSE_HAVE_CEREAL
private:
    friend class cereal::access;
 
    template<class Archive>
    void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &archive) {
        archive(cereal::make_nvp("fileName", fileName_));
        archive(cereal::make_nvp("line", line_));
        archive(cereal::make_nvp("column", column_));
    }
#endif
 
public:
    SourceLocation(): line_(0) {}
 
    SourceLocation(const boost::filesystem::path &fileName, size_t line, const Sawyer::Optional<size_t> &column = Sawyer::Nothing());
 
    static SourceLocation parse(const std::string&);
 
    virtual ~SourceLocation();
 
    virtual std::string toString() const override;
 
    virtual void print(std::ostream&) const override;
 
    virtual std::string printableName() const override;
 
    virtual bool isEqual(const Location&) const override;
 
    virtual bool operator<(const Location&) const override;
    virtual bool operator<=(const Location&) const override;
    virtual bool operator>(const Location&) const override;
    virtual bool operator>=(const Location&) const override;
    virtual bool isValid() const override;
 
    virtual const boost::filesystem::path& fileName() const;
 
    virtual size_t line() const {
        return line_;                                   // no lock necessary since *this is immutable
    }
    virtual size_t line() const  {…}
 
    virtual const Sawyer::Optional<size_t>& column() const {
        return column_;                                 // no lock necessary since *this is immutable
    }
    virtual const Sawyer::Optional<size_t>& column() const  {…}
 
private:
    // Compare two source locations like operator<=> in C++17
    int compare(const SourceLocation &other) const;
 
    // When reconstituting an object from a serialization, we need to make sure the file name is an element of the shared index.
    // It doesn't hurt to call this on any object at any time.
    void registerFileName();
};
class SourceLocation: public Location {…};
 
} // namespace
#endif