Rose/SourceLocation.h

#ifndef ROSE_SourceLocation_H
#define ROSE_SourceLocation_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>

namespace Rose {

class SourceLocation {
    typedef boost::shared_ptr<boost::filesystem::path> NamePtr;
    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; };
    typedef boost::unordered_set<NamePtr, NameHasher, NameEquivalence> FileNames;
    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, 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&);

    ~SourceLocation();

    bool isEmpty() const;
    
    const boost::filesystem::path& fileName() const;

    size_t line() const {
        return line_;                                   // no lock necessary since *this is immutable
    }

    const Sawyer::Optional<size_t>& column() const {
        return column_;                                 // no lock necessary since *this is immutable
    }
    
    bool operator==(const SourceLocation &other) const;
    bool operator!=(const SourceLocation &other) const {
        return !(*this == other);
    }
    int compare(const SourceLocation &other) const;
    bool operator<(const SourceLocation &other) const {
        return compare(other) < 0;
    }
    bool operator<=(const SourceLocation &other) const {
        return compare(other) <= 0;
    }
    bool operator>(const SourceLocation &other) const {
        return compare(other) > 0;
    }
    bool operator>=(const SourceLocation &other) const {
        return compare(other) >= 0;
    }
    std::string toString() const;

    std::string printableName() const;

    void print(std::ostream&) const;

    // The following trickery is to allow things like "if (x)" to work but without having an implicit
    // conversion to bool which would cause no end of other problems. This is fixed in C++11.
private:
    typedef void(SourceLocation::*unspecified_bool)() const;
    void this_type_does_not_support_comparisons() const {}
public:
    operator unspecified_bool() const {
        return isEmpty() ? 0 : &SourceLocation::this_type_does_not_support_comparisons;;
    }

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

std::ostream& operator<<(std::ostream&, const SourceLocation&);

} // namespace

#endif