lsst.ctrl.events::Event Class Reference

Representation of an LSST Event. More...

#include <Event.h>

Inheritance diagram for lsst.ctrl.events::Event:

Public Member Functions
	Event ()
	Constructor for Event with no properties. More...
	Event (PropertySet const &properties)
	Constructor for Event. More...
	Event (PropertySet const &properties, PropertySet const &filterable)
	Constructor for Event. More...
	Event (std::string const &runid, PropertySet::Ptr const properties)
	Constructor for Event. More...
	Event (std::string const &runid, PropertySet const &properties)
	Constructor for Event. More...
	Event (std::string const &runid, PropertySet const &properties, PropertySet const &filterable)
	Constructor for Event. More...
	Event (cms::TextMessage *msg)
	Constructor for Event. More...
virtual	~Event ()
	destructor More...
PropertySet::Ptr	getPropertySet () const
	retrieve the PropertySet for this Event More...
std::string	getPubDate ()
	get the publication date of this Event, in ASCII More...
long long	getPubTime ()
	get the publication time of this Event More...
void	setPubTime (long long t)
	set the publication time of this Event More...
long long	getEventTime ()
	get the event creation time More...
void	setEventTime (long long nsecs)
	set the event creation time More...
void	updateEventTime ()
	update the Event time to the current time More...
std::string	getEventDate ()
	get the Event Date More...
std::string	getRunId ()
	get the RunId for this Event More...
std::string	getType ()
	get the Event type More...
std::string	getStatus ()
	get the Event status More...
void	setStatus (std::string status)
	set the Event status More...
void	setTopic (std::string topic)
	set the Event topic More...
std::string	getTopic ()
	get the Event topic More...
vector< std::string >	getFilterablePropertyNames ()
	return all filterable property names More...
vector< std::string >	getCustomPropertyNames ()
	return all custom property names More...
PropertySet::Ptr	getCustomPropertySet () const
	return all custom property set More...
virtual void	populateHeader (cms::TextMessage *msg) const
	populate a cms::TextMessage header with properties More...
void	marshall (cms::TextMessage *msg)
	marshall values in this event into a cms::TextMessage More...

Static Public Attributes
static const std::string	TYPE = "TYPE"
static const std::string	EVENTTIME = "EVENTTIME"
static const std::string	RUNID = "RUNID"
static const std::string	STATUS = "STATUS"
static const std::string	TOPIC = "TOPIC"
static const std::string	PUBTIME = "PUBTIME"
static const std::string	UNINITIALIZED = "uninitialized"

Protected Member Functions
void	_init ()
void	_constructor (std::string const &runid, PropertySet const &properties, PropertySet const &filterable)
template<typename T >
void	add (std::string const &name, std::string const &tag, PropertySet const &properties, boost::property_tree::ptree &child)

Protected Attributes
PropertySet::Ptr	_psp
PropertySet::Ptr	_filterable
set< std::string >	_keywords

Private Member Functions
std::string	marshall (PropertySet const &properties)
PropertySet::Ptr	processTextMessage (cms::TextMessage *textMessage)
PropertySet::Ptr	unmarshall (std::string const &text)
PropertySet::Ptr	parsePropertySet (boost::property_tree::ptree child)
bool	addDataItem (std::string const &typeInfo, boost::property_tree::ptree &item, std::string const &key, PropertySet &properties)

Detailed Description

Representation of an LSST Event.

Definition at line 62 of file Event.h.

Constructor & Destructor Documentation

lsst.ctrl.events::Event::Event

(

)

Constructor for Event with no properties.

Definition at line 81 of file Event.cc.

             {
    _init();
}

lsst.ctrl.events::Event::Event

(

PropertySet const &

properties

)

Constructor for Event.

Parameters

[in]

properties

the PropertySet to use to populate the event

Definition at line 173 of file Event.cc.

                                  {
    const std::string empty;
    PropertySet p;
    _constructor(empty, ps, p);
}

lsst.ctrl.events::Event::Event	(	PropertySet const &	properties,
		PropertySet const &	filterable
	)

Constructor for Event.

Parameters

