KeyMap.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_KEYMAP_H
#define ASTSHIM_KEYMAP_H

#include <complex>
#include <ostream>
#include <memory>

#include "astshim/base.h"
#include "astshim/Channel.h"
#include "astshim/Object.h"

namespace ast {

namespace {

void throwKeyNotFound(std::string const &key) {
    // make sure there isn't some other error, first
    assertOK();
    std::ostringstream os;
    os << "Key \"" << key << "\" not found or has an undefined value";
    throw std::runtime_error(os.str());
}

}  // namespace

class KeyMap : public Object {
    friend class Object;
    friend class Channel;

public:
    explicit KeyMap(std::string const &options = "")
            : Object(reinterpret_cast<AstObject *>(astKeyMap("%s", options.c_str()))) {
        assertOK();
    }

    virtual ~KeyMap(){};

    KeyMap(KeyMap const &) = default;
    KeyMap(KeyMap &&) = default;
    KeyMap &operator=(KeyMap const &) = delete;
    KeyMap &operator=(KeyMap &&) = default;

    std::shared_ptr<KeyMap> copy() const {
        return std::static_pointer_cast<KeyMap>(copyPolymorphic());
        assertOK();
    }

    bool defined(std::string const &key) const {
        bool ret = static_cast<bool>(
                astMapDefined(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str()));
        assertOK();
        return ret;
    }

    std::string key(int ind) const {
        int const len = size();
        if ((ind < 0) || (ind >= len)) {
            std::ostringstream os;
            os << "ind = " << ind << " not in range [0, " << len - 1 << "]";
            throw std::invalid_argument(os.str());
        }
        const char *rawKey = astMapKey(reinterpret_cast<AstKeyMap const *>(getRawPtr()), ind);
        assertOK();
        return std::string(rawKey);
    }

    bool hasKey(std::string const &key) const {
        bool ret = static_cast<bool>(
                astMapHasKey(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str()));
        assertOK();
        return ret;
    }

    int length(std::string const &key) const {
        int len = astMapLength(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str());
        assertOK();
        return len;
    }

    int size() const {
        int const size = astMapSize(reinterpret_cast<AstKeyMap const *>(getRawPtr()));
        assertOK();
        return size;
    }

    double getD(std::string const &key, int ind) const {
        double retVal;
        if (!astMapGetElemD(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), ind, &retVal)) {
            throwKeyNotFound(key);
        }
        assertOK();
        return retVal;
    }

