source: finroc_plugins_parameters/tConfigFile.cpp @ 87:495d52531f18

//
// You received this file as part of Finroc
// A framework for intelligent robot control
//
// Copyright (C) Finroc GbR (finroc.org)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//----------------------------------------------------------------------
/*!\file    plugins/parameters/tConfigFile.cpp
 *
 * \author  Max Reichardt
 *
 * \date    2012-11-28
 *
 */
//----------------------------------------------------------------------
#include "plugins/parameters/tConfigFile.h"

//----------------------------------------------------------------------
// External includes (system with <>, local with "")
//----------------------------------------------------------------------
#include "rrlib/rtti/rtti.h"
#include "core/file_lookup.h"

//----------------------------------------------------------------------
// Internal includes with ""
//----------------------------------------------------------------------
#include "plugins/parameters/internal/tParameterInfo.h"

//----------------------------------------------------------------------
// Debugging
//----------------------------------------------------------------------
#include <cassert>

//----------------------------------------------------------------------
// Namespace usage
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Namespace declaration
//----------------------------------------------------------------------
namespace finroc
{
namespace parameters
{

//----------------------------------------------------------------------
// Forward declarations / typedefs / enums
//----------------------------------------------------------------------
#ifdef _LIB_RRLIB_XML_PRESENT_
typedef rrlib::xml::tNode tXMLNode;

//----------------------------------------------------------------------
// Const values
//----------------------------------------------------------------------
/*! Separator entries are divided with */
static const std::string cSEPARATOR("/");

/*! Branch name in XML */
static const std::string cXML_BRANCH_NAME("node");

/*! Leaf name in XML */
static const std::string cXML_LEAF_NAME("value");

/*! Override attribute name in config files */
static const std::string cXML_OVERRIDE_ATTRIBUTE_NAME("override");

#endif

/*! Initializes annotation type so that it can be transferred to finstruct */
__attribute__((unused))
static rrlib::rtti::tDataType<tConfigFile> cTYPE;

//----------------------------------------------------------------------
// Implementation
//----------------------------------------------------------------------

namespace
{

#ifdef _LIB_RRLIB_XML_PRESENT_

rrlib::xml::tDocument LoadConfigFile(const std::string& file);

bool ProcessIncludes(rrlib::xml::tNode& node, const std::string& source_file)
{
  if (node.Name() == "include")
  {
    if (!node.HasAttribute("file"))
    {
      FINROC_LOG_PRINT_STATIC(DEBUG_WARNING, "Found 'include' node without 'file' attribute in '", source_file, "'");
    }
    else
    {
      std::string file_name = node.GetStringAttribute("file");
      try
      {
        rrlib::xml::tDocument insert = LoadConfigFile(file_name);
        auto& parent = node.Parent();
        rrlib::xml::tNode* insert_after = &node;
        for (auto it = insert.RootNode().ChildrenBegin(); it != insert.RootNode().ChildrenEnd(); ++it)
        {
          insert_after = &insert_after->AddNextSibling(*it, true); // not using copy resulted in erroneous behavior
        }
        parent.RemoveChildNode(node);
        return true;
      }
      catch (const std::exception& e)
      {
        FINROC_LOG_PRINT(ERROR, "Error including '", file_name, "' in config file: ", e);
      }
    }
  }

  long int index = 0;
  for (auto it = node.ChildrenBegin(); it != node.ChildrenEnd();)
  {
    long int number_of_children = node.GetNumberOfChildren();
    if (ProcessIncludes(*it, source_file))
    {
      // Iterator could be invalid -> reinitialize
      long int size_difference = node.GetNumberOfChildren() - number_of_children;
      assert(size_difference >= -1);
      index += (size_difference + 1);
      it = node.ChildrenBegin();
      for (auto i = 0; i < index; i++)
      {
        ++it;
      }
    }
    else
    {
      ++index;
      ++it;
    }
  }
  return false;
}

void ProcessIncludes(rrlib::xml::tDocument& document, const std::string& source_file)
{
  ProcessIncludes(document.RootNode(), source_file);
}

rrlib::xml::tDocument LoadConfigFile(const std::string& filename)
{
  rrlib::xml::tDocument result = core::GetFinrocXMLDocument(filename, false); // false = do not validate with dtd
  ProcessIncludes(result, filename);
  //FINROC_LOG_PRINT(DEBUG, result.RootNode().GetXMLDump(true));
  return result;
}

bool OverrideContext(rrlib::xml::tNode& node, bool in_override_context)
{
  if (node.HasAttribute(cXML_OVERRIDE_ATTRIBUTE_NAME))
  {
    return node.GetBoolAttribute(cXML_OVERRIDE_ATTRIBUTE_NAME);
  }
  return in_override_context;
}

/*! Result of GetEntryImplementation function */
struct GetEntryImplementationResult
{
  struct tEntry
  {
    rrlib::xml::tNode* node;
    bool overrides;
  };
  tEntry first_entry, last_override_entry;
  size_t entry_count = 0, override_entry_count = 0;
};

/*!
 * Implementation of GetEntry() - called recursively
 *
 * \param result Object that will contain the result(s) as additional entry/entries after the call
 * \param entry Entry
 * \param node Current node
 * \param entry_string_index Current index in entry string
 * \param override_context Whether override="true" has been set in any parent now
 */
void GetEntryImplementation(GetEntryImplementationResult& result, const std::string& entry, rrlib::xml::tNode& node, size_t entry_string_index, bool override_context = false)
{
  if (entry_string_index >= entry.length())
  {
    return;
  }

  // Check for slash at beginning
  if (entry[entry_string_index] == '/')
  {
    if (entry_string_index > 0)
    {
      FINROC_LOG_PRINT_STATIC(WARNING, "Entry '", entry, "' seems to be not clean (sequential slashes). Skipping one slash now, as this is typically intended. Please fix this!");
    }
    entry_string_index++;
  }

  // Search child nodes
  for (rrlib::xml::tNode::iterator child = node.ChildrenBegin(); child != node.ChildrenEnd(); ++child)
  {
    if (child->Name() == cXML_BRANCH_NAME || child->Name() == cXML_LEAF_NAME)
    {
      std::string name_attribute;
      try
      {
        name_attribute = child->GetStringAttribute("name");
      }
      catch (const std::exception& e)
      {
        FINROC_LOG_PRINT_STATIC(WARNING, "Encountered tree node without name");
      }

      try
      {
        if (entry.compare(entry_string_index, name_attribute.length(), name_attribute) == 0) // starts_with name attribute?
        {
          size_t new_entry_string_index = entry_string_index + name_attribute.length();
          if (new_entry_string_index != entry.length())
          {
            if (entry[new_entry_string_index] == '/')
            {
              new_entry_string_index++;
              GetEntryImplementation(result, entry, *child, new_entry_string_index, OverrideContext(*child, override_context));
            }
          }
          else
          {
            // Entry found - include in result
            GetEntryImplementationResult::tEntry new_entry = { &(*child), OverrideContext(*child, override_context) };
            if (!result.entry_count)
            {
              result.first_entry = new_entry;
              if (new_entry.overrides)
              {
                FINROC_LOG_PRINT_STATIC(WARNING, "First config entry with path '", entry, "' marked 'override', but does not override.");
              }
            }
            if (new_entry.overrides)
            {
              result.last_override_entry = new_entry;
            }
            result.entry_count++;
            result.override_entry_count += (new_entry.overrides ? 1 : 0);
          }
        }
      }
      catch (const std::exception& e)
      {
        FINROC_LOG_PRINT_STATIC(ERROR, "Error looking for config entry with path '", entry, "'. Reason: ", e.what());
      }
    }
  }
}

rrlib::xml::tNode* ChooseNodeFromResult(GetEntryImplementationResult& result, const std::string& path)
{
  if (result.entry_count > 1)
  {
    assert(result.entry_count >= result.override_entry_count);
    if (!result.override_entry_count)
    {
      FINROC_LOG_PRINT_STATIC(WARNING, "There are ", result.entry_count, " entries in config file with the path '", path, "'. Using the first one. Hint: Add attribute 'override=\"true\"' to nodes and values if the later entries are intended be used. This will also remove any warning messages.");
    }
    else if (result.entry_count - result.override_entry_count > 1)
    {
      FINROC_LOG_PRINT_STATIC(WARNING, "There are ", result.entry_count, " entries in config file with the path '", path, "'. Only ", result.override_entry_count, " are marked 'override'. Using the last one marked 'override'.");
    }
    return result.override_entry_count ? result.last_override_entry.node : result.first_entry.node;
  }
  return result.entry_count ? result.first_entry.node : nullptr;
}

#endif

}

tConfigFile::tConfigFile() :
#ifdef _LIB_RRLIB_XML_PRESENT_
  wrapped(),
#endif
  filename(),
  active(true)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  wrapped.AddRootNode(cXML_BRANCH_NAME);
#endif
}

tConfigFile::tConfigFile(const std::string& filename, bool optional) :
#ifdef _LIB_RRLIB_XML_PRESENT_
  wrapped(),
#endif
  filename(filename),
  active(true)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  if (core::FinrocFileExists(filename))
  {
    try
    {
      wrapped = LoadConfigFile(filename);
      return;
    }
    catch (const std::exception& e)
    {
      FINROC_LOG_PRINT(ERROR, e);
    }
  }
  else if (!optional)
  {
    FINROC_LOG_PRINT(WARNING, "Specified config file not found: ", filename);
  }
  wrapped = rrlib::xml::tDocument();
  wrapped.AddRootNode(cXML_BRANCH_NAME);
#endif
}

