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 {
    typedef std::map<std::string, std::string> Internal;

public:
    // Create an empty AliasMap
    AliasMap() : _internal(), _table(0) {}

    AliasMap(AliasMap const& other) : _internal(other._internal), _table(0) {}
    // Delegate to copy-constructor for backwards compatibility
    AliasMap(AliasMap&& other) : AliasMap(other) {}

    AliasMap& operator=(AliasMap const&) = default;
    AliasMap& operator=(AliasMap&&) = default;
    ~AliasMap() = default;

    typedef std::map<std::string, std::string>::const_iterator 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