Map.cpp

Go to the documentation of this file.

#include "Map.h"
#include "madara/knowledge/ContextGuard.h"

#include <algorithm>

madara::knowledge::containers::Map::Map (
  const KnowledgeUpdateSettings & settings,
  const std::string & delimiter)
  : BaseContainer ("", settings), context_ (0), delimiter_ (delimiter)
{
}
  
madara::knowledge::containers::Map::Map (
  const std::string & name,
  KnowledgeBase & knowledge,
  const KnowledgeUpdateSettings & settings,
  const std::string & delimiter)
  : BaseContainer (name, settings), context_ (&(knowledge.get_context ())),
  delimiter_ (delimiter)
{
  std::map <std::string, knowledge::KnowledgeRecord> contents;
  std::string common = name + delimiter_;
  context_->to_map (common, contents);
  
  KnowledgeUpdateSettings keep_local (true);
  if (contents.size () > 0)
  {
    for (std::map <std::string, knowledge::KnowledgeRecord>::iterator i =
      contents.begin (); i != contents.end (); ++i)
    {
      map_[i->first.substr (common.size ())] =
        knowledge.get_ref (i->first, keep_local);
    }
  }
}
 
madara::knowledge::containers::Map::Map (
  const std::string & name,
  Variables & knowledge,
  const KnowledgeUpdateSettings & settings,
  const std::string & delimiter)
  : BaseContainer (name, settings), context_ (knowledge.get_context ()),
  delimiter_ (delimiter)
{
  std::map <std::string, knowledge::KnowledgeRecord> contents;
  std::string common = name + delimiter_;
  context_->to_map (common, contents);
  
  KnowledgeUpdateSettings keep_local (true);
  if (contents.size () > 0)
  {
    for (std::map <std::string, knowledge::KnowledgeRecord>::iterator i =
      contents.begin (); i != contents.end (); ++i)
    {
      map_[i->first.substr (common.size ())] =
        knowledge.get_ref (i->first, keep_local);
    }
  }
}
       

madara::knowledge::containers::Map::Map (const Map & rhs)
: BaseContainer (rhs), context_ (rhs.context_),
  map_ (rhs.map_),
  delimiter_ (rhs.delimiter_)
{

}

madara::knowledge::containers::Map::~Map ()
{

}

void
madara::knowledge::containers::Map::modify (void)
{
  if (context_ && name_ != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    for (InternalMap::const_iterator index = map_.begin ();
         index != map_.end (); ++index)
    {
      context_->mark_modified (index->second);
    }
  }
}

std::string
madara::knowledge::containers::Map::get_debug_info (void)
{
  std::stringstream result;

  result << "Map: ";

  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    result << this->name_;
    result << " [" << map_.size () << "]";
    result << " = [";

    bool first (true);
    
    for (InternalMap::const_iterator index = map_.begin ();
      index != map_.end (); ++index)
    {
      if (!first)
      {
        result << ", ";
      }
      else
      {
        first = false;
      }

      result << index->first << " => " <<
        context_->get (index->second).to_string ();
    }

    result << "]";
  }

  return result.str ();
}


void
madara::knowledge::containers::Map::modify_ (void)
{
  modify ();
}

std::string
madara::knowledge::containers::Map::get_debug_info_ (void)
{
  return get_debug_info ();
}

madara::knowledge::containers::BaseContainer *
madara::knowledge::containers::Map::clone (void) const
{
  return new Map (*this);
}

void
madara::knowledge::containers::Map::modify (const std::string & index)
{
  if (context_ && name_ != "" && map_.find (index) != map_.end ())
  {
    ContextGuard context_guard (*context_);
    context_->mark_modified (map_[index]);
  }
}


void
madara::knowledge::containers::Map::operator= (
  const Map & rhs)
{
  if (this != &rhs)
  {
    MADARA_GUARD_TYPE guard (mutex_), guard2 (rhs.mutex_);

    this->context_ = rhs.context_;
    this->name_ = rhs.name_;
    this->settings_ = rhs.settings_;
    this->map_ = rhs.map_;
  }
}

madara::knowledge::KnowledgeRecord
madara::knowledge::containers::Map::to_record (
  const std::string & key)
{
  knowledge::KnowledgeRecord result;

  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);
    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;
  
    KnowledgeUpdateSettings keep_local (true);
    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::const_iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, keep_local);
      map_[key] = ref;
      return context_->get (ref, keep_local);
    }

    result = context_->get (entry->second, keep_local);
  }

  return result;
}

madara::knowledge::KnowledgeRecord
madara::knowledge::containers::Map::operator[] (
  const std::string & key)
{
  return to_record (key);
}

