FlexMap.cpp

Go to the documentation of this file.

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

#include <algorithm>

madara::knowledge::containers::FlexMap::FlexMap (
  const KnowledgeUpdateSettings & settings,
  const std::string & delimiter)
  : BaseContainer ("", settings), context_ (0), delimiter_ (delimiter)
{
}
  

madara::knowledge::containers::FlexMap::FlexMap (
  const std::string & name,
  KnowledgeBase & knowledge,
  const KnowledgeUpdateSettings & settings,
  const std::string & delimiter)
  : BaseContainer (name, settings), context_ (&(knowledge.get_context ())),
  delimiter_ (delimiter)
{
}
 
madara::knowledge::containers::FlexMap::FlexMap (
  const std::string & name,
  Variables & knowledge,
  const KnowledgeUpdateSettings & settings,
  const std::string & delimiter)
  : BaseContainer (name, settings), context_ (knowledge.get_context ()),
  delimiter_ (delimiter)
{
}
       

madara::knowledge::containers::FlexMap::FlexMap (const FlexMap & rhs)
  : BaseContainer (rhs), context_ (rhs.context_),
  variable_ (rhs.variable_),
  delimiter_ (rhs.delimiter_)
{

}

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

}

bool madara::knowledge::containers::FlexMap::is_true (void) const
{
  ContextGuard context_guard (*context_);
  bool result (false);

  KnowledgeUpdateSettings keep_local (true);

  madara_logger_log (context_->get_logger (), logger::LOG_MAJOR,
    "Vector::is_true: checking for non-zero value\n");

  if (!variable_.is_valid ())
  {
    result = context_->get (variable_, keep_local).is_true ();
  }

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

  return result;
}

bool madara::knowledge::containers::FlexMap::is_false (void) const
{
  ContextGuard context_guard (*context_);
  bool result (true);

  KnowledgeUpdateSettings keep_local (true);

  if (!variable_.is_valid ())
  {
    result = context_->get (variable_, keep_local).is_true ();
  }

  return result;
}

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

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    Map map (name_, knowledge, settings_, delimiter_);

    // modify the children
    map.modify ();

    // modify ourself
    if (variable_.is_valid ())
    {
      knowledge.mark_modified (variable_);
    }
  }
}

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

  result << "Flex Map: ";

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

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    Map map (name_, knowledge, settings_, delimiter_);

    result << map.get_debug_info ();
  }

  return result.str ();
}


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

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

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

void
madara::knowledge::containers::FlexMap::operator= (
  const FlexMap & 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->variable_ = rhs.variable_;
  }
}


void
madara::knowledge::containers::FlexMap::operator= (
  knowledge::KnowledgeRecord::Integer value)
{
  set (value, settings_);
}

void
madara::knowledge::containers::FlexMap::operator= (
int value)
{
  set (KnowledgeRecord::Integer (value), settings_);
}

void
madara::knowledge::containers::FlexMap::operator= (
  double value)
{
  set (value, settings_);
}

void
madara::knowledge::containers::FlexMap::operator= (
  const std::string value)
{
  set (value, settings_);
}

void
madara::knowledge::containers::FlexMap::operator= (
  const std::vector <KnowledgeRecord::Integer> & value)
{
  set (value, settings_);
}

void
madara::knowledge::containers::FlexMap::operator= (
const std::vector <double> & value)
{
  set (value, settings_);
}


madara::knowledge::KnowledgeRecord
madara::knowledge::containers::FlexMap::to_record (
  const KnowledgeRecord & default_value) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    if (!variable_.is_valid ())
    {
      this->update_variable ();
    }

    if (context_->exists (variable_))
    {
      return context_->get (variable_, settings_);
    }
  }

  return default_value;
}

madara::knowledge::KnowledgeRecord::Integer
madara::knowledge::containers::FlexMap::to_integer (
  KnowledgeRecord::Integer default_value) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    if (!variable_.is_valid ())
    {
      this->update_variable ();
    }

    if (context_->exists (variable_))
    {
      return context_->get (variable_, settings_).to_integer ();
    }
  }

  return default_value;
}

