xref: /src/external/bsd/elftosb/dist/common/OptionDictionary.cpp

/*
 * File:	OptionDictionary.h
 *
 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
 * See included license file for license details.
 */

#include "OptionDictionary.h"

using namespace elftosb;

//! Deletes all of the option values that have been assigned locally.
//!
OptionDictionary::~OptionDictionary()
{
	option_map_t::iterator it = m_options.begin();
	for (; it != m_options.end(); ++it)
	{
		if (it->second.m_value)
		{
			delete it->second.m_value;
		}
	}
}

//! If a parent context has been set and the option does not exist in
//! this instance, then the parent is asked if it contains the option.
//!
//! \param name The name of the option to query.
//! \retval true The option is present in this instance or one of the parent.
//! \retval false No option with that name is in the dictionary, or any parent
bool OptionDictionary::hasOption(const std::string & name) const
{
	bool hasIt = (m_options.find(name) != m_options.end());
	if (!hasIt && m_parent)
	{
		return m_parent->hasOption(name);
	}
	return hasIt;
}

//! If this object does not contain an option with the name of \a name,
//! then the parent is asked for the value (if a parent has been set).
//!
//! \param name The name of the option.
//! \return The value for the option named \a name.
//! \retval NULL No option is in the table with that name. An option may also
//!		explicitly be set to a NULL value. The only way to tell the difference
//!		is to use the hasOption() method.
const Value * OptionDictionary::getOption(const std::string & name) const
{
	option_map_t::const_iterator it = m_options.find(name);
	if (it == m_options.end())
	{
		if (m_parent)
		{
			return m_parent->getOption(name);
		}
		else
		{
			return NULL;
		}
	}

	return it->second.m_value;
}

//! If the option was not already present in the table, it is added.
//! Otherwise the old value is replaced. The option is always set locally;
//! parent objects are never modified.
//!
//! If the option has been locked with a call to lockOption() before trying
//! to set its value, the setOption() is effectively ignored. To tell if
//! an option is locked, use the isOptionLocked() method.
//!
//! \warning If the option already had a value, that previous value is deleted.
//!		This means that it cannot currently be in use by another piece of code.
//!		See the note in getOption().
//!
//! \param name The option's name.
//! \param value New value for the option.
void OptionDictionary::setOption(const std::string & name, Value * value)
{
	option_map_t::iterator it = m_options.find(name);
	OptionValue newValue;

	// delete the option value instance before replacing it
	if (it != m_options.end())
	{
		// Cannot modify value if locked.
		if (it->second.m_isLocked)
		{
			return;
		}

		if (it->second.m_value)
		{
			delete it->second.m_value;
		}

		// save previous locked value
		newValue.m_isLocked = it->second.m_isLocked;
	}

	// set new option value
	newValue.m_value = value;
	m_options[name] = newValue;
}

//! \param name The name of the option to remove.
//!
void OptionDictionary::deleteOption(const std::string & name)
{
	if (m_options.find(name) != m_options.end())
	{
		if (m_options[name].m_value)
		{
			delete m_options[name].m_value;
		}
		m_options.erase(name);
	}
}

//! \param name Name of the option to query.
//!
//! \return True if the option is locked, false if unlocked or not present.
//!
bool OptionDictionary::isOptionLocked(const std::string & name) const
{
	option_map_t::const_iterator it = m_options.find(name);
	if (it != m_options.end())
	{
		return it->second.m_isLocked;
	}

	return false;
}

//! \param name Name of the option to lock.
//!
void OptionDictionary::lockOption(const std::string & name)
{
	if (!hasOption(name))
	{
		m_options[name].m_value = 0;
	}

	m_options[name].m_isLocked = true;
}

//! \param name Name of the option to unlock.
//!
void OptionDictionary::unlockOption(const std::string & name)
{
	if (!hasOption(name))
	{
		m_options[name].m_value = 0;
	}

	m_options[name].m_isLocked = false;
}


//! Simply calls getOption().
//!
const Value * OptionDictionary::operator [] (const std::string & name) const
{
	return getOption(name);
}