void tConfigFile::Append(const std::string& filename)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  if (core::FinrocFileExists(filename))
  {
    // merge entries into first document
    auto document = LoadConfigFile(filename);
    auto& root_node = document.RootNode();
    for (auto it = root_node.ChildrenBegin(); it != root_node.ChildrenEnd(); ++it)
    {
      this->wrapped.RootNode().AddChildNode(*it, true); // not using copy resulted in erroneous behavior
    }
  }
  else
  {
    throw std::runtime_error("Specified config file not found: " + filename);
  }
#endif
}

#ifdef _LIB_RRLIB_XML_PRESENT_
rrlib::xml::tNode& tConfigFile::CreateEntry(const std::string& entry, bool leaf)
{
  if (!leaf)
  {
    GetEntryImplementationResult result;
    GetEntryImplementation(result, entry, wrapped.RootNode(), 0);
    rrlib::xml::tNode* result_node = ChooseNodeFromResult(result, entry);
    if (result_node)
    {
      // do we want to warn if node is a leaf node? - I currently do not think so
      return *result_node;
    }
  }

  size_t slash_index = entry.rfind('/');
  tXMLNode& parent = (slash_index == std::string::npos || slash_index == 0) ? wrapped.RootNode() : CreateEntry(entry.substr(0, slash_index), false);
  tXMLNode& created = parent.AddChildNode(leaf ? cXML_LEAF_NAME : cXML_BRANCH_NAME);
  created.SetAttribute("name", (slash_index == std::string::npos) ? entry : entry.substr(slash_index + 1));
  return created;
}
#endif

