parser.hpp

Go to the documentation of this file.

/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright 2016 Davide Faconti
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * Redistributions in binary form must reproduce the above
*     copyright notice, this list of conditions and the following
*     disclaimer in the documentation and/or other materials provided
*     with the distribution.
*   * Neither the name of Willow Garage, Inc. nor the names of its
*     contributors may be used to endorse or promote products derived
*     from this software without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
********************************************************************/

#ifndef ROSTypePARSER_H
#define ROSTypePARSER_H

#include <vector>
#include <map>
#include <boost/function.hpp>
#include <boost/utility/string_ref.hpp>
#include "ros_type_introspection/stringtree.hpp"
#include "ros_type_introspection/variant.hpp"

namespace RosIntrospection{


#if 1
// Faster, but might need more testing
typedef ssoX::basic_string<char> SString;
#else
// slightly slower but safer option. More convenient during debug
typedef std::string SString;
#endif

typedef details::TreeElement<SString> StringTreeNode;
typedef details::Tree<SString> StringTree;

class ROSType {
public:

  ROSType(){}

  ROSType(const std::string& name);

  const SString& baseName() const;

  const SString& msgName()  const;

  const SString& pkgName()  const;

  void setPkgName(const SString& new_pkg);

  bool isArray() const;

  bool isBuiltin() const;

  int  arraySize() const;

  int typeSize() const;

  BuiltinType typeID() const;

  bool operator==(const ROSType& other) const  {
    return this->baseName() == other.baseName();
  }

  bool operator<(const ROSType& other) const {
    return this->baseName() < other.baseName();
  }

  VarNumber deserializeFromBuffer(uint8_t** buffer) const
  {
      if(!_deserialize_impl){ return VarNumber(); }
      else{
          return _deserialize_impl(buffer);
      }
  }

protected:

  BuiltinType _id;
  int     _array_size;
  SString _base_name;
  SString _msg_name;
  SString _pkg_name;
  boost::function<VarNumber(uint8_t** buffer)> _deserialize_impl;

};

// helper function to deserialize raw memory
template <typename T> inline T ReadFromBuffer( uint8_t** buffer)
{
  T destination =  (*( reinterpret_cast<T*>( *buffer ) ) );
  *buffer +=  sizeof(T);
  return (destination);
}


class ROSField {
public:
  ROSField(const std::string& name, const ROSType& type ):
    _name( name ), _type( type ) {}

  ROSField(const std::string& definition );

  const SString&  name() const { return _name; }

  const ROSType&  type() const { return _type; }

  bool isConstant() const {
    return _value.size() != 0;
  }

  const SString& value() const   { return _value; }

  friend class ROSMessage;

protected:
  SString _name;
  ROSType _type;
  SString _value;
};

class ROSMessage;
typedef std::vector<ROSMessage> ROSTypeList;



class ROSMessage{
public:

  ROSMessage(const std::string& msg_def );

  void updateTypes(const std::vector<ROSType> &all_types);

  const ROSField* field(const SString& name) const;

  const ROSField& field(size_t index) const { return _fields[index]; }

  const std::vector<ROSField>& fields() const { return _fields; }

  const ROSType& type() const { return _type; }

  void mutateType(const ROSType& new_type ) { _type = new_type; }

private:
  ROSType _type;
  std::vector<ROSField> _fields;
};


inline const ROSField* ROSMessage::field(const SString &name) const
{
  for(int i=0; i<_fields.size(); i++ )  {
    if(  name ==_fields[i].name() ) {
      return &_fields[i];
    }
  }
  return nullptr;
}


//------------------------------

ROSTypeList buildROSTypeMapFromDefinition(
    const std::string& type_name,
    const std::string& msg_definition);

std::ostream& operator<<(std::ostream& s, const ROSTypeList& c);


} // end namespace

#endif // ROSTypePARSER_H