#include <Utils.h>

Collaboration diagram for OpenDDS::XTypes::MemberPathParser:

Public Member Functions
	MemberPathParser (const char *path)

	MemberPathParser (const DCPS::String &path)

bool	consume (size_t by)

bool	get_next_subpath ()

bool	get_index (CORBA::UInt32 &index)

Public Attributes
size_t	pos

size_t	left

const char *	path

bool	error

bool	in_subscript

DCPS::String	subpath

Detailed Description

Iterate over parts of a member name path that can be the name of a field inside a function or an array element nested multiple levels inside a type.

Examples: "member_a" "member_b[2]" "member_b[2].x" "[2]" (If the DynamicData is indexed or keyed)

Definition at line 43 of file XTypes/Utils.h.

Constructor & Destructor Documentation

◆ MemberPathParser() [1/2]

OpenDDS::XTypes::MemberPathParser::MemberPathParser ( const char * path )

inline

Definition at line 52 of file XTypes/Utils.h.

References strlen().

     : pos(0)
     , left(path ? std::strlen(path) : 0)
     , path(left > 0 ? path : 0)
     , error(false)
     , in_subscript(false)
   {
   }

◆ MemberPathParser() [2/2]

OpenDDS::XTypes::MemberPathParser::MemberPathParser ( const DCPS::String & path )

inline

Definition at line 61 of file XTypes/Utils.h.

     : pos(0)
     , left(path.size())
     , path(left > 0 ? path.c_str() : 0)
     , error(false)
     , in_subscript(false)
   {
   }

Member Function Documentation

◆ consume()

bool OpenDDS::XTypes::MemberPathParser::consume ( size_t by )

Definition at line 113 of file XTypes/Utils.cpp.

References ACE_ERROR, error, left, LM_WARNING, OpenDDS::DCPS::log_level, path, pos, and OpenDDS::DCPS::LogLevel::Warning.

Referenced by get_next_subpath().

 {
   if (by > left) {
     if (log_level >= LogLevel::Warning) {
       ACE_ERROR((LM_WARNING, "(%P|%t) Warning: MemberPathParser::consume: "
         "at pos %B with %B left trying to increment by %B\n", pos, left, by));
     }
     error = true;
     return false;
   }
   pos += by;
   left -= by;
   path += by;
   return true;
 }

◆ get_index()

bool OpenDDS::XTypes::MemberPathParser::get_index ( CORBA::UInt32 & index )

Definition at line 213 of file XTypes/Utils.cpp.

References ACE_ERROR, OpenDDS::DCPS::convertToInteger(), in_subscript, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, and subpath.

 {
   if (!in_subscript || subpath.empty() ||
       subpath.find_first_not_of("0123456789") != DCPS::String::npos) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_index: "
         "\"%C\" is not a valid subscript index\n", subpath.c_str()));
 
     }
     return false;
   }
   return DCPS::convertToInteger(subpath, index);
 }

◆ get_next_subpath()

bool OpenDDS::XTypes::MemberPathParser::get_next_subpath ( )

Put the next member name or subscript value in subpath and which kind in in_subscript. Returns false when the end of the path is reached or there was an error in which case error is set to true.

Definition at line 129 of file XTypes/Utils.cpp.

References ACE_ERROR, consume(), error, in_subscript, left, LM_NOTICE, OpenDDS::DCPS::log_level, OpenDDS::DCPS::LogLevel::Notice, path, pos, and subpath.

Referenced by OpenDDS::XTypes::MemberPath::resolve_string_path().

 {
   if (!path) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_next_subpath: "
         "empty or null path\n"));
     }
     error = true;
     return false;
   }
 
   // See if we're in a nested member or subscript and move past the '.' or '[' if we are.
   in_subscript = left > 0 ? path[0] == '[' : false;
   const bool nested_member = left > 0 ? path[0] == '.' : false;
   if (nested_member && pos == 0) {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_next_subpath: "
         "at pos 0 found unexpected '.'\n"));
     }
     error = true;
     return false;
   }
   if (nested_member || in_subscript) {
     consume(1);
   }
 
   size_t i = 0; // Char count to consume
   size_t got = 0; // Char count to use for the result
   char c = '\0';
   bool scan = true;
   for (; i < left && scan; ++i) {
     c = path[i];
     switch (c) {
     case '.':
     case '[':
       if (in_subscript) {
         if (log_level >= LogLevel::Notice) {
           ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_next_subpath: "
             "at pos %B unexpected '%c' in a subscript\n", pos + i, c));
         }
         error = true;
         return false;
       }
       --i; // Don't consume, leave for next iteration
       // fallthrough
     case ']':
       scan = false;
       break;
 
     default:
       ++got;
     }
   }
 
   if (in_subscript && c != ']') {
     if (log_level >= LogLevel::Notice) {
       ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_next_subpath: "
         "at pos %B expected to find a ']' to end subscript\n", pos + i));
     }
     error = true;
     return false;
   }
 
   if (got == 0) {
     if (in_subscript || nested_member) {
       if (log_level >= LogLevel::Notice) {
         const char* const expected = in_subscript ? "index or key" : "member name";
         if (c) {
           ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_next_subpath: "
             "at pos %B expected to find %C before '%c'\n", pos + i, expected, c));
         } else {
           ACE_ERROR((LM_NOTICE, "(%P|%t) NOTICE: MemberPathParser::get_next_subpath: "
             "at pos %B expected to find %C before the end of the path\n", pos + i, expected));
         }
       }
       error = true;
     }
     return false;
   }
 
   subpath.assign(path, got);
   return consume(i);
 }