[in]	properties	the PropertySet to use to populate the event
[in]	filterable	PropertySet of types to be added to the header so they can be filtered.

Definition at line 179 of file Event.cc.

                                                                 {
    const std::string empty;
    _constructor(empty, ps, filterable);
}

lsst.ctrl.events::Event::Event	(	std::string const &	runid,
		PropertySet::Ptr const	properties
	)

Constructor for Event.

Parameters

[in]	runid	A "run id" to place in the header of this event
[in]	properties	the PropertySet::Ptr to use to populate the event

Definition at line 184 of file Event.cc.

                                                             {
    PropertySet p;
    _constructor(runId, *psp, p);
}

lsst.ctrl.events::Event::Event	(	std::string const &	runid,
		PropertySet const &	properties
	)

Constructor for Event.

Parameters

[in]	runid	A "run id" to place in the header of this event
[in]	properties	the PropertySet to use to populate the event

Definition at line 189 of file Event.cc.

                                                          {
    PropertySet p;
    _constructor(runId, ps, p);
}

lsst.ctrl.events::Event::Event	(	std::string const &	runid,
		PropertySet const &	properties,
		PropertySet const &	filterable
	)

Constructor for Event.

Parameters

[in]	runid	A "run id" to place in the header of this event
[in]	properties	the PropertySet to use to populate the event
[in]	filterable	PropertySet of types to be added to the header so they can be filtered.

Definition at line 194 of file Event.cc.

                                                                                         {
    _constructor(runId, ps, filterable);
}

lsst.ctrl.events::Event::Event

(

cms::TextMessage *

msg

)

Constructor for Event.

Parameters

[in]

msg

A cms::TextMessage to convert into an Event object

Definition at line 93 of file Event.cc.

                                {

    vector<std::string>names = msg->getPropertyNames();

    _psp = processTextMessage(msg);

    for (vector<std::string>::iterator name = names.begin(); name != names.end(); ++name) {
        _keywords.insert(*name);
    }

    _psp->set(EVENTTIME, msg->getCMSTimestamp());

    for (vector<std::string>::iterator n = names.begin(); n != names.end(); ++n) {
        std::string const& name = *n;
        cms::Message::ValueType vType = msg->getPropertyValueType(name);
        switch(vType) {
            case cms::Message::NULL_TYPE:
                _psp->set(name, NULL);
                break;
            case cms::Message::BOOLEAN_TYPE:
                _psp->set(name, msg->getBooleanProperty(name));
                break;
            case cms::Message::BYTE_TYPE:
            case cms::Message::CHAR_TYPE:
                _psp->set(name, msg->getByteProperty(name));
                break;
            case cms::Message::SHORT_TYPE:
                _psp->set(name, msg->getShortProperty(name));
                break;
            case cms::Message::INTEGER_TYPE:
                _psp->set(name, msg->getIntProperty(name));
                break;
            case cms::Message::LONG_TYPE:
                _psp->set(name, msg->getLongProperty(name));
                break;
            case cms::Message::DOUBLE_TYPE:
                _psp->set(name, msg->getDoubleProperty(name));
                break;
            case cms::Message::FLOAT_TYPE:
                _psp->set(name, msg->getFloatProperty(name));
                break;
            case cms::Message::STRING_TYPE:
                _psp->set(name, msg->getStringProperty(name));
                break;
            case cms::Message::BYTE_ARRAY_TYPE:
            case cms::Message::UNKNOWN_TYPE:
            default:
                std::string msg("Data type represented by "+name+" is not permitted supported");
                throw LSST_EXCEPT(pexExceptions::RuntimeError, msg);
                break;
        }
    }
    
}

lsst.ctrl.events::Event::~Event ( )

virtual

destructor

Definition at line 520 of file Event.cc.

              {
}

Member Function Documentation

void lsst.ctrl.events::Event::_constructor ( std::string const &  runid, PropertySet const &  properties, PropertySet const &  filterable  )

protected

