lsst::daf::persistence::LogicalLocation Class Reference

Class for logical location of a persisted Persistable instance. More...

#include <LogicalLocation.h>

Public Types
typedef std::shared_ptr< LogicalLocation >	Ptr

Public Member Functions
	LogicalLocation (std::string const &locString, std::shared_ptr< dafBase::PropertySet const > additionalData=std::shared_ptr< dafBase::PropertySet const >())
	Constructor from string and additional data. More...
std::string const &	locString (void) const
	Accessor. More...

Static Public Member Functions
static void	setLocationMap (std::shared_ptr< dafBase::PropertySet > map)
	Set the logical-to-less-logical map. More...

Detailed Description

Class for logical location of a persisted Persistable instance.

Implemented as a minimal string representing a pathname or a database connection string. Interpreted by FormatterStorage subclasses.

Definition at line 59 of file LogicalLocation.h.

Member Typedef Documentation

Ptr

typedef std::shared_ptr<LogicalLocation> lsst::daf::persistence::LogicalLocation::Ptr

Definition at line 61 of file LogicalLocation.h.

Constructor & Destructor Documentation

LogicalLocation()

lsst::daf::persistence::LogicalLocation::LogicalLocation	(	std::string const &	locString,
		std::shared_ptr< dafBase::PropertySet const >	additionalData = std::shared_ptr<dafBase::PropertySet const>()
	)

Constructor from string and additional data.

Definition at line 62 of file LogicalLocation.cc.

        : _locString() {
    std::regex expr("(%.*?)\\((\\w+?)\\)");
    std::sregex_iterator i = std::sregex_iterator(locString.begin(), locString.end(), expr);
    std::sregex_iterator last;
    LOGLS_DEBUG(_log, "Input string: " << locString);
    while (i != std::sregex_iterator()) {
        last = i;
        if ((*i).prefix().matched) {
            _locString += (*i).prefix().str();
        }
        std::string fmt = (*i).str(1);
        std::string key = (*i).str(2);
        LOGLS_DEBUG(_log, "Key: " << key);
        if (_map && _map->exists(key)) {
            if (_map->typeOf(key) == typeid(int)) {
                int value = _map->getAsInt(key);
                LOGLS_DEBUG(_log, "Map Val: " << value);
                if (fmt == "%") {
                    _locString += (boost::format("%1%") % value).str();
                } else {
                    _locString += (boost::format(fmt) % value).str();
                }
            } else {
                std::string value = _map->getAsString(key);
                LOGLS_DEBUG(_log, "Map Val: " << value);
                _locString += value;
            }
        } else if (additionalData && additionalData->exists(key)) {
            if (additionalData->typeOf(key) == typeid(int)) {
                int value = additionalData->getAsInt(key);
                LOGLS_DEBUG(_log, "Map Val: " << value);
                if (fmt == "%") {
                    _locString += (boost::format("%1%") % value).str();
                } else {
                    _locString += (boost::format(fmt) % value).str();
                }
            } else {
                std::string value = additionalData->getAsString(key);
                LOGLS_DEBUG(_log, "Map Val: " << value);
                _locString += value;
            }
        } else {
            throw LSST_EXCEPT(pexExcept::RuntimeError, "Unknown substitution: " + key);
        }
        ++i;
    }
    if (last == std::sregex_iterator()) {
        _locString = locString;
        LOGLS_DEBUG(_log, "Copy to: " << _locString);
    } else {
        _locString += (*last).suffix().str();
        LOGLS_DEBUG(_log, "Result: " << _locString);
    }
}

Member Function Documentation

locString()

std::string const & lsst::daf::persistence::LogicalLocation::locString

(

void

)

const

Accessor.

Definition at line 121 of file LogicalLocation.cc.

{ return _locString; }

setLocationMap()

void lsst::daf::persistence::LogicalLocation::setLocationMap ( std::shared_ptr< dafBase::PropertySet >  map )

static

Set the logical-to-less-logical map.

Definition at line 125 of file LogicalLocation.cc.

                                                                                    {
    if (map) {
        _map = map->deepCopy();
    } else {
        _map.reset();
    }
}

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-5.0.1/Linux64/daf_persistence/g17e5ecfddb+50a5ac4092/include/lsst/daf/persistence/LogicalLocation.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-5.0.1/Linux64/daf_persistence/g17e5ecfddb+50a5ac4092/src/LogicalLocation.cc