size_t
madara::knowledge::containers::Map::size (void) const
{
  MADARA_GUARD_TYPE guard (mutex_);
  return map_.size ();
}


std::vector <std::string>
madara::knowledge::containers::Map::sync_keys (void)
{
  std::vector <std::string> additions;

  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    clear (false);

    std::map <std::string, knowledge::KnowledgeRecord> contents;
    std::string common = name_ + delimiter_;
    context_->to_map (common, contents);
    KnowledgeUpdateSettings keep_local (true);

    for (std::map <std::string, knowledge::KnowledgeRecord>::iterator i =
      contents.begin (); i != contents.end (); ++i)
    {
      std::string key = i->first.substr (common.size ());

      if (map_.find (key) == map_.end ())
      {
        additions.push_back (key);
        map_[key] = context_->get_ref (i->first, keep_local);
      }
    }
  }

  return additions;
}


void
madara::knowledge::containers::Map::exchange (
  Map & other, bool refresh_keys, bool delete_keys)
{
  if (context_ && other.context_)
  {
    std::lock(*context_, *other.context_, mutex_, other.mutex_);

    ContextGuard context_guard (*context_, std::adopt_lock);
    ContextGuard other_context_guard (*other.context_, std::adopt_lock);
    MADARA_GUARD_TYPE guard (mutex_, std::adopt_lock),
                      guard2 (other.mutex_, std::adopt_lock);


    if (refresh_keys)
    {
      other.sync_keys ();
      this->sync_keys ();
    }

    InternalMap leftover (other.map_);
    InternalMap::iterator i = map_.begin ();
    while (i != map_.end ())
    {
      // temp = this[i->first]
      knowledge::KnowledgeRecord temp = this->context_->get (i->second, this->settings_);

      // check if the other map has the key
      InternalMap::iterator other_found = other.map_.find (i->first);

      if (other_found != other.map_.end ())
      {
        // this[i->first] = other[i->first]
        this->context_->set (i->second, 
          other.context_->get (other_found->second, other.settings_),
          this->settings_);

        // other[i->first] = temp
        other.map_ [i->first] = other_found->second;
        other.context_->set (other_found->second, temp, other.settings_);

        // remove item from the items leftover
        leftover.erase (i->first);
      }
      else
      {
        std::stringstream buffer;
        buffer << other.name_;
        buffer << delimiter_;
        buffer << i->first;

        // other[i->first] = temp
        VariableReference ref = other.context_->get_ref (
          buffer.str (), other.settings_);
        other.map_[i->first] = ref;
        other.context_->set (ref, temp, other.settings_);
      
        // this[i->first] = zero
        if (delete_keys)
        {
          std::stringstream buffer2;
          buffer2 << this->name_;
          buffer2 << delimiter_;
          buffer2 << i->first;

          this->context_->delete_variable (buffer2.str (), this->settings_);
          this->map_.erase (i++);
        }
        else
        {
          knowledge::KnowledgeRecord zero;
          this->context_->set (i->second, zero, this->settings_);
          ++i;
        }
      }
    }

    // iterate over the elements in the other.map_ that are not in the current map
  
    for (i = leftover.begin (); i != leftover.end (); ++i)
    {
      if (map_.find (i->first) == map_.end ())
      {
        std::stringstream buffer;
        buffer << name_;
        buffer << delimiter_;
        buffer << i->first;

        VariableReference ref = context_->get_ref (buffer.str (), settings_);
        this->map_[i->first] = ref;

        // this[i->first] = other[i->first]
        this->context_->set (ref,
          other.context_->get (i->second, other.settings_),
          this->settings_);
      
        // other[i->first] = zero;
        if (delete_keys)
        {
          std::stringstream buffer2;
          buffer2 << other.name_;
          buffer2 << delimiter_;
          buffer2 << i->first;

          other.context_->delete_variable (buffer2.str (), settings_);
          other.map_.erase (i->first);
        }
        else
        {
          knowledge::KnowledgeRecord zero;
          other.context_->set (i->second, zero, other.settings_);
        }
      }
    }
  }
}

void
madara::knowledge::containers::Map::clear (bool clear_knowledge)
{
  if (clear_knowledge)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::vector <std::string> keys;
    this->keys (keys);

    for (size_t i = 0; i < keys.size (); ++i)
      this->erase (keys[i]);
  }
  else
  {
    MADARA_GUARD_TYPE guard (mutex_);
    map_.clear ();
  }
}