double
madara::knowledge::containers::FlexMap::to_double (double default_value) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    if (!variable_.is_valid ())
    {
      this->update_variable ();
    }

    if (context_->exists (variable_))
    {
      return context_->get (variable_, settings_).to_double ();
    }
  }

  return default_value;
}

std::string
madara::knowledge::containers::FlexMap::to_string (
  const std::string & default_value) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    if (!variable_.is_valid ())
    {
      this->update_variable ();
    }

    if (context_->exists (variable_))
    {
      return context_->get (variable_, settings_).to_string ();
    }
  }

  return default_value;
}


void
madara::knowledge::containers::FlexMap::to_container (
  BufferVector & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_delimiter (delimiter_);
    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  DoubleVector & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_delimiter (delimiter_);
    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  IntegerVector & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_delimiter (delimiter_);
    target.set_name (name_, knowledge);
  }
}

void
madara::knowledge::containers::FlexMap::to_container (
  NativeIntegerVector & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  StringVector & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_delimiter (delimiter_);
    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  Double & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_name (name_, knowledge);
  }
}

void
madara::knowledge::containers::FlexMap::to_container (
  NativeDoubleVector & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  Integer & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  String & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_name (name_, knowledge);
  }
}


void
madara::knowledge::containers::FlexMap::to_container (
  Map & target) const
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    target.set_delimiter (delimiter_);
    target.set_name (name_, knowledge);
  }
}


madara::knowledge::containers::FlexMap
madara::knowledge::containers::FlexMap::operator[] (
  const std::string & key)
{
  FlexMap map (settings_, delimiter_);

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

    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    map.set_name (name_ + delimiter_ + key, knowledge);
  }

  return map;
}

madara::knowledge::containers::FlexMap
madara::knowledge::containers::FlexMap::operator[] (
  size_t index)
{
  FlexMap map (settings_, delimiter_);

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

    std::stringstream buffer;
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);

    buffer << name_ << delimiter_ << index;

    map.set_name (buffer.str (), knowledge);
  }

  return map;
}

size_t
madara::knowledge::containers::FlexMap::size (
  bool first_level_keys_only) const
{
  ContextGuard context_guard (*context_);
  MADARA_GUARD_TYPE guard (mutex_);

  size_t result (0);

  if (!first_level_keys_only)
  {
    // get all children
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    Map map (name_, knowledge, settings_, delimiter_);

    result = map.size ();
  }
  else
  {
    // use the context's specialized mapping feature
    std::vector<std::string> next_keys;
    std::map<std::string, madara::knowledge::KnowledgeRecord> all_record_vars;
    context_->to_map (name_, delimiter_, "",
      next_keys, all_record_vars, true);

    result = next_keys.size ();
  }

  return result;
}

void
madara::knowledge::containers::FlexMap::exchange (
  FlexMap & 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);


    // use the Map container, which already has exchange implemented
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    Map this_map (name_, knowledge, settings_, delimiter_);
    Map other_map (other.name_, knowledge, other.settings_, delimiter_);

    this_map.exchange (other_map, refresh_keys, delete_keys);
  }
}

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

    // use the Map container, which already has clear implemented
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    Map map (name_, knowledge, settings_, delimiter_);

    map.clear ();

    context_->delete_variable (name_, settings_);
  }
}

void
madara::knowledge::containers::FlexMap::erase (
  const std::string & key, bool delete_subkeys)
{
  if (context_)
  {
    ContextGuard context_guard (*context_);
    MADARA_GUARD_TYPE guard (mutex_);

    context_->delete_variable (name_ + delimiter_ + key, settings_);
    
    if (delete_subkeys)
    {
      // use the Map container, which already has clear implemented
      KnowledgeBase knowledge;
      knowledge.facade_for (*context_);
      Map map (name_ + delimiter_ + key, knowledge, settings_, delimiter_);

      map.clear ();
    }
  }
}

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

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

    name_ = var_name;

    if (context_->exists (var_name, settings_))
    {
      KnowledgeUpdateSettings keep_local (true);

      variable_ = context_->get_ref (var_name, keep_local);
    }
    else
    {
      // reset variable reference
      variable_ = VariableReference ();
    }
  }
}

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

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

    name_ = var_name;

    if (context_->exists (var_name, settings_))
    {
      update_variable ();
    }
    else
    {
      // reset variable reference
      variable_ = VariableReference ();
    }
  }
}

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

    KnowledgeUpdateSettings keep_local (true);

    variable_ = context_->get_ref (name_, keep_local);
  }
}