Definition at line 198 of file Event.cc.

                                                                                                     {
    _init();
    
    _psp = ps.deepCopy();


    // do NOT alter the property set we were given. Make a copy of it,
    // and modify that one.

    if (!_psp->exists(STATUS)) {
        _psp->set(STATUS, "unknown");
    }
    
    if (!_psp->exists(EVENTTIME)) {
        updateEventTime();
    }
   
    // _runId is filled in here and is ignored in the passed PropertySet
    if (!runId.empty()) {
        _keywords.insert(RUNID);
        _psp->set(RUNID, runId);
    }

    // _type is filled in here and is ignored in the passed PropertySet
    _psp->set(TYPE, EventTypes::EVENT);

    // _topic is filled in on publish and is ignored in the passed PropertySet
    _psp->set(TOPIC, Event::UNINITIALIZED);

    // _pubTime is filled in on publish and is ignored in the passed PropertySet
    _psp->set(PUBTIME, (long long)0);

    if (filterable.nameCount() > 0) {
        vector<std::string> names = filterable.names();

        for (vector<std::string>::iterator name = names.begin(); name != names.end(); ++name) {
            _keywords.insert(*name);
        }

        _psp->combine(filterable.PropertySet::deepCopy());
    }
}

void lsst.ctrl.events::Event::_init ( )

protected

Definition at line 85 of file Event.cc.

                  {
    _keywords.insert(TYPE);
    _keywords.insert(EVENTTIME);
    _keywords.insert(STATUS);
    _keywords.insert(TOPIC);
    _keywords.insert(PUBTIME);
}

template<typename T >

template void lsst.ctrl.events::Event::add< long long > ( std::string const &  name, std::string const &  tag, PropertySet const &  properties, boost::property_tree::ptree &  child  )

protected

Definition at line 364 of file Event.cc.

                                                                                                                                      {

    std::vector<T> vec = ps.getArray<T>(name);

    typename std::vector<T>::iterator iter;
    for (iter = vec.begin(); iter != vec.end(); iter++) {
        boost::property_tree::ptree pt;
        pt.put(tag, *iter);
        child.put_child(name, pt);
    }
}

bool lsst.ctrl.events::Event::addDataItem ( std::string const &  typeInfo, boost::property_tree::ptree &  item, std::string const &  key, PropertySet &  ps  )

private

private method to try to add data to a property set

Parameters

typeInfo	a string containing the name of the data type
item	a node of a boost::property_tree::ptree containing data
key	the name of the data
ps	a PropertySet to store the name and data into.

Returns

true if data was added to the PropertySet

Definition at line 435 of file Event.cc.

                                                                                                                        {
    if (typeInfo == "string") {
        std::string value = item.get_value<std::string>();
        ps.add(key, value);
    } else if (typeInfo == "bool") {
        bool value = item.get_value<bool>();
        ps.add(key, value);
    } else if (typeInfo == "long") {
        long value = item.get_value<long>();
        ps.add(key, value);
    } else if (typeInfo == "long long") {
        long long value = item.get_value<long long>();
        ps.add(key, value);
    } else if (typeInfo == "int") {
        int value = item.get_value<int>();
        ps.add(key, value);
    } else if (typeInfo == "float") {
        float value = item.get_value<float>();
        ps.add(key, value);
    } else if (typeInfo == "double") {
        double value = item.get_value<double>();
        ps.add(key, value);
    } else if (typeInfo == "datetime") {
        long long value = item.get_value<long long>();
        ps.add(key, lsst::daf::base::DateTime(value, lsst::daf::base::DateTime::UTC));
    } else {
        return false;
    }
    return true;
}

vector< std::string > lsst.ctrl.events::Event::getCustomPropertyNames

(

)

return all custom property names

Returns

a vector of custom property names

Definition at line 157 of file Event.cc.

                                                {
    vector<std::string> names = _psp->names();

    vector<std::string>::iterator nameIterator;
    set<std::string>::iterator keyIterator;

    for (nameIterator = names.begin(); nameIterator != names.end();) {
            keyIterator = _keywords.find(*nameIterator);
            if (keyIterator == _keywords.end())
                nameIterator++;
            else
                names.erase(nameIterator);
    }
    return names;
}

PropertySet::Ptr lsst.ctrl.events::Event::getCustomPropertySet

(

)

const

return all custom property set

Returns

a PropertySet::Ptr of custom properties