tConfigFile* tConfigFile::Find(const core::tFrameworkElement& element)
{
  tConfigFile* config_file = element.GetAnnotation<tConfigFile>();
  if (config_file && config_file->active == true)
  {
    return config_file;
  }
  core::tFrameworkElement* parent = element.GetParent();
  if (parent)
  {
    return Find(*parent);
  }
  return NULL;
}

#ifdef _LIB_RRLIB_XML_PRESENT_
rrlib::xml::tNode& tConfigFile::GetEntry(const std::string& entry, bool create)
{
  GetEntryImplementationResult result;
  GetEntryImplementation(result, entry, wrapped.RootNode(), 0);
  rrlib::xml::tNode* result_node = ChooseNodeFromResult(result, entry);

  if (!create)
  {
    if (!result_node)
    {
      throw std::runtime_error("Config node not found: " + entry);
    }
    if (result_node->Name() != cXML_LEAF_NAME)
    {
      throw std::runtime_error("Config node is no leaf: " + entry);
    }
    return *result_node;
  }

  // create node...
  if (result.entry_count > 0)
  {
    // recreate existing node
    std::string name = result_node->GetStringAttribute("name");
    tXMLNode& parent = result_node->Parent();
    tXMLNode& new_node = result_node->AddNextSibling(cXML_LEAF_NAME);
    new_node.SetAttribute("name", name);
    parent.RemoveChildNode(*result_node);
    return new_node;
  }
  else
  {
    return CreateEntry(entry, true);
  }
}

std::vector<std::string> tConfigFile::GetChildrenNames(const std::string &entry)
{
  GetEntryImplementationResult result;
  GetEntryImplementation(result, entry, wrapped.RootNode(), 0);
  rrlib::xml::tNode* result_node = ChooseNodeFromResult(result, entry);

  if (!result_node)
  {
    throw std::runtime_error("Config node not found: " + entry);
  }
  if (result_node->Name() == cXML_LEAF_NAME)
  {
    throw std::runtime_error("Config node is a leaf: " + entry);
  }

  std::vector<std::string> children_names;
  for (auto it = result_node->ChildrenBegin(); it != result_node->ChildrenEnd(); ++it)
  {
    children_names.push_back(it->GetStringAttribute("name"));
  }
  return children_names;
}

#endif

std::string tConfigFile::GetStringEntry(const std::string& entry)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  try
  {
    return GetEntry(entry).GetTextContent();
  }
  catch (const std::exception& e)
  {
    return "";
  }
#else
  return "";
#endif
}

bool tConfigFile::HasEntry(const std::string& entry)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  // TODO: could be implemented more efficiently
  try
  {
    GetEntry(entry);
    return true;
  }
  catch (const std::exception& e)
  {
    return false;
  }
#else
  return false;
#endif
}

void tConfigFile::LoadParameterValues()
{
  LoadParameterValues(*GetAnnotated<core::tFrameworkElement>());
}

