ast::KeyMap Class Reference

KeyMap is used to store a set of values with associated keys which identify the values. More...

#include <KeyMap.h>

Inheritance diagram for ast::KeyMap:

Public Types
using	ObjectPtr = std::unique_ptr<AstObject, Deleter>
	unique pointer holding an AST raw pointer

Public Member Functions
	KeyMap (std::string const &options="")
	Construct an empty KeyMap.
virtual	~KeyMap ()
	KeyMap (KeyMap const &)=default
	Copy constructor: make a deep copy.
	KeyMap (KeyMap &&)=default
KeyMap &	operator= (KeyMap const &)=delete
KeyMap &	operator= (KeyMap &&)=default
std::shared_ptr< KeyMap >	copy () const
	Return a deep copy of this object.
bool	defined (std::string const &key) const
	Does this map contain the specified key, and if so, does it have a defined value?
std::string	key (int ind) const
	Get the key at the specified index.
bool	hasKey (std::string const &key) const
	Does this map contain the specified key?
int	length (std::string const &key) const
	Get the size of the vector for the specified key; return 0 if key not found or value is undefined.
int	size () const
	Get the number of keys.
double	getD (std::string const &key, int ind) const
	Get one double value for a given key.
std::vector< double >	getD (std::string const &key) const
	Get all double values for a given key.
float	getF (std::string const &key, int ind) const
	Get one float value for a given key.
std::vector< float >	getF (std::string const &key) const
	Get all float values for a given key.
int	getI (std::string const &key, int ind) const
	Get one int value for a given key.
std::vector< int >	getI (std::string const &key) const
	Get all int values for a given key.
short int	getS (std::string const &key, int ind) const
	Get one short int value for a given key.
std::vector< short int >	getS (std::string const &key) const
	Get all short int values for a given key.
char unsigned	getB (std::string const &key, int ind) const
	Get one char value for a given key.
std::vector< char unsigned >	getB (std::string const &key) const
	Get all char values for a given key.
std::string	getC (std::string const &key, int ind) const
	Get one std::string value for a given key.
std::vector< std::string >	getC (std::string const &key) const
	Get all std::string values for a given key.
std::shared_ptr< Object >	getA (std::string const &key, int ind) const
	Get one Object for a given key; the object is deep copied.
std::vector< std::shared_ptr< Object > >	getA (std::string const &key) const
	Get all Objects for a given key; each object is deep copied.
void	putD (std::string const &key, double value, std::string const &comment="")
	Add a double value.
void	putD (std::string const &key, std::vector< double > const &vec, std::string const &comment="")
	Add a vector of double.
void	putF (std::string const &key, float value, std::string const &comment="")
	Add a float.
void	putF (std::string const &key, std::vector< float > const &vec, std::string const &comment="")
	Add a vector of floats.
void	putI (std::string const &key, int value, std::string const &comment="")
	Add an int.
void	putI (std::string const &key, std::vector< int > const &vec, std::string const &comment="")
	Add a vector of ints.
void	putS (std::string const &key, short int value, std::string const &comment="")
	Add a short int.
void	putS (std::string const &key, std::vector< short int > const &vec, std::string const &comment="")
	Add a vector of short int.
void	putB (std::string const &key, char unsigned value, std::string const &comment="")
	Add a char.
void	putB (std::string const &key, std::vector< char unsigned > const &vec, std::string const &comment="")
	Add a vector of chars.
void	putC (std::string const &key, std::string const &value, std::string const &comment="")
	Add a string.
void	putC (std::string const &key, std::vector< std::string > const &vec, std::string const &comment="")
	Add a vector of strings.
void	putA (std::string const &key, Object const &obj, std::string const &comment="")
	Add an Object, which is deep copied.
void	putA (std::string const &key, std::vector< std::shared_ptr< Object const > > const &vec, std::string const &comment="")
	Add a vector of shared pointer to Object; the objects are deep copied.
void	putU (std::string const &key, std::string const &comment="")
	Add a new entry, but no value is stored with the entry.
void	append (std::string const &key, double value)
	Append an element to a vector of doubles in a KeyMap.
void	append (std::string const &key, float value)
	Append an element to a vector of floats in a KeyMap.
void	append (std::string const &key, int value)
	Append an element to a vector of ints in a KeyMap.
void	append (std::string const &key, short int value)
	Append an element to a vector of short int in a KeyMap.
void	append (std::string const &key, char unsigned value)
	Append an element to a vector of char in a KeyMap.
void	append (std::string const &key, std::string const &value)
	Append an element to a vector of strings in a KeyMap.
void	append (std::string const &key, Object const &value)
	Append an element to a vector of Objects in a KeyMap.
void	replace (std::string const &key, int i, double value)
	Replace an element of a vector of doubles in a KeyMap.
void	replace (std::string const &key, int i, float value)
	Replace an element of a vector of floats in a KeyMap.
void	replace (std::string const &key, int i, int value)
	Replace an element of a vector of ints in a KeyMap.