Definition at line 292 of file Event.cc.

                                                 {
    PropertySet::Ptr psp = _psp->deepCopy();

    set<std::string>::iterator keyIterator;
    for (keyIterator = _keywords.begin(); keyIterator != _keywords.end(); keyIterator++) 
        psp->remove(*keyIterator);
    return psp;
}

std::string lsst.ctrl.events::Event::getEventDate

(

)

get the Event Date

Returns

a formatted date string representing the Event creation time

Definition at line 283 of file Event.cc.

                              {
    long long eventTime = _psp->get<long long>(EVENTTIME);
    dafBase::DateTime dateTime(eventTime);
    
    struct tm gmTime = dateTime.gmtime();
    return asctime(&gmTime);
}

long long lsst.ctrl.events::Event::getEventTime

(

)

get the event creation time

Returns

time in nanoseconds

Definition at line 270 of file Event.cc.

                              {
    return _psp->get<long long>(EVENTTIME);
}

vector< std::string > lsst.ctrl.events::Event::getFilterablePropertyNames

(

)

return all filterable property names

Returns

a vector of filterable property names

Definition at line 148 of file Event.cc.

                                                    {
    vector<std::string> _names;
    set<std::string>::iterator keyIterator;
    for (keyIterator = _keywords.begin(); keyIterator != _keywords.end(); keyIterator++) {
        _names.push_back(*keyIterator);
    }
    return _names;
}

PropertySet::Ptr lsst.ctrl.events::Event::getPropertySet

(

)

const

retrieve the PropertySet for this Event

Returns

PropertySet::Ptr to this PropertySet

Definition at line 301 of file Event.cc.

                                           {
    if (_psp != 0) {
            PropertySet::Ptr psp = _psp->deepCopy();
            return psp;
    }
    PropertySet::Ptr psp(new PropertySet);
    return psp;
}

std::string lsst.ctrl.events::Event::getPubDate

(

)

get the publication date of this Event, in ASCII

Definition at line 318 of file Event.cc.

                            {
    long long _pubTime = _psp->get<long long>(PUBTIME);
    if (_pubTime == 0)
        return std::string();

    dafBase::DateTime dateTime(_pubTime);
    
    struct tm pubTime = dateTime.gmtime();
    return asctime(&pubTime);
}

long long lsst.ctrl.events::Event::getPubTime

(

)

get the publication time of this Event

Returns

time in nanoseconds

Definition at line 314 of file Event.cc.

                            {
    return _psp->get<long long>(PUBTIME);
}

std::string lsst.ctrl.events::Event::getRunId

(

)

get the RunId for this Event

Returns

string representation of the run id

Definition at line 329 of file Event.cc.

                          {
    if (_psp->exists(RUNID))
        return _psp->get<std::string>(RUNID);
    throw LSST_EXCEPT(pexExceptions::RuntimeError, std::string("property RUNID not found"));
}

std::string lsst.ctrl.events::Event::getStatus

(

)

get the Event status

Returns

string representation of the Event status

Definition at line 339 of file Event.cc.

                           {
    return _psp->get<std::string>(STATUS);
}

std::string lsst.ctrl.events::Event::getTopic

(

)

get the Event topic

Returns

string representation of the Event topic

Definition at line 351 of file Event.cc.

                          {
    return _psp->get<std::string>(TOPIC);
}

std::string lsst.ctrl.events::Event::getType

(

void

)

get the Event type

Returns

string representation of the Event type

Definition at line 335 of file Event.cc.

                         {
    return _psp->get<std::string>(TYPE);
}

void lsst.ctrl.events::Event::marshall

(

cms::TextMessage *

msg

)

marshall values in this event into a cms::TextMessage

Definition at line 355 of file Event.cc.

                                        {
    PropertySet::Ptr psp;

    populateHeader(msg);
    psp = getCustomPropertySet();
    std::string payload = marshall(*psp);
    msg->setText(payload);
}

std::string lsst.ctrl.events::Event::marshall ( PropertySet const &  properties )

private

