AliasMap.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
#ifndef AFW_TABLE_AliasMap_h_INCLUDED
#define AFW_TABLE_AliasMap_h_INCLUDED
 
#include <map>
#include <string>
 
namespace lsst {
namespace afw {
namespace table {
 
class BaseTable;
 
class AliasMap final {
    using Internal = std::map<std::string, std::string>;
 
public:
    // Create an empty AliasMap
    AliasMap() : _internal(), _table(nullptr) {}
 
    AliasMap(AliasMap const& other) : _internal(other._internal), _table(nullptr) {}
    // Delegate to copy-constructor for backwards compatibility
    AliasMap(AliasMap&& other) : AliasMap(other) {}
 
    AliasMap& operator=(AliasMap const&) = default;
    AliasMap& operator=(AliasMap&&) = default;
    ~AliasMap() = default;
 
    using Iterator = std::map<std::string, std::string>::const_iterator;
 
    Iterator begin() const { return _internal.begin(); }
 
    Iterator end() const { return _internal.end(); }
 
    std::size_t size() const { return _internal.size(); }
 
    bool empty() const { return _internal.empty(); }
 
    std::string apply(std::string const& name) const;
 
    std::string get(std::string const& alias) const;
 
    void set(std::string const& alias, std::string const& target);
 
    bool erase(std::string const& alias);
 
 
    bool operator==(AliasMap const& other) const;
    bool operator!=(AliasMap const& other) const { return !(other == *this); }
 
    std::size_t hash_value() const noexcept;
 
    bool contains(AliasMap const& other) const;
 
private:
    friend class Schema;
    friend class SubSchema;
    friend class BaseTable;
 
    // Internal in-place implementation of apply()
    void _apply(std::string& name) const;
 
    Internal _internal;
 
    // Table to notify of any changes.  We can't use a shared_ptr here because the Table needs to set
    // this in its own constructor, but the Table does guarantee that this pointer is either valid or
    // null.
    BaseTable* _table;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
namespace std {
template <>
struct hash<lsst::afw::table::AliasMap> {
    using argument_type = lsst::afw::table::AliasMap;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std
 
#endif  // !AFW_TABLE_AliasMap_h_INCLUDED