void
madara::knowledge::containers::Map::erase (const std::string & key)
{
  if (context_)
  {
    ContextGuard context_guard (*context_);

    // find the key in the internal map
    InternalMap::iterator found = map_.find (key);

    // delete the variable if it has been found
    if (found != map_.end ())
    {
      context_->delete_variable (found->second.get_name ());
    }
  }
}

void
madara::knowledge::containers::Map::set_name (
  const std::string & var_name,
  KnowledgeBase & knowledge, bool sync)
{
  if (context_ != &(knowledge.get_context ()) || name_ != var_name)
  {
    context_ = &(knowledge.get_context ());

    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    name_ = var_name;

    // the old map will no longer be appropriate
    clear (false);
    if (sync)
      sync_keys ();
  }
}

void
madara::knowledge::containers::Map::set_name (
  const std::string & var_name,
  Variables & knowledge, bool sync)
{
  if (context_ != knowledge.get_context () || name_ != var_name)
  {
    context_ = knowledge.get_context ();

    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    name_ = var_name;

    // the old map will no longer be appropriate
    clear (false);
    if (sync)
      sync_keys ();
  }
}

void
madara::knowledge::containers::Map::set_delimiter (
  const std::string & delimiter,
  bool sync)
{
  delimiter_ = delimiter;

  if (context_)
  {
    // the old map will no longer be appropriate
    clear (false);
    if (sync)
      sync_keys ();
  }
}


std::string
madara::knowledge::containers::Map::get_delimiter (void)
{
  return delimiter_;
}

bool
madara::knowledge::containers::Map::exists (
  const std::string & key) const
{
  bool result (false);

  InternalMap::const_iterator found = map_.find (key);

  if (context_ && found != map_.end ())
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    result = context_->exists (found->second);
  }

  return result;
}

bool
madara::knowledge::containers::Map::has_prefix (
const std::string & prefix) const
{
  bool result (false);

  InternalMap::const_iterator found = map_.lower_bound (prefix);

  if (found != map_.end ())
  {
    if (madara::utility::begins_with (found->first, prefix))
      result = true;
  }

  return result;
}

void
madara::knowledge::containers::Map::keys (
  std::vector <std::string> & curkeys) const
{
  MADARA_GUARD_TYPE guard (mutex_);
  curkeys.resize (map_.size ());
  unsigned int j = 0;

  for (std::map <std::string, VariableReference>::const_iterator i =
         map_.begin ();
       i != map_.end (); ++i, ++j)
  {
    curkeys[j] = i->first;
  }
}



int
madara::knowledge::containers::Map::read_file (
  const std::string & key,
  const std::string & filename)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;
  
    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->read_file (ref, filename, settings_);
    }
    else
    {
      result = context_->read_file (entry->second, filename, settings_);
    }
  }
  return result;
}
 
int
madara::knowledge::containers::Map::read_file (
  const std::string & key,
  const std::string & filename, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;
  
    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->read_file (ref, filename, settings);
    }
    else
    {
      result = context_->read_file (entry->second, filename, settings);
    }
  }
  return result;
}
      
int
madara::knowledge::containers::Map::set (const std::string & key,
  madara::knowledge::KnowledgeRecord::Integer value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);
    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set (const std::string & key,
  madara::knowledge::KnowledgeRecord::Integer value, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set (ref, value, settings);
    }
    else
    {
      result = context_->set (entry->second, value, settings);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_index (
  const std::string & key,
  size_t index,
  madara::knowledge::KnowledgeRecord::Integer value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set_index (ref, index, value, settings_);
    }
    else
    {
      result = context_->set_index (entry->second, index, value, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_index (
  const std::string & key,
  size_t index,
  madara::knowledge::KnowledgeRecord::Integer value,
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set_index (ref, index, value, settings);
    }
    else
    {
      result = context_->set_index (entry->second, index, value, settings);
    }
  }

  return result;
}


int
madara::knowledge::containers::Map::set (const std::string & key,
  const madara::knowledge::KnowledgeRecord::Integer * value,
  uint32_t size)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, size, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, size, settings_);
    }
  }

  return result;
}
 
int
madara::knowledge::containers::Map::set (const std::string & key,
  const madara::knowledge::KnowledgeRecord::Integer * value,
  uint32_t size,
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set (ref, value, size, settings);
    }
    else
    {
      result = context_->set (entry->second, value, size, settings);
    }
  }

  return result;
}
       
int
madara::knowledge::containers::Map::set (
const std::string & key,
  const std::vector <KnowledgeRecord::Integer> & value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set (
  const std::string & key,
  const std::vector <KnowledgeRecord::Integer> & value,
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      return context_->set (ref, value, settings);
    }
    else
    {
      result = context_->set (entry->second, value, settings);
    }
  }

  return result;
}
          
