lsst.astshim  19.0.0-3-ge74d124
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"
29 #include "astshim/detail/utils.h"
30 #include "astshim/MapSplit.h"
31 
32 namespace ast {
33 
34 class FrameDict;
35 
51 class Object {
52  friend class MapSplit;
53  friend class FrameDict;
54 
55 private:
56  using Deleter = void (*)(AstObject *);
57 
58 public:
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 
297 protected:
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  }
516 private:
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
ast::Object::getNObject
int getNObject() const
Definition: Object.h:153
ast::detail::annulAstObject
void annulAstObject(AstObject *object)
A wrapper around astAnnul; intended as a custom deleter for std::unique_ptr.
Definition: utils.h:40
ast::Object::show
void show(std::ostream &os, bool showComments=true) const
Definition: Object.cc:158
ast::Object::getD
double getD(std::string const &attrib) const
Definition: Object.h:374
ast::assertOK
void assertOK(AstObject *rawPtr1=nullptr, AstObject *rawPtr2=nullptr)
Definition: base.cc:49
ast::Object::operator==
bool operator==(Object const &rhs) const
Definition: Object.cc:85
ast::Object::getRawPtr
AstObject * getRawPtr()
Definition: Object.h:294
ast::Object::getClassName
std::string getClassName() const
Definition: Object.h:139
ast::Object::operator=
Object & operator=(Object const &)=delete
ast::Object::~Object
virtual ~Object()
Definition: Object.h:61
ast::Object::getC
std::string const getC(std::string const &attrib) const
Definition: Object.h:361
ast::Object::setUseDefs
void setUseDefs(bool usedefs)
Set UseDefs: allow use of default values for Object attributes?
Definition: Object.h:221
ast::Object::ObjectPtr
std::unique_ptr< AstObject, Deleter > ObjectPtr
unique pointer holding an AST raw pointer
Definition: Object.h:59
ast::Object::setI
void setI(std::string const &attrib, int value)
Definition: Object.h:500
ast::Object::operator=
Object & operator=(Object &&)=default
ast::Object::copyPolymorphic
virtual std::shared_ptr< Object > copyPolymorphic() const =0
ast::Object::getRawPtr
AstObject const * getRawPtr() const
Definition: Object.h:292
base.h
ast::Object
Definition: Object.h:51
ast::Object::fromString
static std::shared_ptr< Object > fromString(std::string const &str)
Definition: Object.h:88
ast::Object::getObjSize
int getObjSize() const
Get ObjSize: the in-memory size of the AST object in bytes.
Definition: Object.h:156
ast::Object::getF
float getF(std::string const &attrib) const
Definition: Object.h:387
ast::Object::clear
void clear(std::string const &attrib)
Definition: Object.h:119
ast::Object::setB
void setB(std::string const &attrib, bool value)
Definition: Object.h:452
ast::Object::makeShim
static std::shared_ptr< ShimT > makeShim(AstObject *p)
Definition: Object.h:310
utils.h
ast::Object::Object
Object(Object &&)=default
ast::Object::setC
void setC(std::string const &attrib, std::string const &value)
Definition: Object.h:464
ast::Object::getB
bool getB(std::string const &attrib) const
Definition: Object.h:348
ast::Object::getRefCount
int getRefCount() const
Definition: Object.h:163
MapSplit.h
ast::Object::getUseDefs
bool getUseDefs() const
Get UseDefs: allow use of default values for Object attributes?
Definition: Object.h:166
ast::MapSplit
Definition: MapSplit.h:38
ast::Object::same
bool same(Object const &other) const
Definition: Object.h:212
ast::detail::getClassName
std::string getClassName(AstObject const *rawObj)
Definition: utils.cc:37
ast::Object::lock
void lock(bool wait)
Definition: Object.h:202
ast::Object::setD
void setD(std::string const &attrib, double value)
Definition: Object.h:476
ast::Object::getIdent
std::string getIdent() const
Get Ident: object identification string that is copied.
Definition: Object.h:145
ast::Object::getI
int getI(std::string const &attrib) const
Definition: Object.h:400
ast
AST wrapper classes and functions.
Definition: attributes_channel.dox:1
ast::Object::hasAttribute
bool hasAttribute(std::string const &attrib) const
Definition: Object.h:127
ast::Object::test
bool test(std::string const &attrib) const
Definition: Object.h:250
ast::Object::setF
void setF(std::string const &attrib, float value)
Definition: Object.h:488
ast::Object::copy
std::shared_ptr< Object > copy() const
Return a deep copy of this object.
Definition: Object.h:109
ast::FrameDict
Definition: FrameDict.h:67
ast::Object::set
void set(std::string const &setting)
Definition: Object.h:440
ast::Object::getID
std::string getID() const
Get ID: object identification string that is not copied.
Definition: Object.h:142
ast::Object::setID
void setID(std::string const &id)
Set ID: object identification string that is not copied.
Definition: Object.h:215
ast::Object::fromAstObject
static std::shared_ptr< Class > fromAstObject(AstObject *rawObj, bool copy)
Definition: Object.cc:138
ast::Object::setL
void setL(std::string const &attrib, long int value)
Definition: Object.h:512
ast::Object::copyImpl
std::shared_ptr< T > copyImpl() const
Definition: Object.h:320
ast::Object::getL
long int getL(std::string const &attrib) const
Definition: Object.h:413
ast::Object::unlock
void unlock(bool report=false)
Definition: Object.h:280
ast::Object::Object
Object(Object const &object)
Copy constructor: make a deep copy.
Definition: Object.h:64
ast::Object::operator!=
bool operator!=(Object const &rhs) const
Definition: Object.h:82
ast::Object::setIdent
void setIdent(std::string const &ident)
Set Ident: object identification string that is copied.
Definition: Object.h:218