smacc2::introspection::TypeInfo Class Reference

#include <smacc_type_info.hpp>

Collaboration diagram for smacc2::introspection::TypeInfo:

Public Types
typedef std::shared_ptr< TypeInfo >	Ptr

Public Member Functions
	TypeInfo (std::string tkey, std::string codedtype, std::string finaltype)
std::string	toString ()
std::string	getNonTemplatedTypeName ()
const std::string &	getFullName ()

Static Public Member Functions
static TypeInfo::Ptr	getTypeInfoFromString (std::string inputtext)
static TypeInfo::Ptr	getFromStdTypeInfo (const std::type_info &tid)
template<typename T >
static TypeInfo::Ptr	getTypeInfoFromType ()

Public Attributes
std::vector< Ptr >	templateParameters

Static Public Attributes
static std::map< std::string, Ptr >	typeInfoDatabase

Private Attributes
std::string	tkey
std::string	codedtype
std::string	finaltype

Detailed Description

Definition at line 32 of file smacc_type_info.hpp.

Member Typedef Documentation

Ptr

typedef std::shared_ptr<TypeInfo> smacc2::introspection::TypeInfo::Ptr

Definition at line 35 of file smacc_type_info.hpp.

Constructor & Destructor Documentation

TypeInfo()

smacc2::introspection::TypeInfo::TypeInfo ( std::string  tkey, std::string  codedtype, std::string  finaltype  )

inline

Definition at line 50 of file smacc_type_info.hpp.

  {
    this->tkey = tkey;
    this->codedtype = codedtype;
    this->finaltype = finaltype;
  }

References codedtype, finaltype, and tkey.

Member Function Documentation

getFromStdTypeInfo()

TypeInfo::Ptr smacc2::introspection::TypeInfo::getFromStdTypeInfo ( const std::type_info &  tid )

static

Definition at line 76 of file string_type_walker.cpp.

{
  return TypeInfo::getTypeInfoFromString(demangleSymbol(tid.name()));
}

References smacc2::introspection::demangleSymbol(), and getTypeInfoFromString().

Referenced by smacc2::introspection::StateReactorHandler::addInputEvent(), smacc2::utils::cleanShortTypeName(), smacc2::ISmaccClient::getType(), and getTypeInfoFromType().

Here is the call graph for this function:

Here is the caller graph for this function:

getFullName()

const std::string & smacc2::introspection::TypeInfo::getFullName ( )

inline

Definition at line 65 of file smacc_type_info.hpp.

{ return this->finaltype; }

References finaltype.

getNonTemplatedTypeName()

std::string smacc2::introspection::TypeInfo::getNonTemplatedTypeName ( )

inline

Definition at line 59 of file smacc_type_info.hpp.

  {
    auto index = this->finaltype.find("<");
    return this->finaltype.substr(0, index);
  }

References finaltype.

getTypeInfoFromString()

TypeInfo::Ptr smacc2::introspection::TypeInfo::getTypeInfoFromString ( std::string  inputtext )

static

Definition at line 81 of file string_type_walker.cpp.