void	replace (std::string const &key, int i, short int value)
	Replace an element of a vector of short int in a KeyMap.
void	replace (std::string const &key, int i, char unsigned value)
	Replace an element of a vector of char in a KeyMap.
void	replace (std::string const &key, int i, std::string const &value)
	Replace an element of a vector of strings in a KeyMap.
void	replace (std::string const &key, int i, Object const &value)
	Replace an element of a vector of Objects in a KeyMap.
void	remove (std::string const &key)
	Remove the specified entry.
void	rename (std::string const &oldKey, std::string const &newKey)
	Rename the specified entry.
DataType	type (std::string const &key)
	Get the type suffix for a given key.
bool	operator== (Object const &rhs) const
	Return True if this and rhs are the equal.
bool	operator!= (Object const &rhs) const
	Return True if this and rhs are not equal.
void	clear (std::string const &attrib)
	Clear the values of a specified set of attributes for an Object.
bool	hasAttribute (std::string const &attrib) const
	Does this object have an attribute with the specified name?
std::string	getClassName () const
	Get Class: the name of the class (e.g.
std::string	getID () const
	Get ID: object identification string that is not copied.
std::string	getIdent () const
	Get Ident: object identification string that is copied.
int	getNObject () const
	Get NObject: number of AST objects in existence of the same type as the underlying AST class.
int	getObjSize () const
	Get ObjSize: the in-memory size of the AST object in bytes.
int	getRefCount () const
	Get RefCount: number of active pointers to the underlying AST object.
bool	getUseDefs () const
	Get UseDefs: allow use of default values for Object attributes?
void	lock (bool wait)
	Lock this object for exclusive use by the calling thread.
bool	same (Object const &other) const
	Does this contain the same AST object as another?
void	setID (std::string const &id)
	Set ID: object identification string that is not copied.
void	setIdent (std::string const &ident)
	Set Ident: object identification string that is copied.
void	setUseDefs (bool usedefs)
	Set UseDefs: allow use of default values for Object attributes?
void	show (std::ostream &os, bool showComments=true) const
	Print a textual description the object to an ostream.
std::string	show (bool showComments=true) const
	Return a textual description the object as a string.
bool	test (std::string const &attrib) const
	Has this attribute been explicitly set (and not subsequently cleared)?
void	unlock (bool report=false)
	Unlock this object previously locked using lock, so that other threads can use this object.
AstObject const *	getRawPtr () const
	Get the raw AST pointer.
AstObject *	getRawPtr ()
	Get the raw AST pointer.

Static Public Member Functions
static std::shared_ptr< Object >	fromString (std::string const &str)
	Construct an Object from a string, using astFromString.
template<typename Class >
static std::shared_ptr< Class >	fromAstObject (AstObject *rawObj, bool copy)
	Given a bare AST object pointer return a shared pointer to an ast::Object of the correct type.

Protected Member Functions
virtual std::shared_ptr< Object >	copyPolymorphic () const override
	Return a deep copy of this object.
	KeyMap (AstKeyMap *rawKeyMap)
	Construct a KeyMap from a raw AstKeyMap.
template<typename T , typename AstT >
std::shared_ptr< T >	copyImpl () const
	Implementation of deep copy.
long int	getL (std::string const &attrib) const
	Get the value of an attribute as a long int.
void	set (std::string const &setting)
	Assign a set of attribute values, over-riding any previous values.
void	setB (std::string const &attrib, bool value)
	Set the value of an attribute as a bool.
void	setC (std::string const &attrib, std::string const &value)
	Set the value of an attribute as a string.
void	setD (std::string const &attrib, double value)
	Set the value of an attribute as a double.
void	setF (std::string const &attrib, float value)
	Set the value of an attribute as a float.
void	setI (std::string const &attrib, int value)
	Set the value of an attribute as an int.
void	setL (std::string const &attrib, long int value)
	Set the value of an attribute as a long int.

Static Protected Member Functions
template<typename ShimT , typename AstT >
static std::shared_ptr< ShimT >	makeShim (AstObject *p)
	Functor to make an astshim instance from a raw AST pointer of the corresponding type.

Friends
class	Object
class	Channel

Detailed Description

KeyMap is used to store a set of values with associated keys which identify the values.

The keys are strings. These may be case sensitive or insensitive as selected by the KeyCase attribute, and trailing spaces are ignored. Each key is associated a vector of values of a particular type, which is one of the following, where the single letter is the suffix for the associated setter or getter, such as getD, putD or replaceD:

• D: double
• F: float
• I: int
• S: short int
• B: char
• C: string (internally: char *)
• A: astshim Object (internally: AstObject *)

Despite the name, KeyMap is not a Mapping.

The getters will attempt to cast the data into the requested form. The setters come in three forms:

• put<X> that takes a scalar will and a key with one value
• put<X> that takes a vector will add a key with a vector of values
• append will append one value to a key (in AST this is one of two functions handled by astMapPutElem<X>
• replace will replace one value in a key (in AST this is one of two functions handled by astMapPutElem<X>)

Attributes

KeyMap has the following attributes, in addition to those inherited from Object

• KeyCase: Sets the case in which keys are stored
• KeyError: Report an error if the requested key does not exist?
• SizeGuess: The expected size of the KeyMap.
• SortBy: Determines how keys are sorted in a KeyMap.
• MapLocked: Prevent new entries being added to the KeyMap?

Definition at line 83 of file KeyMap.h.

Member Typedef Documentation

ObjectPtr

using ast::Object::ObjectPtr = std::unique_ptr<AstObject, Deleter>

inherited

unique pointer holding an AST raw pointer

Definition at line 59 of file Object.h.

Constructor & Destructor Documentation

KeyMap() [1/4]

ast::KeyMap::KeyMap ( std::string const & options = "" )

inlineexplicit

Construct an empty KeyMap.

Parameters

[in]

options

Comma-separated list of attribute assignments.

Definition at line 93 of file KeyMap.h.

            : Object(reinterpret_cast<AstObject *>(astKeyMap("%s", options.c_str()))) {
        assertOK();
    }

~KeyMap()

virtual ast::KeyMap::~KeyMap ( )

inlinevirtual

Definition at line 98 of file KeyMap.h.

{};

KeyMap() [2/4]

ast::KeyMap::KeyMap ( KeyMap const & )

default

Copy constructor: make a deep copy.

KeyMap() [3/4]

ast::KeyMap::KeyMap ( KeyMap && )

default

KeyMap() [4/4]

ast::KeyMap::KeyMap ( AstKeyMap * rawKeyMap )

inlineexplicitprotected

Construct a KeyMap from a raw AstKeyMap.

Definition at line 591 of file KeyMap.h.

                                          : 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();
    }

Member Function Documentation

append() [1/7]

void ast::KeyMap::append ( std::string const & key, char unsigned value )

inline

Append an element to a vector of char in a KeyMap.

Definition at line 482 of file KeyMap.h.

                                                           {
        int const i = _getAppendIndex(key);
        astMapPutElemB(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

append() [2/7]

void ast::KeyMap::append ( std::string const & key, double value )

inline

Append an element to a vector of doubles in a KeyMap.

Definition at line 454 of file KeyMap.h.

                                                    {
        int const i = _getAppendIndex(key);
        astMapPutElemD(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

append() [3/7]

void ast::KeyMap::append ( std::string const & key, float value )

inline

Append an element to a vector of floats in a KeyMap.

Definition at line 461 of file KeyMap.h.

                                                   {
        int const i = _getAppendIndex(key);
        astMapPutElemF(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

append() [4/7]

void ast::KeyMap::append ( std::string const & key, int value )

inline

Append an element to a vector of ints in a KeyMap.

Definition at line 468 of file KeyMap.h.

                                                 {
        int const i = _getAppendIndex(key);
        astMapPutElemI(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

append() [5/7]

void ast::KeyMap::append ( std::string const & key, Object const & value )

inline

Append an element to a vector of Objects in a KeyMap.

Definition at line 496 of file KeyMap.h.

                                                           {
        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);
    }

append() [6/7]

void ast::KeyMap::append ( std::string const & key, short int value )

inline

Append an element to a vector of short int in a KeyMap.

Definition at line 475 of file KeyMap.h.

                                                       {
        int const i = _getAppendIndex(key);
        astMapPutElemS(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

append() [7/7]

void ast::KeyMap::append ( std::string const & key, std::string const & value )

inline

Append an element to a vector of strings in a KeyMap.

Definition at line 489 of file KeyMap.h.

                                                              {
        int const i = _getAppendIndex(key);
        astMapPutElemC(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value.c_str());
        assertOK();
    }

clear()

void ast::Object::clear ( std::string const & attrib )

inlineinherited

Clear the values of a specified set of attributes for an Object.

Clearing an attribute cancels any value that has previously been explicitly set for it, so that the standard default attribute value will subsequently be used instead. This also causes the astTest function to return the value zero for the attribute, indicating that no value has been set.

Definition at line 119 of file Object.h.

                                        {
        astClear(getRawPtr(), attrib.c_str());
        assertOK();
    }

copy()

std::shared_ptr< KeyMap > ast::KeyMap::copy ( ) const

inline

Return a deep copy of this object.

Definition at line 107 of file KeyMap.h.

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

copyImpl()

template<typename T , typename AstT >

std::shared_ptr< T > ast::Object::copyImpl ( ) const

inlineprotectedinherited

Implementation of deep copy.

Should be called to implement copyPolymorphic by all derived classes.

Definition at line 320 of file Object.h.

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

copyPolymorphic()

virtual std::shared_ptr< Object > ast::KeyMap::copyPolymorphic ( ) const

inlineoverrideprotectedvirtual

Return a deep copy of this object.

This is called by copy.

Each subclass must override this method. The standard implementation is:

return copyImpl<astshim_class, ast_class>();

for example Frame implements this as:

return copyImpl<Frame, AstFrame>();

Implements ast::Object.

Definition at line 584 of file KeyMap.h.

                                                                   {
        return std::static_pointer_cast<KeyMap>(copyImpl<KeyMap, AstKeyMap>());
    }

defined()

bool ast::KeyMap::defined ( std::string const & key ) const

inline

Does this map contain the specified key, and if so, does it have a defined value?

See also hasKey, which does not check if the value is defined

Definition at line 117 of file KeyMap.h.

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

fromAstObject()

template<typename Class >

template std::shared_ptr< Object > ast::Object::fromAstObject< Object > ( AstObject * rawObj, bool copy )

staticinherited

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.

Template Parameters

Class

The class of the returned shared pointer. (The actual class will be the correct class of rawPtr.)

Parameters

[in]	rawObj	A bare AST object pointer
[in]	copy	If True then make a deep copy of the pointer (and free the original)

Definition at line 138 of file Object.cc.

                                                                       {
    AstObject *rawObjCopy = rawObj;
    if (copy) {
        rawObjCopy = reinterpret_cast<AstObject *>(astCopy(rawObj));
        astAnnul(rawObj);
    }
    assertOK(rawObjCopy);
 
    // Make the appropriate ast shim object and dynamically cast to the desired output type
    auto retObjectBeforeCast = Object::_basicFromAstObject(rawObjCopy);
    auto retObject = std::dynamic_pointer_cast<Class>(retObjectBeforeCast);
    if (!retObject) {
        std::ostringstream os;
        os << "The component is of type " << retObject->getClassName()
           << ", which could not be cast to the desired type " << typeid(Class).name();
        throw std::runtime_error(os.str());
    }
    return retObject;
}

fromString()

static std::shared_ptr< Object > ast::Object::fromString ( std::string const & str )

inlinestaticinherited

Construct an Object from a string, using astFromString.

Definition at line 88 of file Object.h.

                                                                  {
        auto *rawPtr = reinterpret_cast<AstObject *>(astFromString(str.c_str()));
        assertOK(rawPtr);
        return Object::_basicFromAstObject(rawPtr);
    }

getA() [1/2]

std::vector< std::shared_ptr< Object > > ast::KeyMap::getA ( std::string const & key ) const

inline

Get all Objects for a given key; each object is deep copied.

Definition at line 321 of file KeyMap.h.

                                                                      {
        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;
    }

getA() [2/2]

std::shared_ptr< Object > ast::KeyMap::getA ( std::string const & key, int ind ) const

inline

Get one Object for a given key; the object is deep copied.

Definition at line 310 of file KeyMap.h.

                                                                    {
        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);
    }

getB() [1/2]

std::vector< char unsigned > ast::KeyMap::getB ( std::string const & key ) const

inline

Get all char values for a given key.

Definition at line 266 of file KeyMap.h.

                                                              {
        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;
    }

getB() [2/2]

char unsigned ast::KeyMap::getB ( std::string const & key, int ind ) const

inline

Get one char value for a given key.

Definition at line 256 of file KeyMap.h.

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

getC() [1/2]

std::vector< std::string > ast::KeyMap::getC ( std::string const & key ) const

inline

Get all std::string values for a given key.

Definition at line 291 of file KeyMap.h.

                                                          {
        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;
    }

getC() [2/2]

std::string ast::KeyMap::getC ( std::string const & key, int ind ) const

inline

Get one std::string value for a given key.

Definition at line 279 of file KeyMap.h.

                                                        {
        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());
    }

getClassName()

std::string ast::Object::getClassName ( ) const

inlineinherited

Get Class: the name of the class (e.g.

ZoomMap)

Note: if AST returns "CmpMap" then the name will be changed to "SeriesMap" or "ParallelMap", as appropriate.

Definition at line 139 of file Object.h.

{ return detail::getClassName(getRawPtr()); }

getD() [1/2]

std::vector< double > ast::KeyMap::getD ( std::string const & key ) const

inline

Get all double values for a given key.

Definition at line 174 of file KeyMap.h.

                                                       {
        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;
    }

getD() [2/2]

double ast::KeyMap::getD ( std::string const & key, int ind ) const

inline

Get one double value for a given key.

Definition at line 164 of file KeyMap.h.

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

getF() [1/2]

std::vector< float > ast::KeyMap::getF ( std::string const & key ) const

inline

Get all float values for a given key.

Definition at line 197 of file KeyMap.h.

                                                      {
        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;
    }

getF() [2/2]

float ast::KeyMap::getF ( std::string const & key, int ind ) const

inline

Get one float value for a given key.

Definition at line 187 of file KeyMap.h.

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

getI() [1/2]

std::vector< int > ast::KeyMap::getI ( std::string const & key ) const

inline

Get all int values for a given key.

Definition at line 220 of file KeyMap.h.

                                                    {
        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;
    }

getI() [2/2]

int ast::KeyMap::getI ( std::string const & key, int ind ) const

inline

Get one int value for a given key.

Definition at line 210 of file KeyMap.h.

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

getID()

std::string ast::Object::getID ( ) const

inlineinherited

Get ID: object identification string that is not copied.

Definition at line 142 of file Object.h.

{ return getC("ID"); }

getIdent()

std::string ast::Object::getIdent ( ) const

inlineinherited

Get Ident: object identification string that is copied.

Definition at line 145 of file Object.h.

{ return getC("Ident"); }

getL()

long int ast::Object::getL ( std::string const & attrib ) const

inlineprotectedinherited

Get the value of an attribute as a long int.

If possible, the attribute value is converted to the type you request.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 409 of file Object.h.

                                                 {
        long int val = astGetL(getRawPtr(), attrib.c_str());
        assertOK();
        return val;
    }

getNObject()

int ast::Object::getNObject ( ) const

inlineinherited

Get NObject: number of AST objects in existence of the same type as the underlying AST class.

Warning

Intended only for debugging astshim.

Definition at line 153 of file Object.h.

{ return getI("NObject"); }

getObjSize()

int ast::Object::getObjSize ( ) const

inlineinherited

Get ObjSize: the in-memory size of the AST object in bytes.

Definition at line 156 of file Object.h.

{ return getI("ObjSize"); }

getRawPtr() [1/2]

AstObject * ast::Object::getRawPtr ( )

inlineinherited

Get the raw AST pointer.

Intended for internal use only, but cannot be made protected without endless "friend class" declarations.

Definition at line 294 of file Object.h.

{ return &*_objPtr; };

getRawPtr() [2/2]

AstObject const * ast::Object::getRawPtr ( ) const

inlineinherited

Get the raw AST pointer.

Intended for internal use only, but cannot be made protected without endless "friend class" declarations.

Definition at line 292 of file Object.h.

{ return &*_objPtr; };

getRefCount()

int ast::Object::getRefCount ( ) const

inlineinherited

Get RefCount: number of active pointers to the underlying AST object.

Warning

Intended only for debugging astshim.

Definition at line 163 of file Object.h.

{ return getI("RefCount"); }

getS() [1/2]

std::vector< short int > ast::KeyMap::getS ( std::string const & key ) const

inline

Get all short int values for a given key.

Definition at line 243 of file KeyMap.h.

                                                          {
        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;
    }

getS() [2/2]

short int ast::KeyMap::getS ( std::string const & key, int ind ) const

inline

Get one short int value for a given key.

Definition at line 233 of file KeyMap.h.

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

getUseDefs()

bool ast::Object::getUseDefs ( ) const

inlineinherited

Get UseDefs: allow use of default values for Object attributes?

Definition at line 166 of file Object.h.

{ return getB("UseDefs"); }

hasAttribute()

bool ast::Object::hasAttribute ( std::string const & attrib ) const

inlineinherited

Does this object have an attribute with the specified name?

Definition at line 127 of file Object.h.

                                                     {
        bool ret = astHasAttribute(getRawPtr(), attrib.c_str());
        assertOK();
        return ret;
    }

hasKey()

bool ast::KeyMap::hasKey ( std::string const & key ) const

inline

Does this map contain the specified key?

See also defined, which also checks that the value is defined

Definition at line 142 of file KeyMap.h.

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

key()

std::string ast::KeyMap::key ( int ind ) const

inline

Get the key at the specified index.

Definition at line 125 of file KeyMap.h.

                                 {
        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);
    }

length()

int ast::KeyMap::length ( std::string const & key ) const

inline

Get the size of the vector for the specified key; return 0 if key not found or value is undefined.

Definition at line 150 of file KeyMap.h.

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

lock()

void ast::Object::lock ( bool wait )

inlineinherited

Lock this object for exclusive use by the calling thread.

The thread-safe public interface to AST is designed so that an error is reported if any thread attempts to use an Object that it has not previously locked for its own exclusive use using this function. When an Object is created, it is initially locked by the thread that creates it, so newly created objects do not need to be explicitly locked. However, if an Object pointer is passed to another thread, the original thread must first unlock it (using astUnlock) and the new thread must then lock it (using astLock) before the new thread can use the Object.

Parameters

[in]

wait

If the Object is curently locked by another thread then this function will either report an error or block. If a non-zero value is supplied for "wait", the calling thread waits until the object is available for it to use. Otherwise, an error is reported and the function returns immediately without locking the Object.

Notes

• The Locked object will belong to the current AST context.
• This function returns without action if the Object is already locked by the calling thread.
• If simultaneous use of the same object is required by two or more threads, Object::copy should be used to to produce a deep copy of the Object for each thread. Each copy should then be unlocked by the parent thread (i.e. the thread that created the copy), and then locked by the child thread (i.e. the thread that wants to use the copy).
• This function returns without action if the AST library has been built without POSIX thread support (i.e. the "-with-pthreads" option was not specified when running the "configure" script).

Definition at line 202 of file Object.h.

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

makeShim()

template<typename ShimT , typename AstT >

static std::shared_ptr< ShimT > ast::Object::makeShim ( AstObject * p )

inlinestaticprotectedinherited

Functor to make an astshim instance from a raw AST pointer of the corresponding type.

Template Parameters

ShimT	Output astshim class
AstT	Output AST class

Definition at line 310 of file Object.h.

                                                       {
        return std::shared_ptr<ShimT>(new ShimT(reinterpret_cast<AstT *>(p)));
    }

operator!=()

bool ast::Object::operator!= ( Object const & rhs ) const

inlineinherited

Return True if this and rhs are not equal.

See operator== for details

Definition at line 82 of file Object.h.

                                             {
        return !(*this == rhs); };

operator=() [1/2]

KeyMap & ast::KeyMap::operator= ( KeyMap && )

default

operator=() [2/2]

KeyMap & ast::KeyMap::operator= ( KeyMap const & )

delete

operator==()

bool ast::Object::operator== ( Object const & rhs ) const

inherited

Return True if this and rhs are the equal.

For two objects be equal, they both must have the same attributes and all contained objects must be equal.

Definition at line 85 of file Object.cc.

                                               {
    auto thisStr = this->show(false);
    auto rhsStr = rhs.show(false);
    return rhsStr == thisStr;
}

putA() [1/2]

void ast::KeyMap::putA ( std::string const & key, Object const & obj, std::string const & comment = "" )

inline

Add an Object, which is deep copied.

Definition at line 421 of file KeyMap.h.

                                                                                      {
        AstObject *rawCopy = reinterpret_cast<AstObject *>(astCopy(obj.getRawPtr()));
        astMapPut0A(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), rawCopy, comment.c_str());
        assertOK(rawCopy);
    }

putA() [2/2]

void ast::KeyMap::putA ( std::string const & key, std::vector< std::shared_ptr< Object const > > const & vec, std::string const & comment = "" )

inline

Add a vector of shared pointer to Object; the objects are deep copied.

Definition at line 428 of file KeyMap.h.

                                             {
        _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]);
            }
        }
    }

putB() [1/2]

void ast::KeyMap::putB ( std::string const & key, char unsigned value, std::string const & comment = "" )

inline

Add a char.

Definition at line 387 of file KeyMap.h.

                                                                                        {
        astMapPut0B(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

putB() [2/2]

void ast::KeyMap::putB ( std::string const & key, std::vector< char unsigned > const & vec, std::string const & comment = "" )

inline

Add a vector of chars.

Definition at line 393 of file KeyMap.h.

                                             {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1B(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

putC() [1/2]

void ast::KeyMap::putC ( std::string const & key, std::string const & value, std::string const & comment = "" )

inline

Add a string.

Definition at line 402 of file KeyMap.h.

                                                                                           {
        astMapPut0C(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value.c_str(), comment.c_str());
        assertOK();
    }

putC() [2/2]

void ast::KeyMap::putC ( std::string const & key, std::vector< std::string > const & vec, std::string const & comment = "" )

inline

Add a vector of strings.

Definition at line 408 of file KeyMap.h.

                                                                                                    {
        _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]);
            }
        }
    }

putD() [1/2]

void ast::KeyMap::putD ( std::string const & key, double value, std::string const & comment = "" )

inline

Add a double value.

Definition at line 331 of file KeyMap.h.

                                                                                 {
        astMapPut0D(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

putD() [2/2]

void ast::KeyMap::putD ( std::string const & key, std::vector< double > const & vec, std::string const & comment = "" )

inline

Add a vector of double.

Definition at line 337 of file KeyMap.h.

                                                                                                 {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1D(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

putF() [1/2]

void ast::KeyMap::putF ( std::string const & key, float value, std::string const & comment = "" )

inline

Add a float.

Definition at line 345 of file KeyMap.h.

                                                                                {
        astMapPut0F(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

putF() [2/2]

void ast::KeyMap::putF ( std::string const & key, std::vector< float > const & vec, std::string const & comment = "" )

inline

Add a vector of floats.

Definition at line 351 of file KeyMap.h.

                                                                                                {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1F(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

putI() [1/2]

void ast::KeyMap::putI ( std::string const & key, int value, std::string const & comment = "" )

inline

Add an int.

Definition at line 359 of file KeyMap.h.

                                                                              {
        astMapPut0I(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

putI() [2/2]

void ast::KeyMap::putI ( std::string const & key, std::vector< int > const & vec, std::string const & comment = "" )

inline

Add a vector of ints.

Definition at line 365 of file KeyMap.h.

                                                                                              {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1I(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

putS() [1/2]

void ast::KeyMap::putS ( std::string const & key, short int value, std::string const & comment = "" )

inline

Add a short int.

Definition at line 373 of file KeyMap.h.

                                                                                    {
        astMapPut0S(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), value, comment.c_str());
        assertOK();
    }

putS() [2/2]

void ast::KeyMap::putS ( std::string const & key, std::vector< short int > const & vec, std::string const & comment = "" )

inline

Add a vector of short int.

Definition at line 379 of file KeyMap.h.

                                                                                                    {
        _assertVectorNotEmpty(key, vec.size());
        astMapPut1S(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), vec.size(), vec.data(),
                    comment.c_str());
        assertOK();
    }

putU()

void ast::KeyMap::putU ( std::string const & key, std::string const & comment = "" )

inline

Add a new entry, but no value is stored with the entry.

The entry has a special data type represented by symbolic constant AST__UNDEFTYPE. Such entries can act as placeholders for values that can be added to the KeyMap later.

Definition at line 448 of file KeyMap.h.

                                                                   {
        astMapPutU(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), comment.c_str());
        assertOK();
    }

remove()

void ast::KeyMap::remove ( std::string const & key )

inline

Remove the specified entry.

Silently do nothing if this KeyMap does not contain the specified key.

Definition at line 558 of file KeyMap.h.

                                      {
        astMapRemove(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str());
        assertOK();
    }

rename()

void ast::KeyMap::rename ( std::string const & oldKey, std::string const & newKey )

inline

Rename the specified entry.

Silently do nothing if this KeyMap does not contain the old key.

Definition at line 568 of file KeyMap.h.

                                                                  {
        astMapRename(reinterpret_cast<AstKeyMap *>(getRawPtr()), oldKey.c_str(), newKey.c_str());
        assertOK();
    }

replace() [1/7]

void ast::KeyMap::replace ( std::string const & key, int i, char unsigned value )

inline

Replace an element of a vector of char in a KeyMap.

Definition at line 532 of file KeyMap.h.

                                                                   {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemB(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

replace() [2/7]

void ast::KeyMap::replace ( std::string const & key, int i, double value )

inline

Replace an element of a vector of doubles in a KeyMap.

Definition at line 504 of file KeyMap.h.

                                                            {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemD(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

replace() [3/7]

void ast::KeyMap::replace ( std::string const & key, int i, float value )

inline

Replace an element of a vector of floats in a KeyMap.

Definition at line 511 of file KeyMap.h.

                                                           {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemF(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

replace() [4/7]

void ast::KeyMap::replace ( std::string const & key, int i, int value )

inline

Replace an element of a vector of ints in a KeyMap.

Definition at line 518 of file KeyMap.h.

                                                         {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemI(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

replace() [5/7]

void ast::KeyMap::replace ( std::string const & key, int i, Object const & value )

inline

Replace an element of a vector of Objects in a KeyMap.

Definition at line 546 of file KeyMap.h.

                                                                   {
        _assertReplaceIndexInRange(key, i);
        AstObject *rawCopy = reinterpret_cast<AstObject *>(astCopy(value.getRawPtr()));
        astMapPutElemA(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, rawCopy);
        assertOK(rawCopy);
    }

replace() [6/7]

void ast::KeyMap::replace ( std::string const & key, int i, short int value )

inline

Replace an element of a vector of short int in a KeyMap.

Definition at line 525 of file KeyMap.h.

                                                               {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemS(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value);
        assertOK();
    }

replace() [7/7]

void ast::KeyMap::replace ( std::string const & key, int i, std::string const & value )

inline

Replace an element of a vector of strings in a KeyMap.

Definition at line 539 of file KeyMap.h.

                                                                      {
        _assertReplaceIndexInRange(key, i);
        astMapPutElemC(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str(), i, value.c_str());
        assertOK();
    }

same()

bool ast::Object::same ( Object const & other ) const

inlineinherited

Does this contain the same AST object as another?

This is a test of identity, not of equality.

Definition at line 212 of file Object.h.

{ return astSame(getRawPtr(), other.getRawPtr()); }

set()

void ast::Object::set ( std::string const & setting )

inlineprotectedinherited

Assign a set of attribute values, over-riding any previous values.

The attributes and their new values are specified via a character string, which should contain a comma-separated list of the form: "attribute_1 = value_1, attribute_2 = value_2, ... " where "attribute_n" specifies an attribute name, and the value to the right of each " =" sign should be a suitable textual representation of the value to be assigned. This value will be interpreted according to the attribute's data type.

Notes

• Attribute names are not case sensitive and may be surrounded by white space
• Attribute names are not case sensitive and may be surrounded by white space.
• White space may also surround attribute values, where it will generally be ignored (except for string-valued attributes where it is significant and forms part of the value to be assigned).
• To include a literal comma or percent sign in the value assigned to an attribute, the whole attribute value should be enclosed in quotation markes.

Exceptions

std::runtime_error

if the attribute is read-only

Definition at line 436 of file Object.h.

                                       {
        astSet(getRawPtr(), "%s", setting.c_str());
        assertOK();
    }

setB()

void ast::Object::setB ( std::string const & attrib, bool value )

inlineprotectedinherited

Set the value of an attribute as a bool.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 448 of file Object.h.

                                                   {
        astSetI(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

setC()

void ast::Object::setC ( std::string const & attrib, std::string const & value )

inlineprotectedinherited

Set the value of an attribute as a string.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 460 of file Object.h.

                                                               {
        astSetC(getRawPtr(), attrib.c_str(), value.c_str());
        assertOK();
    }

setD()

void ast::Object::setD ( std::string const & attrib, double value )

inlineprotectedinherited

Set the value of an attribute as a double.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 472 of file Object.h.

                                                     {
        astSetD(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

setF()

void ast::Object::setF ( std::string const & attrib, float value )

inlineprotectedinherited

Set the value of an attribute as a float.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 484 of file Object.h.

                                                    {
        astSetF(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

setI()

void ast::Object::setI ( std::string const & attrib, int value )

inlineprotectedinherited

Set the value of an attribute as an int.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 496 of file Object.h.

                                                  {
        astSetI(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

setID()

void ast::Object::setID ( std::string const & id )

inlineinherited

Set ID: object identification string that is not copied.

Definition at line 215 of file Object.h.

{ setC("ID", id); }

setIdent()

void ast::Object::setIdent ( std::string const & ident )

inlineinherited

Set Ident: object identification string that is copied.

Definition at line 218 of file Object.h.

{ setC("Ident", ident); }

setL()

void ast::Object::setL ( std::string const & attrib, long int value )

inlineprotectedinherited

Set the value of an attribute as a long int.

If possible, the type you provide is converted to the actual type of the attribute.

Exceptions

std::runtime_error

if the attribute does not exist or the value cannot be converted

Definition at line 508 of file Object.h.

                                                       {
        astSetL(getRawPtr(), attrib.c_str(), value);
        assertOK();
    }

setUseDefs()

void ast::Object::setUseDefs ( bool usedefs )

inlineinherited

Set UseDefs: allow use of default values for Object attributes?

Definition at line 221 of file Object.h.

{ setB("UseDefs", usedefs); }

show() [1/2]

std::string ast::Object::show ( bool showComments = true ) const

inherited

Return a textual description the object as a string.

Parameters

[in]

showComments

Show comments?

Definition at line 165 of file Object.cc.

                                              {
    std::ostringstream os;
    show(os, showComments);
    return os.str();
}

show() [2/2]

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

inherited

Print a textual description the object to an ostream.

Parameters

[in,out]	os	The stream to which to write the string representation.
[in]	showComments	Show comments?

Definition at line 158 of file Object.cc.

                                                         {
    Stream stream(nullptr, &os);
    Channel ch(stream, showComments ? "" : "Comment=0");
    ch.write(*this);
    assertOK();
}

size()

int ast::KeyMap::size ( ) const

inline

Get the number of keys.

Definition at line 157 of file KeyMap.h.

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

test()

bool ast::Object::test ( std::string const & attrib ) const

inlineinherited

Has this attribute been explicitly set (and not subsequently cleared)?

Warning

Unlike the underlying astTest function, throws an exception if an error results

Notes

• Attribute names are not case sensitive and may be surrounded by white space.
• As you might expect, the returned value for a read-only attribute is always false.

Exceptions

std::runtime_error

if an error results.

Definition at line 250 of file Object.h.

                                             {
        bool res = astTest(getRawPtr(), attrib.c_str());
        assertOK();
        return res;
    }

type()

DataType ast::KeyMap::type ( std::string const & key )

inline

Get the type suffix for a given key.

Definition at line 576 of file KeyMap.h.

                                        {
        int retVal = astMapType(reinterpret_cast<AstKeyMap *>(getRawPtr()), key.c_str());
        assertOK();
        return static_cast<DataType>(retVal);
    }

unlock()

void ast::Object::unlock ( bool report = false )

inlineinherited

Unlock this object previously locked using lock, so that other threads can use this object.

See lock for further details.

Parameters

[in]

report

If true, an error will be reported if the supplied Object, or any Object contained within the supplied Object, is not currently locked by the running thread. If false, such Objects will be left unchanged, and no error will be reported.

Notes

• This function attempts to execute even if AST's global error status is set, but no further error report will be made if it subsequently fails under these circumstances.
• All unlocked Objects are excluded from AST context handling until they are re-locked using astLock.
• This function returns without action if the Object is not currently locked by any thread. If it is locked by the running thread, it is unlocked. If it is locked by another thread, an error will be reported if "error" is non-zero.
• This function returns without action if the AST library has been built without POSIX thread support (i.e. the "-with-pthreads" option was not specified when running the "configure" script).

Definition at line 280 of file Object.h.

                                     {
        astUnlock(getRawPtr(), static_cast<int>(report));
        assertOK();
    }

Friends And Related Symbol Documentation

Channel

friend class Channel

friend

Definition at line 85 of file KeyMap.h.

Object

friend class Object

friend

Definition at line 84 of file KeyMap.h.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-9.0.0/Linux64/astshim/g3156d2b45e+6e55a43351/include/astshim/KeyMap.h