void tConfigFile::LoadParameterValues(core::tFrameworkElement& fe)
{
  rrlib::thread::tLock lock(fe.GetStructureMutex());  // nothing should change while we're doing this
  for (auto it = fe.SubElementsBegin(true); it != fe.SubElementsEnd(); ++it)
  {
    if (it->IsPort() && it->IsReady() && Find(*it) == this)    // Does element belong to this configuration file?
    {
      internal::tParameterInfo* pi = it->GetAnnotation<internal::tParameterInfo>();
      if (pi)
      {
        try
        {
          pi->LoadValue();
        }
        catch (const std::exception& e)
        {
          FINROC_LOG_PRINT_STATIC(ERROR, e);
        }
      }
    }
  }
}

void tConfigFile::Reload()
{
  if (core::FinrocFileExists(filename))
  {
    try
    {
      wrapped = LoadConfigFile(filename);
      return;
    }
    catch (const std::exception& e)
    {
      FINROC_LOG_PRINT(ERROR, e);
    }
  }
}

void tConfigFile::SaveFile(const std::string& new_filename)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  // first: update tree
  core::tFrameworkElement* ann = GetAnnotated<core::tFrameworkElement>();
  if (ann)
  {
    rrlib::thread::tLock lock(ann->GetStructureMutex()); // nothing should change while we're doing this
    for (auto it = ann->SubElementsBegin(true); it != ann->SubElementsEnd(); ++it)
    {
      if (it->IsPort() && it->IsReady() && Find(*it) == this)    // Does element belong to this configuration file?
      {
        internal::tParameterInfo* pi = it->GetAnnotation<internal::tParameterInfo>();
        if (pi)
        {
          try
          {
            pi->SaveValue();
          }
          catch (const std::exception& e)
          {
            FINROC_LOG_PRINT_STATIC(ERROR, e);
          }
        }
      }
    }
  }

  try
  {
    if (new_filename.length() > 0)
    {
      this->filename = new_filename;
    }
    std::string save_to = core::GetFinrocFileToSaveTo(this->filename);
    if (save_to.length() == 0)
    {
      std::string save_to_alt = save_to;
      std::replace(save_to_alt.begin(), save_to_alt.end(), '/', '_'); // Replace '/' characters with '_'
      save_to_alt = core::GetFinrocFileToSaveTo(save_to_alt);
      FINROC_LOG_PRINT(ERROR, "There does not seem to be any suitable location for: '", this->filename, "' . For now, using '", save_to_alt, "'.");
      save_to = save_to_alt;
    }

    // write new tree to file
    wrapped.WriteToFile(save_to);
  }
  catch (const std::exception& e)
  {
    FINROC_LOG_PRINT(ERROR, e);
  }
#endif
}

rrlib::serialization::tOutputStream& operator << (rrlib::serialization::tOutputStream& stream, const tConfigFile& config_file)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  stream.WriteBoolean(config_file.IsActive());
  stream.WriteString(config_file.GetFilename());

  try
  {
    stream.WriteString(config_file.wrapped.RootNode().GetXMLDump());
  }
  catch (const std::exception& e)
  {
    FINROC_LOG_PRINT_STATIC(ERROR, e); // Should never occur
  }
#endif
  return stream;
}

rrlib::serialization::tInputStream& operator >> (rrlib::serialization::tInputStream& stream, tConfigFile& config_file)
{
#ifdef _LIB_RRLIB_XML_PRESENT_
  config_file.active = stream.ReadBoolean();
  std::string file = stream.ReadString();
  std::string content = stream.ReadString();

  if (config_file.active && file.length() > 0 && content.length() == 0 && (file != config_file.filename))
  {
    // load file
    if (core::FinrocFileExists(file))
    {
      try
      {
        config_file.wrapped = LoadConfigFile(file);
      }
      catch (const std::exception& e)
      {
        FINROC_LOG_PRINT_STATIC(ERROR, e);
        config_file.wrapped = rrlib::xml::tDocument();
        try
        {
          config_file.wrapped.AddRootNode(cXML_BRANCH_NAME);
        }
        catch (const std::exception& e1)
        {
          FINROC_LOG_PRINT_STATIC(ERROR, e1);
        }
      }
    }
    config_file.filename = file;
  }
  else if (config_file.active && content.length() > 0)
  {
    if (file.length() > 0)
    {
      config_file.filename = file;
    }

    try
    {
      config_file.wrapped = rrlib::xml::tDocument(content.c_str(), content.length() + 1);
    }
    catch (const std::exception& e)
    {
      FINROC_LOG_PRINT_STATIC(ERROR, e);
    }
  }
#endif
  return stream;
}

//----------------------------------------------------------------------
// End of namespace declaration
//----------------------------------------------------------------------
}
}