Object.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_OBJECT_H
#define ASTSHIM_OBJECT_H
 
#include <ostream>
#include <memory>
 
#include "astshim/base.h"
#include "astshim/detail/utils.h"
#include "astshim/MapSplit.h"
 
namespace ast {
 
class FrameDict;

class Object {
    friend class MapSplit;
    friend class FrameDict;
 
private:
    using Deleter = void (*)(AstObject *);
 
public:
    using ObjectPtr = std::unique_ptr<AstObject, Deleter>;  
 
    virtual ~Object() {}

    Object(Object const &object) : _objPtr(object.getRawPtrCopy(), &detail::annulAstObject) {}
    Object(Object &&) = default;
    Object &operator=(Object const &) = delete;
    Object &operator=(Object &&) = default;

    bool operator==(Object const &rhs) const;

    bool operator!=(Object const &rhs) const {
        return !(*this == rhs); };

    static std::shared_ptr<Object> fromString(std::string const &str) {
        auto *rawPtr = reinterpret_cast<AstObject *>(astFromString(str.c_str()));
        assertOK(rawPtr);
        return Object::_basicFromAstObject(rawPtr);
    }

    template <typename Class>
    static std::shared_ptr<Class> fromAstObject(AstObject *rawObj, bool copy);

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

    void clear(std::string const &attrib) {
        astClear(getRawPtr(), attrib.c_str());
        assertOK();
    }

    bool hasAttribute(std::string const &attrib) const {
        bool ret = astHasAttribute(getRawPtr(), attrib.c_str());
        assertOK();
        return ret;
    }

    std::string getClassName() const { return detail::getClassName(getRawPtr()); }

    std::string getID() const { return getC("ID"); }

    std::string getIdent() const { return getC("Ident"); }

    int getNObject() const { return getI("NObject"); }

    int getObjSize() const { return getI("ObjSize"); }

    int getRefCount() const { return getI("RefCount"); }

    bool getUseDefs() const { return getB("UseDefs"); }

    void lock(bool wait) {
        astLock(getRawPtr(), static_cast<int>(wait));
        assertOK();
    }

    bool same(Object const &other) const { return astSame(getRawPtr(), other.getRawPtr()); }

    void setID(std::string const &id) { setC("ID", id); }

    void setIdent(std::string const &ident) { setC("Ident", ident); }

    void setUseDefs(bool usedefs) { setB("UseDefs", usedefs); }

    void show(std::ostream &os, bool showComments = true) const;

    std::string show(bool showComments = true) const;

    bool test(std::string const &attrib) const {
        bool res = astTest(getRawPtr(), attrib.c_str());
        assertOK();
        return res;
    }

    void unlock(bool report = false) {
        astUnlock(getRawPtr(), static_cast<int>(report));
        assertOK();
    }

    AstObject const *getRawPtr() const { return &*_objPtr; };
 
    AstObject *getRawPtr() { return &*_objPtr; };
 
protected:
    explicit Object(AstObject *object);

    template <typename ShimT, typename AstT>
    static std::shared_ptr<ShimT> makeShim(AstObject *p) {
        return std::shared_ptr<ShimT>(new ShimT(reinterpret_cast<AstT *>(p)));
    }

    template <typename T, typename AstT>
    std::shared_ptr<T> copyImpl() const {
        auto *rawptr = reinterpret_cast<AstT *>(astCopy(getRawPtr()));
        auto retptr = std::shared_ptr<T>(new T(rawptr));
        assertOK();
        return retptr;
    }

    virtual std::shared_ptr<Object> copyPolymorphic() const = 0;

    bool getB(std::string const &attrib) const {
        bool val = astGetI(getRawPtr(), attrib.c_str());
        assertOK();
        return val;
    }

    std::string const getC(std::string const &attrib) const {
        char const *rawval = astGetC(getRawPtr(), attrib.c_str());
        assertOK();
        return std::string(rawval);
    }

    double getD(std::string const &attrib) const {
        double val = astGetD(getRawPtr(), attrib.c_str());
        assertOK();
        return val;
    }

    float getF(std::string const &attrib) const {
        float val = astGetF(getRawPtr(), attrib.c_str());
        assertOK();
        return val;
    }

    int getI(std::string const &attrib) const;

    long int getL(std::string const &attrib) const {
        long int val = astGetL(getRawPtr(), attrib.c_str());
        assertOK();
        return val;
    }

    void set(std::string const &setting) {
        astSet(getRawPtr(), "%s", setting.c_str());
        assertOK();
    }

    void setB(std::string const &attrib, bool value) {
        astSetI(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

    void setC(std::string const &attrib, std::string const &value) {
        astSetC(getRawPtr(), attrib.c_str(), value.c_str());
        assertOK();
    }

    void setD(std::string const &attrib, double value) {
        astSetD(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

    void setF(std::string const &attrib, float value) {
        astSetF(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

    void setI(std::string const &attrib, int value) {
        astSetI(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

    void setL(std::string const &attrib, long int value) {
        astSetL(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }
private:
    /*
    Given a bare AST object pointer return a shared pointer to an ast::Object of the correct type
 
    The returned object takes ownership of the pointer. This is almost always what you want,
    for instance astDecompose returns shallow copies of the internal pointers.
 
    @param[in] rawObj  A bare AST object pointer
    */
    static std::shared_ptr<Object> _basicFromAstObject(AstObject *rawObj);
 
    /*
    Get a deep copy of the raw AST pointer.
    */
    AstObject * getRawPtrCopy() const {
        AstObject * rawPtrCopy = reinterpret_cast<AstObject *>(astCopy(getRawPtr()));
        assertOK(rawPtrCopy);
        return rawPtrCopy;
    }
 
    /*
    Swap the raw object pointers between this and another object
    */
    void swapRawPointers(Object &other) noexcept {
        swap(_objPtr, other._objPtr);
    }
 
    ObjectPtr _objPtr;
};
 
}  // namespace ast
 
#endif