Definition at line 376 of file Event.cc.

                                               {
    std::vector<std::string> names = ps.paramNames(false);

    boost::property_tree::ptree child;
 
    for (vector<std::string>::iterator n = names.begin(); n != names.end(); ++n) {
        std::string name = *n;

        if (ps.typeOf(name) == typeid(bool)) {
            add<bool>(name, "bool", ps, child);
        } else if (ps.typeOf(name) == typeid(long)) {
            add<long>(name, "long", ps, child);
        } else if (ps.typeOf(name) == typeid(long long)) {
            add<long long>(name, "long long", ps, child);
        } else if (ps.typeOf(name) == typeid(int)) {
            add<int>(name, "int", ps, child);
        } else if (ps.typeOf(name) == typeid(float)) {
            add<float>(name, "float", ps, child);
        } else if (ps.typeOf(name) == typeid(double)) {
            add<double>(name, "double", ps, child);
        } else if (ps.typeOf(name) == typeid(std::string)) {
            add<std::string>(name, "string", ps, child);
        } else if (ps.typeOf(name) == typeid(lsst::daf::base::DateTime)) {
            std::vector<lsst::daf::base::DateTime> vec  = ps.getArray<lsst::daf::base::DateTime>(name);
            std::vector<lsst::daf::base::DateTime>::iterator iter;
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                boost::property_tree::ptree pt;
                pt.put("datetime", (*iter).nsecs());
                child.put_child(name, pt);
            }
        } else {
            std::string msg("Couldn't marshall "+name);
            throw LSST_EXCEPT(pexExceptions::RuntimeError, msg);
        }
    }
    std::ostringstream payload;
    write_json(payload, child, false);

    return payload.str();
}

PropertySet::Ptr lsst.ctrl.events::Event::parsePropertySet ( boost::property_tree::ptree  child )

private

private method to iterate through the representation of a propertyset within the boost::property_tree::ptree

Parameters

child

a boost::property_tree::ptree to iterate through

Returns

a PropertySet::Ptr containing the data that was stored in child.

Definition at line 471 of file Event.cc.

                                                                    {
    PropertySet::Ptr psp(new PropertySet);
    
    BOOST_FOREACH(boost::property_tree::ptree::value_type const &v, child.get_child("")) {
        std::string label = v.first;
        BOOST_FOREACH(boost::property_tree::ptree::value_type &v2, child.get_child(label)) {
            const bool b = addDataItem(v2.first, v2.second, label, *psp);
            if (!b) {
                PropertySet::Ptr p2 = parsePropertySet(child.get_child(label));
                psp->add(label, p2);
                break;
            }
        }
    }
    return psp;
}

void lsst.ctrl.events::Event::populateHeader ( cms::TextMessage *  msg ) const

virtual

populate a cms::TextMessage header with properties

Parameters

[in]

msg

a cms::TextMessage

Reimplemented in lsst.ctrl.events::CommandEvent, lsst.ctrl.events::StatusEvent, and lsst.ctrl.events::LogEvent.

Definition at line 241 of file Event.cc.

                                                     {
    set<std::string>::iterator keyIterator;
    for (keyIterator = _keywords.begin(); keyIterator != _keywords.end(); keyIterator++) {
        std::string const& name = *keyIterator;
        std::type_info const& t = _psp->typeOf(name);
        if (t == typeid(bool)) {
            msg->setBooleanProperty(name, _psp->get<bool>(name));
        } else if (t == typeid(short)) {
            msg->setShortProperty(name, _psp->get<short>(name));
        } else if (t == typeid(int)) {
            msg->setIntProperty(name, _psp->get<int>(name));
        } else if (t == typeid(long)) {
            msg->setLongProperty(name, _psp->get<long>(name));
        } else if (t == typeid(long long)) {
            msg->setLongProperty(name, _psp->get<long long>(name));
        } else if (t == typeid(double)) {
            msg->setDoubleProperty(name, _psp->get<double>(name));
        } else if (t == typeid(float)) {
            msg->setFloatProperty(name, _psp->get<float>(name));
        } else if (t == typeid(std::string)) {
            msg->setStringProperty(name, _psp->get<std::string>(name));
        } else {
            std::string msg("Data type represented in "+ name +" is not permitted in event header");
            throw LSST_EXCEPT(pexExceptions::RuntimeError, msg);
        }
    }
}

