Oculus_PrimeSerialInterface.hpp

Go to the documentation of this file.

 
#ifndef Oculus_PrimeSerialInterface_DEFINED
#define Oculus_PrimeSerialInterface_DEFINED
 
#include "wb_oculus_prime_serial.h" 
 
#ifdef WHITEBOARD_POSTER_STRING_CONVERSION
#include <arpa/inet.h>
 
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wreserved-id-macro"
#include <sstream>
#pragma clang diagnostic pop
#endif
 
namespace guWhiteboard                                                  
{
        class Oculus_PrimeSerialInterface: public wb_oculus_prime_serial
        {
        public:
 
        Oculus_PrimeSerialInterface() { }
 
#ifdef WHITEBOARD_POSTER_STRING_CONVERSION
        Oculus_PrimeSerialInterface(const std::string &str) { from_string(str); }
#undef DELIMITER
#undef SEP
#undef SV
#undef PARSER
#undef COMP
#undef PARSE
 
#define DELIMITER ','
#define SEP ':'
#define ARRAY_DEL '-'
#define SV std::vector<std::string>
#define PARSER(s, c, p) if (k.compare(s) == 0) { set_##c ( p ); continue; }
#define ARRAY_PARSER(s, c, p) if (k.compare(s) == 0)                        \
            {                                                               \
                SV kk = components_of_string_separated(v, ARRAY_DEL, true); \
                for(size_t n = 0; n < kk.size(); n++)                       \
                    { v = kk.at(n); _##c[n] = p; _##c##_mask = 1; }                                        \
                continue;                                                   \
            }
#define COMP(v, s) v.compare(0, 2, s) == 0
 
#define PARSE_UINT8 static_cast<uint8_t>(atoi(v.c_str())) 
 
                void from_string(const std::string &str) 
        {
            SV sn = components_of_string_separated(str, DELIMITER, true);
            for(size_t i = 0; i < sn.size(); i++)
            {
                SV kv = components_of_string_separated(sn.at(i), SEP, true);
                if(kv.size() != 2)
                {
                    fprintf(stderr, "parse error\n");
                    return;
                }
                std::string k = kv.at(0);
                std::string v = kv.at(1);
 
                //serial parser - removed indenting so I can read it, Carl.
ARRAY_PARSER("f",     forward,                    PARSE_UINT8 )
ARRAY_PARSER("l",     left,                       PARSE_UINT8 )
ARRAY_PARSER("r",     right,                      PARSE_UINT8 )
PARSER("s",     stop,                       1)
 
                //pretty parser - removed indenting so I can read it, Carl.
ARRAY_PARSER("forward",       forward,               PARSE_UINT8)
ARRAY_PARSER("left",       left,                     PARSE_UINT8)
ARRAY_PARSER("right",       right,                   PARSE_UINT8)
PARSER("stop",          stop,                       1)
            }
        }
 
                std::string description() const
                {
                        std::stringstream ss;
                        ss  
                        << static_cast<int>(forward()[0]) << " " << static_cast<int>(forward()[1]) << " forward : , ";
                        return ss.str();
                }
#endif // WHITEBOARD_POSTER_STRING_CONVERSION
        };
}
 
#endif //Oculus_PrimeSerialInterface_DEFINED