ros_field.cpp

Go to the documentation of this file.

/***** MIT License ****
*
*   Copyright (c) 2016-2022 Davide Faconti
*
*   Permission is hereby granted, free of charge, to any person obtaining a copy
*   of this software and associated documentation files (the "Software"), to deal
*   in the Software without restriction, including without limitation the rights
*   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*   copies of the Software, and to permit persons to whom the Software is
*   furnished to do so, subject to the following conditions:
*
*   The above copyright notice and this permission notice shall be included in all
*   copies or substantial portions of the Software.
*
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*   SOFTWARE.
*/

#include <algorithm>
#include <regex>
#include "rosx_introspection/ros_field.hpp"
#include "rosx_introspection/ros_message.hpp"

namespace RosMsgParser{


ROSField::ROSField(const ROSType &type, const std::string &name):
  _fieldname(name), _type(type), _is_array(false), _array_size(1)
{

}

ROSField::ROSField(const std::string &definition):
  _is_array(false), _array_size(1)
{
  static const  std::regex type_regex("[a-zA-Z][a-zA-Z0-9_]*"
                                       "(/[a-zA-Z][a-zA-Z0-9_]*){0,1}"
                                       "(\\[[0-9]*\\]){0,1}");

  static const  std::regex field_regex("[a-zA-Z][a-zA-Z0-9_]*");

  static const std::regex array_regex("(.+)(\\[([0-9]*)\\])");

  using std::regex;
  std::string::const_iterator begin = definition.begin();
  std::string::const_iterator end   = definition.end();
  std::match_results<std::string::const_iterator> what;

  // Get type and field
  std::string type, value;

  //-------------------------------
  // Find type, field and array size
  if( std::regex_search(begin, end, what, type_regex))
  {
    type = what[0];
    begin = what[0].second;
  }
  else {
    throw std::runtime_error("Bad type when parsing field: " + definition);
  }

  if (regex_search(begin, end, what, field_regex))
  {
    _fieldname = what[0];
    begin = what[0].second;
  }
  else {
    throw std::runtime_error("Bad field when parsing field: " + definition);
  }

  std::string temp_type = type;
  if (regex_search(temp_type, what, array_regex))
  {
    type = what[1];

    if (what.size() == 3) {
      _array_size = -1;
      _is_array = true;
    }
    else if (what.size() == 4) {
      std::string size(what[3].first, what[3].second);
      _array_size = size.empty() ? -1 : atoi(size.c_str());
      _is_array = true;
    }
    else {
      throw std::runtime_error("Bad array size when parsing field:  " + definition);
    }
  }

  //-------------------------------
  // Find if Constant or comment

  // Determine next character
  // if '=' -> constant, if '#' -> done, if nothing -> done, otherwise error
  if (regex_search(begin, end, what, std::regex("\\S")))
  {
    if (what[0] == "=")
    {
      begin = what[0].second;
      // Copy constant
      if (type == "string") {
        value.assign(begin, end);
      }
      else
      {
        if (regex_search(begin, end, what, std::regex("\\s*#")))
        {
          value.assign(begin, what[0].first);
        }
        else {
          value.assign(begin, end);
        }
      }

      TrimString(value);
      _is_constant = true;
    }
    else if (what[0] == "#")
    {
      // Ignore comment
    }
    else // default value, not constant ?
    {
      if (regex_search(begin, end, what, std::regex("\\s*#")))
      {
        value.assign(begin, what[0].first);
      }
      else {
        value.assign(begin, end);
      }
    }
  }
  _type  = ROSType( type );
  // TODO: Raise error if string is not numeric ?
  _value = value;
}

std::shared_ptr<ROSMessage> ROSField::getMessagePtr(const RosMessageLibrary &library) const
{
  if( _type.typeID() != BuiltinType::OTHER )
  {
    return {};
  }
  if( &library == _cache_library && _cache_message )
  {
    return _cache_message;
  }
  auto it = library.find(_type.baseName());
  if( it == library.end() )
  {
    return nullptr;
  }
  _cache_library = &library;
  _cache_message = it->second;
  return _cache_message;
}

void TrimStringLeft(std::string &s)
{
  s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
    return !std::isspace(ch);
  }));
}

void TrimStringRight(std::string &s)
{
  s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
    return !std::isspace(ch);
  }).base(), s.end());
}

void TrimString(std::string &s)
{
  TrimStringLeft(s);
  TrimStringRight(s);
}

}