FrameDict.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2017 AURA/LSST.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <https://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef ASTSHIM_FRAMEDICT_H
#define ASTSHIM_FRAMEDICT_H
 
#include <cassert>
#include <memory>
#include <set>
#include <sstream>
#include <stdexcept>
#include <unordered_map>
 
#include "astshim/base.h"
#include "astshim/detail/utils.h"
#include "astshim/Frame.h"
#include "astshim/FrameSet.h"
 
namespace ast {
 
class FrameDict : public FrameSet {
    friend class Object;
 
public:
    explicit FrameDict(Frame const &frame, std::string const &options = "") : FrameSet(frame, options) {
        _domainIndexDict = _makeNewDict(*this);
    }
 
    explicit FrameDict(Frame const &baseFrame, Mapping const &mapping, Frame const &currentFrame,
                       std::string const &options = "")
            : FrameSet(baseFrame, mapping, currentFrame) {
        _domainIndexDict = _makeNewDict(*this);
    }
 
    explicit FrameDict(FrameSet const &frameSet) : FrameSet(frameSet), _domainIndexDict() {
        _domainIndexDict = _makeNewDict(*this);
    }
 
    virtual ~FrameDict() {}
 
    FrameDict(FrameDict const &) = default;
    FrameDict(FrameDict &&) = default;
    FrameDict &operator=(FrameDict const &) = delete;
    FrameDict &operator=(FrameDict &&) = default;
 
    std::shared_ptr<FrameDict> copy() const { return std::static_pointer_cast<FrameDict>(copyPolymorphic()); }
 
    void addFrame(int iframe, Mapping const &map, Frame const &frame) override;
 
    void addFrame(std::string const &domain, Mapping const &map, Frame const &frame);
 
    std::set<std::string> getAllDomains() const;
 
    using FrameSet::getFrame;
 
    std::shared_ptr<Frame> getFrame(std::string const &domain, bool copy = true) const {
        return getFrame(getIndex(domain), copy);
    }
 
    using FrameSet::getMapping;
 
    std::shared_ptr<Mapping> getMapping(int from, std::string const &to) const {
        return getMapping(from, getIndex(to));
    }
 
    std::shared_ptr<Mapping> getMapping(std::string const &from, int to) const {
        return getMapping(getIndex(from), to);
    }
 
    std::shared_ptr<Mapping> getMapping(std::string const &from, std::string const &to) const {
        return getMapping(getIndex(from), getIndex(to));
    }
 
    int getIndex(std::string const &domain) const {
        auto domainUpper = detail::stringToUpper(domain);
        auto it = _domainIndexDict.find(domainUpper);
        if (it == _domainIndexDict.end()) {
            throw std::out_of_range("No frame found with domain " + domain);
        }
        return it->second;
    }
 
    bool hasDomain(std::string const &domain) const { return _domainIndexDict.count(domain) > 0; }
 
    using FrameSet::mirrorVariants;
 
    void mirrorVariants(std::string const &domain) { mirrorVariants(getIndex(domain)); }
 
    using FrameSet::remapFrame;
 
    void remapFrame(std::string const &domain, Mapping &map) { remapFrame(getIndex(domain), map); }
 
    void removeFrame(int iframe) override;
 
    void removeFrame(std::string const &domain);
 
    using FrameSet::setBase;
 
    void setBase(std::string const &domain) { setBase(getIndex(domain)); }
 
    using FrameSet::setCurrent;
 
    void setCurrent(std::string const &domain) { setCurrent(getIndex(domain)); }
 
    void setDomain(std::string const &domain) override;
 
protected:
    virtual std::shared_ptr<Object> copyPolymorphic() const override {
        return copyImpl<FrameDict, AstFrameSet>();
    }
 
    std::shared_ptr<FrameSet> getFrameSet() const {
        return std::static_pointer_cast<FrameSet>(copyImpl<FrameSet, AstFrameSet>());
    }
 
    explicit FrameDict(AstFrameSet *rawptr);
 
private:
    /*
    Build a new domain:index dict from a FrameSet
    */
    static std::unordered_map<std::string, int> _makeNewDict(FrameSet const &frameSet);
 
    /*
    Update the internal data using the supplied frameSet, which is swapped with the old data.
 
    Build a new domain::index dict from frameSet. If successful, replace the current dict
    and swap frameSet with the old frame set data.
 
    If any exception is thrown this FrameDict (and the frameSet argument) is unchanged.
    */
    void _update(FrameSet &frameSet) {
        _domainIndexDict = _makeNewDict(frameSet);
        this->swapRawPointers(frameSet);
    }
 
    std::unordered_map<std::string, int> _domainIndexDict;  // Dict of frame domain:index
};
 
}  // namespace ast
 
#endif