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

    AliasMap(AliasMap const& other) : _internal(other._internal), _table() {}
    // 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;
 
    std::shared_ptr<BaseTable> getTable() const { return _table.lock(); }
    void setTable(std::shared_ptr<BaseTable> table) { _table = table; }
 
private:
    friend class Schema;
    friend class SubSchema;
 
    // 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.
    std::weak_ptr<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