    std::vector<double> getD(std::string const &key) const {
        int const size = length(key);
        std::vector<double> retVec(size);
        if (size > 0) {
            int nret;  // should equal size after the call
            astMapGet1D(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), size, &nret,
                        retVec.data());
        }
        assertOK();
        return retVec;
    }

    float getF(std::string const &key, int ind) const {
        float retVal;
        if (!astMapGetElemF(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), ind, &retVal)) {
            throwKeyNotFound(key);
        }
        assertOK();
        return retVal;
    }

    std::vector<float> getF(std::string const &key) const {
        int const size = length(key);
        std::vector<float> retVec(size);
        if (size > 0) {
            int nret;  // should equal size after the call
            astMapGet1F(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), size, &nret,
                        retVec.data());
        }
        assertOK();
        return retVec;
    }

    int getI(std::string const &key, int ind) const {
        int retVal;
        if (!astMapGetElemI(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), ind, &retVal)) {
            throwKeyNotFound(key);
        }
        assertOK();
        return retVal;
    }

    std::vector<int> getI(std::string const &key) const {
        int const size = length(key);
        std::vector<int> retVec(size);
        if (size > 0) {
            int nret;  // should equal size after the call
            astMapGet1I(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), size, &nret,
                        retVec.data());
        }
        assertOK();
        return retVec;
    }

    short int getS(std::string const &key, int ind) const {
        short int retVal;
        if (!astMapGetElemS(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), ind, &retVal)) {
            throwKeyNotFound(key);
        }
        assertOK();
        return retVal;
    }

    std::vector<short int> getS(std::string const &key) const {
        int const size = length(key);
        std::vector<short int> retVec(size);
        if (size > 0) {
            int nret;  // should equal size after the call
            astMapGet1S(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), size, &nret,
                        retVec.data());
        }
        assertOK();
        return retVec;
    }

    char unsigned getB(std::string const &key, int ind) const {
        char unsigned retVal;
        if (!astMapGetElemB(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), ind, &retVal)) {
            throwKeyNotFound(key);
        }
        assertOK();
        return retVal;
    }

    std::vector<char unsigned> getB(std::string const &key) const {
        int const size = length(key);
        std::vector<char unsigned> retVec(size);
        if (size > 0) {
            int nret;  // should equal size after the call
            astMapGet1B(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), size, &nret,
                        retVec.data());
        }
        assertOK();
        return retVec;
    }

    std::string getC(std::string const &key, int ind) const {
        int const maxChar = 1 + astMapLenC(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str());
        std::unique_ptr<char[]> cstr(new char[maxChar]);
        if (!astMapGetElemC(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), maxChar, ind,
                            cstr.get())) {
            throwKeyNotFound(key);
        }
        assertOK();
        return std::string(cstr.get());
    }

    std::vector<std::string> getC(std::string const &key) const {
        int const size = length(key);
        std::vector<std::string> retVec;
        if (size > 0) {
            // # of chars for each entry; the +1 is needed to provide space for the terminating null
            int const eltLen = 1 + astMapLenC(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str());
            std::unique_ptr<char[]> cstr(new char[size * eltLen]);
            int nret;  // should equal size after the call
            astMapGet1C(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), eltLen, size, &nret,
                        cstr.get());
            for (int i = 0; i < size; ++i) {
                retVec.push_back(std::string(cstr.get() + i * eltLen));
            }
        }
        assertOK();
        return retVec;
    }

    std::shared_ptr<Object> getA(std::string const &key, int ind) const {
        std::shared_ptr<Object> retVal;
        AstObject *rawObj;
        if (!astMapGetElemA(reinterpret_cast<AstKeyMap const *>(getRawPtr()), key.c_str(), ind, &rawObj)) {
            throwKeyNotFound(key);
        }
        assertOK();
        return Object::fromAstObject<Object>(rawObj, true);
    }

    std::vector<std::shared_ptr<Object>> getA(std::string const &key) const {
        int const size = length(key);
        std::vector<std::shared_ptr<Object>> retVec;
        for (int i = 0; i < size; ++i) {
            retVec.push_back(getA(key, i));
        }
        return retVec;
    }

    void putD(std::string const &key, double value, std::string const &comment = "") {
        astMapPut0D(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

    void putD(std::string const &key, std::vector<double> const &vec, std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1D(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

    void putF(std::string const &key, float value, std::string const &comment = "") {
        astMapPut0F(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

    void putF(std::string const &key, std::vector<float> const &vec, std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1F(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

    void putI(std::string const &key, int value, std::string const &comment = "") {
        astMapPut0I(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

    void putI(std::string const &key, std::vector<int> const &vec, std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1I(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

    void putS(std::string const &key, short int value, std::string const &comment = "") {
        astMapPut0S(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

    void putS(std::string const &key, std::vector<short int> const &vec, std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1S(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

    void putB(std::string const &key, char unsigned value, std::string const &comment = "") {
        astMapPut0B(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

    void putB(std::string const &key, std::vector<char unsigned> const &vec,
              std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1B(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

    void putC(std::string const &key, std::string const &value, std::string const &comment = "") {
        astMapPut0C(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value.c_str(), comment.c_str());
        assertOK();
    }

    void putC(std::string const &key, std::vector<std::string> const &vec, std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        // to simplify memory management, create the key with the first element and append the rest
        for (int i = 0, size = vec.size(); i < size; ++i) {
            if (i == 0) {
                putC(key, vec[0]);
            } else {
                append(key, vec[i]);
            }
        }
    }

    void putA(std::string const &key, Object const &obj, std::string const &comment = "") {
        AstObject *rawCopy = reinterpret_cast<AstObject *>(astCopy(obj.getRawPtr()));
        astMapPut0A(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), rawCopy, comment.c_str());
        assertOK(rawCopy);
    }

    void putA(std::string const &key, std::vector<std::shared_ptr<Object const>> const &vec,
              std::string const &comment = "") {
        _assertVectorNotEmpty(key, vec.size());
        // to simplify memory management, create the key with the first element and append the rest
        for (int i = 0, size = vec.size(); i < size; ++i) {
            if (i == 0) {
                // initialize the key with the first element
                putA(key, *vec[0]);
            } else {
                append(key, *vec[i]);
            }
        }
    }

    void putU(std::string const &key, std::string const &comment = "") {
        astMapPutU(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), comment.c_str());
        assertOK();
    }

    void append(std::string const &key, double value) {
        int const i = _getAppendIndex(key);
        astMapPutElemD(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void append(std::string const &key, float value) {
        int const i = _getAppendIndex(key);
        astMapPutElemF(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void append(std::string const &key, int value) {
        int const i = _getAppendIndex(key);
        astMapPutElemI(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void append(std::string const &key, short int value) {
        int const i = _getAppendIndex(key);
        astMapPutElemS(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void append(std::string const &key, char unsigned value) {
        int const i = _getAppendIndex(key);
        astMapPutElemB(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void append(std::string const &key, std::string const &value) {
        int const i = _getAppendIndex(key);
        astMapPutElemC(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value.c_str());
        assertOK();
    }

    void append(std::string const &key, Object const &value) {
        int const i = _getAppendIndex(key);
        AstObject *rawCopy = reinterpret_cast<AstObject *>(astCopy(value.getRawPtr()));
        astMapPutElemA(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, rawCopy);
        assertOK(rawCopy);
    }

    void replace(std::string const &key, int i, double value) {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemD(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void replace(std::string const &key, int i, float value) {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemF(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void replace(std::string const &key, int i, int value) {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemI(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void replace(std::string const &key, int i, short int value) {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemS(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void replace(std::string const &key, int i, char unsigned value) {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemB(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

    void replace(std::string const &key, int i, std::string const &value) {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemC(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value.c_str());
        assertOK();
    }

    void replace(std::string const &key, int i, Object const &value) {
        _assertReplaceIndexInRange(key, i);
        AstObject *rawCopy = reinterpret_cast<AstObject *>(astCopy(value.getRawPtr()));
        astMapPutElemA(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, rawCopy);
        assertOK(rawCopy);
    }

    void remove(std::string const &key) {
        astMapRemove(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str());
        assertOK();
    }

    void rename(std::string const &oldKey, std::string const &newKey) {
        astMapRename(reinterpret_cast<AstKeyMap *>(getRawPtr()), oldKey.c_str(), newKey.c_str());
        assertOK();
    }

    DataType type(std::string const &key) {
        int retVal = astMapType(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str());
        assertOK();
        return static_cast<DataType>(retVal);
    }

protected:
    // Protected implementation of deep-copy.
    virtual std::shared_ptr<Object> copyPolymorphic() const override {
        return std::static_pointer_cast<KeyMap>(copyImpl<KeyMap, AstKeyMap>());
    }

    explicit KeyMap(AstKeyMap *rawKeyMap) : Object(reinterpret_cast<AstObject *>(rawKeyMap)) {
        if (!astIsAKeyMap(getRawPtr())) {
            std::ostringstream os;
            os << "this is a " << getClassName() << ", which is not a KeyMap";
            throw std::invalid_argument(os.str());
        }
        assertOK();
    }

private:
    void _assertVectorNotEmpty(std::string const &key, int size) const {
        if (size == 0) {
            std::ostringstream os;
            os << "vector supplied for key \"" << key << "\" has zero elements";
            throw std::invalid_argument(os.str());
        }
    }

    // replace silently fails if index out of range, so check it here
    void _assertReplaceIndexInRange(std::string const &key, int i) const {
        int const len = length(key);
        if ((i < 0) || (i >= len)) {
            std::ostringstream os;
            os << "i = " << i << " not in range [0, " << len - 1 << "] for key \"" << key << "\"";
            throw std::invalid_argument(os.str());
        }
    }

    // retrieve the index required to append a value to a key, and make sure the key exists
    int _getAppendIndex(std::string const &key) const {
        int const i = length(key);
        if (i == 0) {
            std::ostringstream os;
            os << "key \"" << key << "\" not found";
            throw std::invalid_argument(os.str());
        }
        return i;
    }
};

}  // namespace ast

#endif