//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/PropertyManager.h"
#include "MantidKernel/Exception.h"
#include <boost/tokenizer.hpp>
#include <algorithm>
namespace Mantid
{
namespace Kernel
{
using std::string;
// Get a reference to the logger
Logger& PropertyManager::g_log = Logger::get("PropertyManager");
//-----------------------------------------------------------------------------------------------
/// Default constructor
PropertyManager::PropertyManager() :
m_properties(), m_orderedProperties()
{
}
//-----------------------------------------------------------------------------------------------
/// copy constructor
/// @param other :: the PropertyManager to copy
PropertyManager::PropertyManager(const PropertyManager& other) :
m_properties(), m_orderedProperties(other.m_orderedProperties.size())
{
// We need to do a deep copy of the property pointers here
for (unsigned int i = 0; i < m_orderedProperties.size(); ++i)
{
Property * p = other.m_orderedProperties[i]->clone();
this->m_orderedProperties[i] = p;
std::string key = p->name();
std::transform(key.begin(), key.end(), key.begin(), toupper);
this->m_properties[key] = p;
}
}
//-----------------------------------------------------------------------------------------------
/// Assignment operator - performs a deep copy
/// @param other :: the PropertyManager to copy
/// @return pointer to this
PropertyManager& PropertyManager::operator=(const PropertyManager& other)
{
// We need to do a deep copy here
if ( this != &other )
{
for ( PropertyMap::iterator it = m_properties.begin(); it != m_properties.end(); ++it )
{
delete it->second;
}
this->m_properties.clear();
this->m_orderedProperties.resize(other.m_orderedProperties.size());
for (unsigned int i = 0; i < m_orderedProperties.size(); ++i)
{
Property * p = other.m_orderedProperties[i]->clone();
this->m_orderedProperties[i] = p;
std::string key = p->name();
std::transform(key.begin(), key.end(), key.begin(), toupper);
this->m_properties[key] = p;
}
}
return *this;
}
//-----------------------------------------------------------------------------------------------
/// Virtual destructor
PropertyManager::~PropertyManager()
{
for ( PropertyMap::iterator it = m_properties.begin(); it != m_properties.end(); ++it )
{
delete it->second;
}
}
//-----------------------------------------------------------------------------------------------
/**
* Addition operator
* @param rhs :: The object that is being added to this.
* @returns A reference to the summed object
*/
PropertyManager& PropertyManager::operator+=(const PropertyManager& rhs)
{
//Iterate through all properties on the RHS
PropertyMap::const_iterator it;
for (it = rhs.m_properties.begin(); it != rhs.m_properties.end(); it++)
{
//The name on the rhs
string rhs_name = it->first;
try
{
Property * lhs_prop = this->getPointerToProperty(rhs_name);
//Use the property's += operator to add THAT. Isn't abstraction fun?!
(*lhs_prop) += it->second;
}
catch (Exception::NotFoundError err)
{
//The property isnt on the lhs.
//Let's copy it
Property * copy = it->second->clone();
//And we add a copy of that property to *this
this->declareProperty(copy, "");
}
//(*it->second) +=
}
return *this;
}
//-----------------------------------------------------------------------------------------------
/**
* Filter out a run by time. Takes out any TimeSeriesProperty log entries outside of the given
* absolute time range.
*
* @param start :: Absolute start time. Any log entries at times >= to this time are kept.
* @param stop :: Absolute stop time. Any log entries at times < than this time are kept.
*/
void PropertyManager::filterByTime(const Kernel::DateAndTime start, const Kernel::DateAndTime stop)
{
//Iterate through all properties
PropertyMap::const_iterator it;
for (it = this->m_properties.begin(); it != this->m_properties.end(); it++)
{
//Filter out the property
Property * prop = it->second;
prop->filterByTime(start, stop);
}
}
//-----------------------------------------------------------------------------------------------
/**
* Split a run by time (splits the TimeSeriesProperties contained).
*
* Total proton charge will get re-integrated after filtering.
*
* @param splitter :: TimeSplitterType with the intervals and destinations.
* @param outputs :: Vector of output runs.
*/
void PropertyManager::splitByTime(TimeSplitterType& splitter, std::vector< PropertyManager * > outputs) const
{
size_t n = outputs.size();
//Iterate through all properties
PropertyMap::const_iterator it;
for (it = this->m_properties.begin(); it != this->m_properties.end(); it++)
{
//Filter out the property
Property * prop = it->second;
//Make a vector of the output properties contained in the other property managers.
// NULL if it was not found.
std::vector< Property *> output_properties;
for (size_t i=0; i<n; i++)
{
if (outputs[i])
output_properties.push_back( outputs[i]->getPointerToPropertyOrNull( prop->name() ) );
else
output_properties.push_back( NULL );
}
//Now the property does the splitting.
prop->splitByTime(splitter, output_properties);
}//for each property
}
//-----------------------------------------------------------------------------------------------
/** Add a property to the list of managed properties
* @param p :: The property object to add
* @param doc :: A description of the property that may be displayed to users
* @throw Exception::ExistsError if a property with the given name already exists
* @throw std::invalid_argument if the property declared has an empty name.
*/
void PropertyManager::declareProperty( Property *p, const std::string &doc )
{
// Get the name of the property and don't permit empty names
std::string key = p->name();
if (key.empty())
{
delete p;
throw std::invalid_argument("An empty property name is not permitted");
}
std::transform(key.begin(), key.end(), key.begin(), toupper);
if ( m_properties.insert(PropertyMap::value_type(key, p)).second)
{
m_orderedProperties.push_back(p);
}
else
{
// Don't delete if this is actually the same property object!!!
if ( m_properties.find(key)->second != p ) delete p;
throw Exception::ExistsError( "Property with given name already exists", key );
}
p->setDocumentation(doc);
}
//-----------------------------------------------------------------------------------------------
/** Set the ordered list of properties by one string of values.
* @param propertiesArray :: The list of property values
* @throw invalid_argument if error in parameters
*/
// Care will certainly be required in the calling of this function or it could all go horribly wrong!
void PropertyManager::setProperties( const std::string &propertiesArray )
{
// Split up comma-separated properties
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(";");
tokenizer propPairs(propertiesArray, sep);
int index=0;
// Iterate over the properties
for (tokenizer::iterator it = propPairs.begin(); it != propPairs.end(); ++it)
{
boost::char_separator<char> sep2("=");
tokenizer properties(*it,sep2);
std::vector<std::string> property(properties.begin(), properties.end());
// Call the appropriate setProperty method on the algorithm
if ( property.size() == 2)
{
setPropertyValue(property[0],property[1]);
}
else if ( property.size() == 1)
{
// This is for a property with no value. Not clear that we will want such a thing.
setPropertyOrdinal(index,property[0]);
}
// Throw if there's a problem with the string
else
{
throw std::invalid_argument("Misformed properties string");
}
index++;
}
}
//-----------------------------------------------------------------------------------------------
/** Set the value of a property by string
* N.B. bool properties must be set using 1/0 rather than true/false
* @param name :: The name of the property (case insensitive)
* @param value :: The value to assign to the property
* @throw Exception::NotFoundError if the named property is unknown
* @throw std::invalid_argument If the value is not valid for the property given
*/
void PropertyManager::setPropertyValue( const std::string &name, const std::string &value )
{
Property *p = getPointerToProperty(name); // throws NotFoundError if property not in vector
std::string errorMsg = p->setValue(value);
if ( !errorMsg.empty() )
{
errorMsg = "Invalid value for property " + p->name() + " (" +p->type() + ") \"" + value
+ "\": " + errorMsg;
throw std::invalid_argument(errorMsg);
}
}
//-----------------------------------------------------------------------------------------------
/** Set the value of a property by an index
* N.B. bool properties must be set using 1/0 rather than true/false
* @param index :: The index of the property to assign
* @param value :: The value to assign to the property
* @throw std::runtime_error if the property index is too high
* @throw std::invalid_argument If the value is not valid for the property given
*/
void PropertyManager::setPropertyOrdinal( const int& index, const std::string &value )
{
Property *p = getPointerToPropertyOrdinal(index); // throws runtime_error if property not in vector
std::string errorMsg = p->setValue(value);
if ( !errorMsg.empty() )
{
errorMsg = "Invalid value for property " + p->name() + " (" +p->type() + ") \"" + value
+ "\" : " + errorMsg;
throw std::invalid_argument(errorMsg);
}
}
//-----------------------------------------------------------------------------------------------
/** Checks whether the named property is already in the list of managed property.
* @param name :: The name of the property (case insensitive)
* @return True if the property is already stored
*/
bool PropertyManager::existsProperty( const std::string& name ) const
{
try
{
getPointerToProperty(name);
return true;
}
catch (Exception::NotFoundError&)
{
return false;
}
}
//-----------------------------------------------------------------------------------------------
/** Validates all the properties in the collection
* @return True if all properties have a valid value
*/
bool PropertyManager::validateProperties() const
{
bool allValid = true;
for ( PropertyMap::const_iterator it = m_properties.begin(); it != m_properties.end(); ++it )
{
//check for errors in each property
std::string error = it->second->isValid();
//"" means no error
if ( !error.empty() )
{
g_log.error() << "Property \"" << it->first << "\" is not set to a valid value: \"" <<
error << "\"." << std::endl;
allValid=false;
}
}
return allValid;
}
//-----------------------------------------------------------------------------------------------
/** Get the value of a property as a string
* @param name :: The name of the property (case insensitive)
* @return The value of the named property
* @throw Exception::NotFoundError if the named property is unknown
*/
std::string PropertyManager::getPropertyValue( const std::string &name ) const
{
Property *p = getPointerToProperty(name); // throws NotFoundError if property not in vector
return p->value();
}
//-----------------------------------------------------------------------------------------------
/** Get a property by name
* @param name :: The name of the property (case insensitive)
* @return A pointer to the named property
* @throw Exception::NotFoundError if the named property is unknown
*/
Property* PropertyManager::getPointerToProperty( const std::string &name ) const
{
std::string ucName = name;
std::transform(ucName.begin(), ucName.end(), ucName.begin(), toupper);
PropertyMap::const_iterator it = m_properties.find(ucName);
if (it != m_properties.end())
{
return it->second;
}
throw Exception::NotFoundError("Unknown property", name);
}
//-----------------------------------------------------------------------------------------------
/** Get a property by name
* @param name :: The name of the property (case insensitive)
* @return A pointer to the named property; NULL if not found
*/
Property* PropertyManager::getPointerToPropertyOrNull( const std::string &name ) const
{
std::string ucName = name;
std::transform(ucName.begin(), ucName.end(), ucName.begin(), toupper);
PropertyMap::const_iterator it = m_properties.find(ucName);
if (it != m_properties.end())
{
return it->second;
}
return NULL;
}
//-----------------------------------------------------------------------------------------------
/** Get a property by an index
* @param index :: The name of the property (case insensitive)
* @return A pointer to the named property
* @throw std::runtime_error if the property index is too high
*/
Property* PropertyManager::getPointerToPropertyOrdinal( const int& index) const
{
if ( index < static_cast<int>(m_orderedProperties.size()) )
{
return m_orderedProperties[index];
}
throw std::runtime_error("Property index too high");
}
//-----------------------------------------------------------------------------------------------
/** Get the list of managed properties.
* The properties will be stored in the order that they were declared.
* @return A vector holding pointers to the list of properties
*/
const std::vector< Property* >& PropertyManager::getProperties() const
{
return m_orderedProperties;
}
//-----------------------------------------------------------------------------------------------
/** Get the value of a property. Allows you to assign directly to a variable of the property's type
* (if a supported type).
*
* *** This method does NOT work for assigning to an existing std::string.
* In this case you have to use getPropertyValue() instead.
* Note that you can, though, construct a local string variable by writing,
* e.g. std::string s = getProperty("myProperty"). ***
*
* @param name :: The name of the property
* @return The value of the property. Will be cast to the desired type (if a supported type).
* @throw std::runtime_error If an attempt is made to assign a property to a different type
* @throw Exception::NotFoundError If the property requested does not exist
*/
PropertyManager::TypedValue PropertyManager::getProperty( const std::string &name ) const
{
return TypedValue(*this, name);
}
//-----------------------------------------------------------------------------------------------
/** Removes the property from properties map.
* @param name :: name of the property to be removed.
*/
void PropertyManager::removeProperty(const std::string &name)
{
if(existsProperty(name))
{
//remove it
Property* prop=getPointerToProperty(name);
std::string key = name;
std::transform(key.begin(), key.end(), key.begin(), toupper);
m_properties.erase(key);
std::vector<Property*>::iterator itr;
itr=find(m_orderedProperties.begin(),m_orderedProperties.end(),prop);
m_orderedProperties.erase(itr);
delete prop;
}
}
} // namespace Kernel
} // namespace Mantid