int
madara::knowledge::containers::Map::set (
  const std::string & key,
  double value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, settings_);
    }
  }

  return result;
}
    
int
madara::knowledge::containers::Map::set (const std::string & key,
  double value, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set (ref, value, settings);
    }
    else
    {
      result = context_->set (entry->second, value, settings);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_index (
  const std::string & key,
  size_t index,
  double value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set_index (ref, index, value, settings_);
    }
    else
    {
      result = context_->set_index (entry->second, index, value, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_index (const std::string & key,
  size_t index,
  double value,
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set_index (ref, index, value, settings);
    }
    else
    {
      result = context_->set_index (entry->second, index, value, settings);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set (const std::string & key,
  const double * value,
  uint32_t size)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, size, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, size, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set (const std::string & key,
  const double * value,
  uint32_t size,
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set (ref, value, size, settings);
    }
  
    result = context_->set (entry->second, value, size, settings);
  }

  return result;
}
 
int
madara::knowledge::containers::Map::set (const std::string & key,
  const std::vector <double> & value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, settings_);
    }
  }

  return result;
}
 
int
madara::knowledge::containers::Map::set (const std::string & key,
  const std::vector <double> & value,
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set (ref, value, settings);
    }
    else
    {
      result = context_->set (entry->second, value, settings);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set (const std::string & key,
  const std::string & value)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set (ref, value, settings_);
    }
    else
    {
      result = context_->set (entry->second, value, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set (const std::string & key,
  const std::string & value, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set (ref, value, settings);
    }
    else
    {
      result = context_->set (entry->second, value, settings);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_file (const std::string & key,
  const unsigned char * value, size_t size)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set_file (ref, value, size, settings_);
    }
    else
    {
      result = context_->set_file (entry->second, value, size, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_file (const std::string & key,
  const unsigned char * value, size_t size, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set_file (ref, value, size, settings);
    }
  
    result = context_->set_file (entry->second, value, size, settings);
  }

  return result;
}

int
madara::knowledge::containers::Map::set_jpeg (const std::string & key,
  const unsigned char * value, size_t size)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings_);
      map_[key] = ref;
      result = context_->set_jpeg (ref, value, size, settings_);
    }
    else
    {
      result = context_->set_jpeg (entry->second, value, size, settings_);
    }
  }

  return result;
}

int
madara::knowledge::containers::Map::set_jpeg (const std::string & key,
  const unsigned char * value, size_t size, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

  if (context_ && key != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    std::string final_key = buffer.str ();
    std::map <std::string, VariableReference>::iterator entry =
      map_.find (final_key);

    if (entry == map_.end ())
    {
      VariableReference ref = context_->get_ref (final_key, settings);
      map_[key] = ref;
      result = context_->set_jpeg (ref, value, size, settings);
    }
    else
    {
      result = context_->set_jpeg (entry->second, value, size, settings);
    }
  }

  return result;
}

void madara::knowledge::containers::Map::set_quality (
  const std::string & key,
  uint32_t quality,
  const KnowledgeReferenceSettings & settings)
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    std::stringstream buffer;
    buffer << name_;
    buffer << delimiter_;
    buffer << key;

    context_->set_quality (buffer.str (), quality, true, settings);
  }
}

bool
madara::knowledge::containers::Map::is_true (void) const
{
  bool result (false);

  madara_logger_log (context_->get_logger (), logger::LOG_MAJOR,
    "Map::is_true: checking for truth in all elements\n");

  if (context_ && name_ != "")
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    result = true;

    for (InternalMap::const_iterator index = map_.begin ();
      index != map_.end (); ++index)
    {
      madara_logger_log (context_->get_logger (), logger::LOG_DETAILED,
        "Map::is_true: checking index, is_false of %d. \n",
        (int)context_->get (index->second).is_false ());

      if (context_->get (index->second).is_false ())
      {
        madara_logger_log (context_->get_logger (), logger::LOG_MAJOR,
          "Map::is_true: result is false, breaking\n");

        result = false;
        break;
      }
    }

    if (map_.size () == 0)
      result = false;
  }

  madara_logger_log (context_->get_logger (), logger::LOG_MAJOR,
    "Map::is_true: final result is %d\n", (int)result);

  return result;
}

bool
madara::knowledge::containers::Map::is_false (void) const
{
  return !is_true ();
}


bool
madara::knowledge::containers::Map::is_true_ (void) const
{
  return is_true ();
}

bool
madara::knowledge::containers::Map::is_false_ (void) const
{
  return is_false ();
}