PropertySet::Ptr lsst.ctrl.events::Event::processTextMessage ( cms::TextMessage *  textMessage )

private

private method unmarshall the DataProperty from the TextMessage

Definition at line 419 of file Event.cc.

                                                                    {
    if (textMessage == NULL)
        return PropertySet::Ptr();

    std::string text = textMessage->getText();

    return unmarshall(text);
}

void lsst.ctrl.events::Event::setEventTime

(

long long

nsecs

)

set the event creation time

Definition at line 274 of file Event.cc.

                                        {
    _psp->set(EVENTTIME,  nsecs);
}

void lsst.ctrl.events::Event::setPubTime

(

long long

t

)

set the publication time of this Event

Definition at line 310 of file Event.cc.

                                  {
    _psp->set(PUBTIME, t);
}

void lsst.ctrl.events::Event::setStatus

(

std::string

status

)

set the Event status

Parameters

[in]

status

string representation of the Event status

Definition at line 343 of file Event.cc.

                                       {
    return _psp->set(STATUS, status);
}

void lsst.ctrl.events::Event::setTopic

(

std::string

topic

)

set the Event topic

Parameters

[in]

topic

string representation of the Event topic

Definition at line 347 of file Event.cc.

                                    {
    _psp->set(TOPIC, topic);
}

PropertySet::Ptr lsst.ctrl.events::Event::unmarshall ( std::string const &  text )

private

private method unmarshall the DataProperty from a text string

Parameters

text	a JSON text string

Returns

a PropertySet::Ptr containing the data that was stored in text

Definition at line 492 of file Event.cc.

                                                      {

    boost::property_tree::ptree pt;
    std::istringstream is (text);
    read_json(is, pt);

    PropertySet::Ptr psp(new PropertySet);

    BOOST_FOREACH(boost::property_tree::ptree::value_type &v, pt) {
        std::string key = v.first;

        boost::property_tree::ptree child = v.second;
        BOOST_FOREACH(boost::property_tree::ptree::value_type &v2, child) {
            std::string key2 = v2.first;

            const bool b = addDataItem(key2, v2.second, key, *psp);
            if (!b) {
                std::string value = v2.second.get_value<std::string>();
                PropertySet::Ptr p = parsePropertySet(child);
                psp->add(key, p);
                break;
            }
        }
    }
        
    return psp;
}

void lsst.ctrl.events::Event::updateEventTime

(

)

update the Event time to the current time

Definition at line 278 of file Event.cc.

                            {
    _psp->set(EVENTTIME,  (long long)dafBase::DateTime::now().nsecs());
}

Member Data Documentation

PropertySet::Ptr lsst.ctrl.events::Event::_filterable

protected

Definition at line 237 of file Event.h.

set<std::string> lsst.ctrl.events::Event::_keywords

protected

Definition at line 238 of file Event.h.

PropertySet::Ptr lsst.ctrl.events::Event::_psp

protected

Definition at line 236 of file Event.h.

const std::string lsst.ctrl.events::Event::EVENTTIME = "EVENTTIME"

static

Definition at line 67 of file Event.h.

const std::string lsst.ctrl.events::Event::PUBTIME = "PUBTIME"

static

Definition at line 71 of file Event.h.

const std::string lsst.ctrl.events::Event::RUNID = "RUNID"

static

Definition at line 68 of file Event.h.

const std::string lsst.ctrl.events::Event::STATUS = "STATUS"

static

Definition at line 69 of file Event.h.

const std::string lsst.ctrl.events::Event::TOPIC = "TOPIC"

static

Definition at line 70 of file Event.h.

const std::string lsst.ctrl.events::Event::TYPE = "TYPE"

static

Definition at line 66 of file Event.h.

const std::string lsst.ctrl.events::Event::UNINITIALIZED = "uninitialized"

static

Definition at line 72 of file Event.h.

---

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

• /home/lsstsw/stack/Linux64/ctrl_events/10.0-6-g462a451+1/include/lsst/ctrl/events/Event.h
• /home/lsstsw/stack/Linux64/ctrl_events/10.0-6-g462a451+1/src/Event.cc