SourceLocation.h

#ifndef ROSE_SourceLocation_H
#define ROSE_SourceLocation_H

#include <Rose/Location.h>

#include <boost/filesystem.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/unordered_set.hpp>
#include <Sawyer/Optional.h>
#include <ostream>
#include <string>

namespace Rose {

class SourceLocation: public Location {
    using NamePtr = boost::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_;

private:
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
    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

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 const Sawyer::Optional<size_t>& column() const {
        return column_;                                 // no lock necessary since *this is immutable
    }

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();
};

} // namespace
#endif