void
madara::knowledge::containers::FlexMap::set_delimiter (
const std::string & delimiter)
{
  delimiter_ = delimiter;
}


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

bool
madara::knowledge::containers::FlexMap::exists (void) const
{
  ContextGuard context_guard (*context_);
  bool result (true);

  KnowledgeUpdateSettings keep_local (true);

  if (!variable_.is_valid ())
  {
    result = context_->exists (variable_, keep_local);
  }

  return result;
}

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

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

    // check if the key exists
    std::string exact_key = name_ + delimiter_ + key;
    result = context_->exists (exact_key);

    if (!result && first_level_key)
    {
      std::vector <std::string> curkeys;
      keys (curkeys);

      std::vector <std::string>::iterator found;

      // look for the key in the sub keys
      found = std::find (curkeys.begin (), curkeys.end (), key);

      result = found != curkeys.end ();
    }
  }

  return result;
}

void
madara::knowledge::containers::FlexMap::keys (
  std::vector <std::string> & curkeys,
  bool first_level_keys_only) const
{
  ContextGuard context_guard (*context_);
  MADARA_GUARD_TYPE guard (mutex_);

  if (!first_level_keys_only)
  {
    // use the Map container, which already has clear implemented
    KnowledgeBase knowledge;
    knowledge.facade_for (*context_);
    Map map (name_, knowledge, settings_, delimiter_);

    map.keys (curkeys);
  }
  else
  {
    // use the context's specialized mapping feature
    std::vector<std::string> next_keys;
    std::map<std::string, madara::knowledge::KnowledgeRecord> all_record_vars;
    context_->to_map (name_, delimiter_, "",
      curkeys, all_record_vars, true);
  }
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->read_file (variable_, filename, settings_);
  }
  return result;
}
 
int
madara::knowledge::containers::FlexMap::read_file (
  
  const std::string & filename, 
  const KnowledgeUpdateSettings & settings)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->read_file (variable_, filename, settings);
  }
  return result;
}
      
int madara::knowledge::containers::FlexMap::set (
  madara::knowledge::KnowledgeRecord::Integer value)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings);
  }

  return result;
}

int madara::knowledge::containers::FlexMap::set_index (
  
  size_t index,
  madara::knowledge::KnowledgeRecord::Integer value)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_index (variable_, index, value, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_index (variable_, index, value, settings);
  }

  return result;
}


int madara::knowledge::containers::FlexMap::set (
  const madara::knowledge::KnowledgeRecord::Integer * value,
  uint32_t size)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, size, settings_);
  }

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, size, settings);
  }

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings);
  }

  return result;
}
          
int madara::knowledge::containers::FlexMap::set (
  double value)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings_);
  }

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings);
  }

  return result;
}

int madara::knowledge::containers::FlexMap::set_index (
  size_t index,
  double value)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_index (variable_, index, value, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_index (variable_, index, value, settings);
  }

  return result;
}

int madara::knowledge::containers::FlexMap::set (
  const double * value,
  uint32_t size)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, size, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, size, settings);
  }

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings_);
  }

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set (variable_, value, settings);
  }

  return result;
}

int madara::knowledge::containers::FlexMap::set_file (
  const unsigned char * value, size_t size)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_file (variable_, value, size, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_file (variable_, value, size, settings);
  }

  return result;
}

int madara::knowledge::containers::FlexMap::set_jpeg (
  const unsigned char * value, size_t size)
{
  int result = -1;

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_jpeg (variable_, value, size, settings_);
  }

  return result;
}

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

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    result = context_->set_jpeg (variable_, value, size, settings);
  }

  return result;
}

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

    if (!variable_.is_valid ())
    {
      update_variable ();
    }

    context_->set_quality (name_, quality, true, settings);
  }
}

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

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