{
  auto it = typeInfoDatabase.find(inputtext);
 
  if (it != typeInfoDatabase.end()) return typeInfoDatabase[inputtext];
 
  bool ok = false;
  int typecount = 0;
  std::string originalinputtext = inputtext;
  std::map<std::string, std::string> typesdict;
  std::map<std::string, std::string> typesdict_content;
 
  // ITERATE on the current string to replace internal template types with ids (ie $Tx) replacements
  // until plain template type
 
  while (!ok)
  {
    //simpletypeRE = r"[^<>,\s]+<[^<>]+>"
    //print ("input: " + inputtext)
 
    const char * simpletypeRE = "[^\\<\\>,\\s]+\\<[^\\<\\>]+\\>";
    //std::cout << inputtext << std::endl;
 
    // locate moste outer template
    std::smatch matches;
    std::regex regex(simpletypeRE);  // matches words beginning by "sub"
 
    std::regex_search(inputtext, matches, regex);
 
    // checking ending condition
    if (matches.size() == 0)
    {
      if (typesdict.size() == 0)
      {
        auto tkey = "$T" + std::to_string(typecount);
        typesdict[tkey] = inputtext;
      }
      break;
    }
    else
    {
      // find and replace all coincidences typestr to tokenid
      int i = 0;
      for (auto & m : matches)
      {
        std::string tstr = m;
        auto tkey = "$T" + std::to_string(typecount);
        replace(inputtext, tstr, tkey);
 
        typecount++;
        typesdict[tkey] = tstr;
 
        i++;
      }
    }
  }
 
  // ---------- SORT by token key to replace back in a single pass --------
  std::vector<std::pair<std::string, std::string>> orderedTypedict;
  for (const auto & item : typesdict)
  {
    orderedTypedict.emplace_back(item);
  }
 
  std::sort(
    orderedTypedict.begin(), orderedTypedict.end(),
    [](auto & a, auto & b) { return std::stoi(a.first.substr(2)) > std::stoi(b.first.substr(2)); });
  // -----------------------------------------------------------------
 
  std::set<std::string> allbasetypes;
  for (auto & typeentry : orderedTypedict /*typesdict*/)
  {
    auto flat = typeentry.second;
 
    size_t startindex = flat.find("<");
    size_t endindex = flat.find(">");
    if (startindex != std::string::npos)
    {
      flat = flat.substr(
        startindex + 1,
        endindex - startindex - 1);  // gets the list of template parameters in csv format
 
      typesdict_content[typeentry.first] = flat;
      std::vector<std::string> localbasetypes;
 
      std::istringstream iss(flat);
      std::string token;
      while (std::getline(iss, token, ','))
      {
        boost::trim(token);
        localbasetypes.push_back(token);
      }
 
      for (auto & b : localbasetypes)
      {
        size_t found = b.find("$");
 
        if (found == std::string::npos)
        {
          allbasetypes.insert(b);
        }
      }
    }
 
    // for b in allbasetypes:
    // typesdict[b] = b
 
    //refresh
    for (auto & b : allbasetypes)
    {
      typesdict[b] = b;
    }
  }
  // types = []
  // for tkey in typesdict:
  //     finaltype = replace_back(typesdict[tkey], typesdict)
  //     t = TypeInfo(tkey, typesdict[tkey], finaltype)
  //     types.append(t)
 
  //     print t
 
  // append leaf types
  for (auto & b : allbasetypes)
  {
    orderedTypedict.push_back({b, b});
  }
 
  //std::cout << "---------- TYPES -------" << std::endl;
  std::vector<TypeInfo::Ptr> types;
  std::vector<std::string> tokens;
 
  for (auto t : orderedTypedict)  // must be ordered. to avoid issue, ie: $11 to be replaced in $T14
  {
    //auto t = *it;
    auto & tkey = t.first;
    auto & tval = t.second;
    auto finaltype = replace_back(tval, orderedTypedict);
    auto tinfo = std::make_shared<TypeInfo>(tkey, tval, finaltype);
    types.push_back(tinfo);
    tokens.push_back(tkey);
 
    //std::cout << "replacing back: " << finaltype << std::endl;
  }
 
  // --------- FINDING THE CURRENT TYPE -------------
  TypeInfo::Ptr roottype = nullptr;
  for (auto & t : types)
  {
    // std::cout << t->finaltype << " vs " <<originalinputtext;
    if (t->finaltype == originalinputtext)
    {
      roottype = t;
      break;
    }
  }
 
  if (roottype == nullptr && globalNh_ != nullptr)
  {
    std::stringstream ss;
    ss << "---------------" << std::endl;
    ss << "TYPE STRING WALKER, type was not properly interpreted: " << std::endl
       << " - " << inputtext.c_str() << std::endl
       << " - " << originalinputtext << std::endl;
 
    auto strmsg = ss.str();
    RCLCPP_WARN_STREAM(globalNh_->get_logger(), strmsg);
  }
 
  // std::sort(types.begin(), types.end(),[](auto& a, auto& b)
  // {
  //     return a->getFullName().size() > b->getFullName().size();
  // });
 
  /*
    std::cout<<"types order:" << std::endl;
    for(auto t: types)
    {
        std::cout<< t->codedtype << std::endl;
    }
    std::cout<<"---------" << std::endl;
 
    std::cout<<"types order:" << std::endl;
    for(auto t: types)
    {
        std::cout<< t->finaltype << std::endl;
    }
    std::cout<<"---------" << std::endl;
    */
 
  // Replacing back tokens in strings to get the whole final name
  for (size_t i = 0; i < types.size(); i++)
  {
    auto t = types[i];
    auto ttoken = tokens[i];
 
    //auto t = types[it1];
    std::vector<std::pair<int, TypeInfo::Ptr>> unorderedTemplateParameters;
 
    //std::cout << "original typestr: " << codedtypecopy << std::endl;
 
    //auto codedtypecopy = t->codedtype;
    auto codedtypecopy = typesdict_content[ttoken];
 
    // std::cout << "original typestr: " << codedtypecopy << std::endl;
    // std::cout << "original token: " << ttoken << std::endl;
    // std::cout << "original typestr: " << typesdict_content[ttoken] << std::endl;
 
    // size_t startindex = codedtypecopy.find("<");
    // size_t endindex = codedtypecopy.find(">");
 
    // if (startindex != std::string::npos)
    // {
    //     codedtypecopy = codedtypecopy.substr(startindex + 1, endindex - startindex - 1);
    // }
    //std::cout << "original typestr: " << codedtypecopy << std::endl;
 
    for (auto & t2 : types)
    //for (auto it2= types.size() -1; it2 >=0; it2--)
    {
      //std::cout << it2 << std::endl;
      //auto t2 = types[it2];
      //std::cout << t2->getFullName() << std::endl;
      if (t == t2) continue;
 
      auto index = codedtypecopy.find(t2->tkey);
      if (index != std::string::npos)
      {
        auto pair = std::make_pair(index, t2);  // this line is important for the order of templates
        //auto pair = std::make_pair(0, t2);
        //std::cout << "matches: " << t2->tkey <<std::endl;
        unorderedTemplateParameters.push_back(pair);
        replace(codedtypecopy, t2->tkey, "");  // consume token
        //std::cout << "codedtypecopy: " << codedtypecopy << std::endl;
      }
    }
 
    std::sort(
      unorderedTemplateParameters.begin(), unorderedTemplateParameters.end(),
      [](auto & a, auto & b) -> bool { return a.first <= b.first; });
 
    //RCLCPP_DEBUG_STREAM(nh_->get_logger(),"------------------");
    //RCLCPP_DEBUG_STREAM(nh_->get_logger(),"CREATING TYPE:" << t->getFullName());
 
    for (auto & item : unorderedTemplateParameters)
    {
      //RCLCPP_DEBUG_STREAM(nh_->get_logger()," - template parameter: " << item.second->getFullName());
      t->templateParameters.push_back(item.second);
    }
    //RCLCPP_DEBUG_STREAM(nh_->get_logger(),"------------------");
  }
 
  //RCLCPP_DEBUG_STREAM(nh_->get_logger(),"ADDING TYPE TO DATABASE: " << inputtext);
  //RCLCPP_DEBUG_STREAM(nh_->get_logger(),"Current Database");
  for (auto & en : typeInfoDatabase)
  {
    if (globalNh_ != nullptr) RCLCPP_DEBUG_STREAM(globalNh_->get_logger(), "- " << en.first);
  }
 
  typeInfoDatabase[originalinputtext] = roottype;
 
  if (roottype == nullptr && globalNh_ != nullptr)
  {
    std::stringstream ss;
    ss << "---------------" << std::endl;
    ss << "TYPE STRING WALKER, type was not properly interpreted: " << std::endl
       << " - " << inputtext.c_str() << std::endl
       << " - " << originalinputtext << std::endl;
 
    ss << "---- current type (ordered types)" << std::endl;
 
    for (auto & en : orderedTypedict)
    {
      ss << "- " << en.first << ": " << en.second << std::endl;
    }
    ss << "---------------" << std::endl;
 
    ss << "------current type types --------" << std::endl;
 
    for (auto & t : types)
    {
      ss << t->finaltype << std::endl;
    }
 
    ss << "----total typeinfo database" << std::endl;
 
    for (auto & en : typeInfoDatabase)
    {
      ss << "- " << en.first << ": " << en.second << std::endl;
    }
 
    auto strmsg = ss.str();
    RCLCPP_WARN_STREAM(globalNh_->get_logger(), strmsg);
  }
 
  return roottype;
}

