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