lsst.astshim g38293774b4+c9b10be330
Object.h
Go to the documentation of this file.
1/*
2 * LSST Data Management System
3 * Copyright 2017 AURA/LSST.
4 *
5 * This product includes software developed by the
6 * LSST Project (http://www.lsst.org/).
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the LSST License Statement and
19 * the GNU General Public License along with this program. If not,
20 * see <https://www.lsstcorp.org/LegalNotices/>.
21 */
22#ifndef ASTSHIM_OBJECT_H
23#define ASTSHIM_OBJECT_H
24
25#include <ostream>
26#include <memory>
27
28#include "astshim/base.h"
30#include "astshim/MapSplit.h"
31
32namespace ast {
33
34class FrameDict;
35
51class Object {
52 friend class MapSplit;
53 friend class FrameDict;
54
55private:
56 using Deleter = void (*)(AstObject *);
57
58public:
59 using ObjectPtr = std::unique_ptr<AstObject, Deleter>;
60
61 virtual ~Object() {}
62
64 Object(Object const &object) : _objPtr(object.getRawPtrCopy(), &detail::annulAstObject) {}
65 Object(Object &&) = default;
66 Object &operator=(Object const &) = delete;
67 Object &operator=(Object &&) = default;
68
75 bool operator==(Object const &rhs) const;
76
82 bool operator!=(Object const &rhs) const {
83 return !(*this == rhs); };
84
88 static std::shared_ptr<Object> fromString(std::string const &str) {
89 auto *rawPtr = reinterpret_cast<AstObject *>(astFromString(str.c_str()));
90 assertOK(rawPtr);
91 return Object::_basicFromAstObject(rawPtr);
92 }
93
105 template <typename Class>
106 static std::shared_ptr<Class> fromAstObject(AstObject *rawObj, bool copy);
107
109 std::shared_ptr<Object> copy() const { return std::static_pointer_cast<Object>(copyPolymorphic()); }
110
119 void clear(std::string const &attrib) {
120 astClear(getRawPtr(), attrib.c_str());
121 assertOK();
122 }
123
127 bool hasAttribute(std::string const &attrib) const {
128 bool ret = astHasAttribute(getRawPtr(), attrib.c_str());
129 assertOK();
130 return ret;
131 }
132
139 std::string getClassName() const { return detail::getClassName(getRawPtr()); }
140
142 std::string getID() const { return getC("ID"); }
143
145 std::string getIdent() const { return getC("Ident"); }
146
153 int getNObject() const { return getI("NObject"); }
154
156 int getObjSize() const { return getI("ObjSize"); }
157
163 int getRefCount() const { return getI("RefCount"); }
164
166 bool getUseDefs() const { return getB("UseDefs"); }
167
202 void lock(bool wait) {
203 astLock(getRawPtr(), static_cast<int>(wait));
204 assertOK();
205 }
206
212 bool same(Object const &other) const { return astSame(getRawPtr(), other.getRawPtr()); }
213
215 void setID(std::string const &id) { setC("ID", id); }
216
218 void setIdent(std::string const &ident) { setC("Ident", ident); }
219
221 void setUseDefs(bool usedefs) { setB("UseDefs", usedefs); }
222
229 void show(std::ostream &os, bool showComments = true) const;
230
236 std::string show(bool showComments = true) const;
237
250 bool test(std::string const &attrib) const {
251 bool res = astTest(getRawPtr(), attrib.c_str());
252 assertOK();
253 return res;
254 }
255
280 void unlock(bool report = false) {
281 astUnlock(getRawPtr(), static_cast<int>(report));
282 assertOK();
283 }
284
292 AstObject const *getRawPtr() const { return &*_objPtr; };
293
294 AstObject *getRawPtr() { return &*_objPtr; };
296
297protected:
301 explicit Object(AstObject *object);
302
309 template <typename ShimT, typename AstT>
310 static std::shared_ptr<ShimT> makeShim(AstObject *p) {
311 return std::shared_ptr<ShimT>(new ShimT(reinterpret_cast<AstT *>(p)));
312 }
313
319 template <typename T, typename AstT>
320 std::shared_ptr<T> copyImpl() const {
321 auto *rawptr = reinterpret_cast<AstT *>(astCopy(getRawPtr()));
322 auto retptr = std::shared_ptr<T>(new T(rawptr));
323 assertOK();
324 return retptr;
325 }
326
339 virtual std::shared_ptr<Object> copyPolymorphic() const = 0;
340
348 bool getB(std::string const &attrib) const {
349 bool val = astGetI(getRawPtr(), attrib.c_str());
350 assertOK();
351 return val;
352 }
353
361 std::string const getC(std::string const &attrib) const {
362 char const *rawval = astGetC(getRawPtr(), attrib.c_str());
363 assertOK();
364 return std::string(rawval);
365 }
366
374 double getD(std::string const &attrib) const {
375 double val = astGetD(getRawPtr(), attrib.c_str());
376 assertOK();
377 return val;
378 }
379
387 float getF(std::string const &attrib) const {
388 float val = astGetF(getRawPtr(), attrib.c_str());
389 assertOK();
390 return val;
391 }
392
400 int getI(std::string const &attrib) const {
401 int val = astGetI(getRawPtr(), attrib.c_str());
402 assertOK();
403 return val;
404 }
405
413 long int getL(std::string const &attrib) const {
414 long int val = astGetL(getRawPtr(), attrib.c_str());
415 assertOK();
416 return val;
417 }
418
440 void set(std::string const &setting) {
441 astSet(getRawPtr(), "%s", setting.c_str());
442 assertOK();
443 }
444
452 void setB(std::string const &attrib, bool value) {
453 astSetI(getRawPtr(), attrib.c_str(), value);
454 assertOK();
455 }
456
464 void setC(std::string const &attrib, std::string const &value) {
465 astSetC(getRawPtr(), attrib.c_str(), value.c_str());
466 assertOK();
467 }
468
476 void setD(std::string const &attrib, double value) {
477 astSetD(getRawPtr(), attrib.c_str(), value);
478 assertOK();
479 }
480
488 void setF(std::string const &attrib, float value) {
489 astSetF(getRawPtr(), attrib.c_str(), value);
490 assertOK();
491 }
492
500 void setI(std::string const &attrib, int value) {
501 astSetI(getRawPtr(), attrib.c_str(), value);
502 assertOK();
503 }
504
512 void setL(std::string const &attrib, long int value) {
513 astSetL(getRawPtr(), attrib.c_str(), value);
514 assertOK();
515 }
516private:
517 /*
518 Given a bare AST object pointer return a shared pointer to an ast::Object of the correct type
519
520 The returned object takes ownership of the pointer. This is almost always what you want,
521 for instance astDecompose returns shallow copies of the internal pointers.
522
523 @param[in] rawObj A bare AST object pointer
524 */
525 static std::shared_ptr<Object> _basicFromAstObject(AstObject *rawObj);
526
527 /*
528 Get a deep copy of the raw AST pointer.
529 */
530 AstObject * getRawPtrCopy() const {
531 AstObject * rawPtrCopy = reinterpret_cast<AstObject *>(astCopy(getRawPtr()));
532 assertOK(rawPtrCopy);
533 return rawPtrCopy;
534 }
535
536 /*
537 Swap the raw object pointers between this and another object
538 */
539 void swapRawPointers(Object &other) noexcept {
540 swap(_objPtr, other._objPtr);
541 }
542
543 ObjectPtr _objPtr;
544};
545
546} // namespace ast
547
548#endif
Definition: FrameDict.h:67
Definition: MapSplit.h:38
Definition: Object.h:51
static std::shared_ptr< Class > fromAstObject(AstObject *rawObj, bool copy)
Definition: Object.cc:138
Object(Object &&)=default
Object & operator=(Object &&)=default
void lock(bool wait)
Definition: Object.h:202
void show(std::ostream &os, bool showComments=true) const
Definition: Object.cc:158
std::shared_ptr< T > copyImpl() const
Definition: Object.h:320
bool same(Object const &other) const
Definition: Object.h:212
void setD(std::string const &attrib, double value)
Definition: Object.h:476
bool operator!=(Object const &rhs) const
Definition: Object.h:82
double getD(std::string const &attrib) const
Definition: Object.h:374
void setL(std::string const &attrib, long int value)
Definition: Object.h:512
std::shared_ptr< Object > copy() const
Return a deep copy of this object.
Definition: Object.h:109
AstObject * getRawPtr()
Definition: Object.h:294
long int getL(std::string const &attrib) const
Definition: Object.h:413
std::string const getC(std::string const &attrib) const
Definition: Object.h:361
std::string getClassName() const
Definition: Object.h:139
void setI(std::string const &attrib, int value)
Definition: Object.h:500
static std::shared_ptr< ShimT > makeShim(AstObject *p)
Definition: Object.h:310
virtual std::shared_ptr< Object > copyPolymorphic() const =0
bool test(std::string const &attrib) const
Definition: Object.h:250
bool getB(std::string const &attrib) const
Definition: Object.h:348
bool getUseDefs() const
Get UseDefs: allow use of default values for Object attributes?
Definition: Object.h:166
void setID(std::string const &id)
Set ID: object identification string that is not copied.
Definition: Object.h:215
std::string getID() const
Get ID: object identification string that is not copied.
Definition: Object.h:142
void clear(std::string const &attrib)
Definition: Object.h:119
virtual ~Object()
Definition: Object.h:61
int getI(std::string const &attrib) const
Definition: Object.h:400
void setF(std::string const &attrib, float value)
Definition: Object.h:488
static std::shared_ptr< Object > fromString(std::string const &str)
Definition: Object.h:88
void unlock(bool report=false)
Definition: Object.h:280
std::unique_ptr< AstObject, Deleter > ObjectPtr
unique pointer holding an AST raw pointer
Definition: Object.h:59
void setC(std::string const &attrib, std::string const &value)
Definition: Object.h:464
float getF(std::string const &attrib) const
Definition: Object.h:387
Object(Object const &object)
Copy constructor: make a deep copy.
Definition: Object.h:64
std::string getIdent() const
Get Ident: object identification string that is copied.
Definition: Object.h:145
void set(std::string const &setting)
Definition: Object.h:440
int getObjSize() const
Get ObjSize: the in-memory size of the AST object in bytes.
Definition: Object.h:156
void setB(std::string const &attrib, bool value)
Definition: Object.h:452
Object & operator=(Object const &)=delete
AstObject const * getRawPtr() const
Definition: Object.h:292
int getNObject() const
Definition: Object.h:153
void setIdent(std::string const &ident)
Set Ident: object identification string that is copied.
Definition: Object.h:218
bool hasAttribute(std::string const &attrib) const
Definition: Object.h:127
void setUseDefs(bool usedefs)
Set UseDefs: allow use of default values for Object attributes?
Definition: Object.h:221
bool operator==(Object const &rhs) const
Definition: Object.cc:85
int getRefCount() const
Definition: Object.h:163
void annulAstObject(AstObject *object)
A wrapper around astAnnul; intended as a custom deleter for std::unique_ptr.
Definition: utils.h:40
std::string getClassName(AstObject const *rawObj)
Definition: utils.cc:37
AST wrapper classes and functions.
Definition: attributes_channel.dox:1
void assertOK(AstObject *rawPtr1=nullptr, AstObject *rawPtr2=nullptr)
Definition: base.cc:49
str
Definition: version.py:5