References finaltype, smacc2::introspection::globalNh_, smacc2::introspection::replace(), smacc2::introspection::replace_back(), tkey, and typeInfoDatabase.

Referenced by getFromStdTypeInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

getTypeInfoFromType()

template<typename T >

static TypeInfo::Ptr smacc2::introspection::TypeInfo::getTypeInfoFromType ( )

inlinestatic

Definition at line 42 of file smacc_type_info.hpp.

  {
    return TypeInfo::getFromStdTypeInfo(typeid(T));
  }

References getFromStdTypeInfo().

Referenced by smacc2::introspection::processTransition().

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

std::string smacc2::introspection::TypeInfo::toString ( )

inline

Definition at line 57 of file smacc_type_info.hpp.

{ return this->tkey + ":" + this->finaltype; }

References finaltype, and tkey.

Member Data Documentation

codedtype

std::string smacc2::introspection::TypeInfo::codedtype

private

Definition at line 71 of file smacc_type_info.hpp.

Referenced by TypeInfo().

finaltype

std::string smacc2::introspection::TypeInfo::finaltype

private

Definition at line 72 of file smacc_type_info.hpp.

Referenced by getFullName(), getNonTemplatedTypeName(), getTypeInfoFromString(), toString(), and TypeInfo().

templateParameters

std::vector<Ptr> smacc2::introspection::TypeInfo::templateParameters

Definition at line 48 of file smacc_type_info.hpp.

tkey

std::string smacc2::introspection::TypeInfo::tkey

private

Definition at line 70 of file smacc_type_info.hpp.

Referenced by getTypeInfoFromString(), toString(), and TypeInfo().

typeInfoDatabase

std::map< std::string, TypeInfo::Ptr > smacc2::introspection::TypeInfo::typeInfoDatabase

static

Definition at line 67 of file smacc_type_info.hpp.

Referenced by getTypeInfoFromString().

---

The documentation for this class was generated from the following files:

• smacc2/include/smacc2/introspection/smacc_type_info.hpp
• smacc2/src/smacc2/introspection/string_type_walker.cpp