PParser Class Reference

Packet parser class. More...

#include <pparser.h>

List of all members.

Public Member Functions

 PParser (char *packet=0, unsigned int length=0)
 constructor of pParser
 ~PParser ()
 default destructor
void setPacket (char *packet)
 array pointer setter method
void setLength (unsigned int length)
 array length setter method
char * getPacket ()
 returns actual packet array pointer
unsigned int getLength ()
 returns length of array
bool parse ()
 parsing method

Private Types

enum  State {
  INIT, S1, S2, S3,
  S4, S5, S6, S7,
  S8, S9, S10, S11,
  S12, S13, ERR
}

Private Member Functions

unsigned int parse_fr ()
 method parsing first row of the packet - NOT IMPLEMENTED YET
void parse_ts ()
 method parsing timestamp part of packet data - NOT IMPLEMENTED YET
void parse_3DOF ()
 method prasing 3DOF aditional markers data - NOT IMPLEMENTED YET
void parse_gl ()
 method parsing finger tracking data - NOT IMPLEMENTED YET
void parse_6DOF ()
 method parsing 6DOF devices tracking data - NOT IMPLEMENTED YET
void parse_flystick ()
 method parsing an old style flystick/flystick2 data - NOT IMPLEMENTED YET
void parse_flystick2 ()
 method parsing a new style flystick/flystick2 data - NOT IMPLEMENTED YET
void parse_6dcal ()
 method parsing additional information data - NOT IMPLEMENTED YET
int parse_int ()
 method parsing signed integer
float parse_float ()
 method parsing floating point number

Private Attributes

char * mp_packet
 Pointer to byte array (char[]).
unsigned int m_packet_length
 Length of array pointed with mp_packet.
unsigned int m_packet_index
 index to next chunk to read while parsing datagram
unsigned int m_frame_counter
 the last frame counter

Detailed Description

Packet parser class.

This class enables parsing UDP datagram send by Dtrack software. The class can parse only ASCII format of the datagram.
It uses an array of chars (char[]) as packet buffer. You have to specify this array and also its length

Definition at line 11 of file pparser.h.

Member Enumeration Documentation

enum PParser::State [private]

Enumerator:
INIT 
S1 
S2 
S3 
S4 
S5 
S6 
S7 
S8 
S9 
S10 
S11 
S12 
S13 
ERR 

Definition at line 15 of file pparser.h.

00015 {INIT, S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, ERR};

Constructor & Destructor Documentation

PParser::PParser ( char *  packet = 0,
unsigned int  length = 0 
)

constructor of pParser

Note that constructor does not copy the array! It just use the pointer. So you have to store array you ara declaring to constructor
You can also use a default constructor pParser() but be sure you are using setPacket() & setLength()

Parameters:
packet is pointer to array where are stored packet data.
length is length of this array.

Definition at line 5 of file pparser.cpp.

00005                                                  : mp_packet(packet), m_packet_length(length), m_packet_index(0), m_frame_counter(0)
00006 {}

PParser::~PParser (  ) 

default destructor

destructor do not delete array pointed to (see constructor description)

Definition at line 7 of file pparser.cpp.

00008 {}

Member Function Documentation

unsigned int PParser::parse_fr (  )  [private]

method parsing first row of the packet - NOT IMPLEMENTED YET

Definition at line 166 of file pparser.cpp.

00167 {
00168        // TODO:: Implement
00169        return 0;
00170 }

void PParser::parse_ts (  )  [private]

method parsing timestamp part of packet data - NOT IMPLEMENTED YET

Definition at line 171 of file pparser.cpp.

00172 {
00173        // TODO:: Implement
00174 }

void PParser::parse_3DOF (  )  [private]

method prasing 3DOF aditional markers data - NOT IMPLEMENTED YET

Definition at line 175 of file pparser.cpp.

00176 {
00177        // TODO:: Implement
00178 }

void PParser::parse_gl (  )  [private]

method parsing finger tracking data - NOT IMPLEMENTED YET

Definition at line 179 of file pparser.cpp.

00180 {
00181        // TODO:: Implement
00182 }

void PParser::parse_6DOF (  )  [private]

method parsing 6DOF devices tracking data - NOT IMPLEMENTED YET

Definition at line 183 of file pparser.cpp.

00184 {
00185        // TODO:: Implement
00186 }

void PParser::parse_flystick (  )  [private]

method parsing an old style flystick/flystick2 data - NOT IMPLEMENTED YET

Definition at line 187 of file pparser.cpp.

00188 {
00189        // TODO:: Implement
00190 }

void PParser::parse_flystick2 (  )  [private]

method parsing a new style flystick/flystick2 data - NOT IMPLEMENTED YET

Definition at line 191 of file pparser.cpp.

00192 {
00193        // TODO:: Implement
00194 }

void PParser::parse_6dcal (  )  [private]

method parsing additional information data - NOT IMPLEMENTED YET

Definition at line 195 of file pparser.cpp.

00196 {
00197        // TODO:: Implement
00198 }

int PParser::parse_int (  )  [private]

method parsing signed integer

parsing is finished when not number character occurred

throw exception here - if reading out of array

Definition at line 200 of file pparser.cpp.

00201 {
00202        // TODO:: rebulid this method
00203        int tmp = 0;
00204        char chunk =  mp_packet[m_packet_index++];
00205        while('0' <= chunk && '9' >= chunk)
00206        {
00207               if (m_packet_index >= m_packet_length) return 0; 
00208               tmp = tmp * 10 + (int)(chunk - '0');
00209               chunk =  mp_packet[m_packet_index++];
00210        }
00211        return tmp;
00212 }

float PParser::parse_float (  )  [private]

method parsing floating point number

parsing is finished when not number character occurred

void PParser::setPacket ( char *  packet  ) 

array pointer setter method

Use this method after using default constructor pParser() or when you want to parse another packet array.
Simultaneously use setLength().

Definition at line 14 of file pparser.cpp.

00015 {
00016        mp_packet = packet;
00017 }

void PParser::setLength ( unsigned int  length  ) 

array length setter method

Use this method after using default constructor pParser() or when you want to parse another packet array.
Simultaneously use setPacket(). This method also force parser to parse from the beginning

Definition at line 9 of file pparser.cpp.

00010 {
00011        m_packet_length = length;
00012        m_packet_index =  0;
00013 }

char * PParser::getPacket (  ) 

returns actual packet array pointer

Definition at line 18 of file pparser.cpp.

00019 {
00020        return mp_packet;
00021 }

unsigned int PParser::getLength (  ) 

returns length of array

bool PParser::parse (  ) 

parsing method

result of parsing will be the trnsformation matrix
for the first time result will just check correctness

Definition at line 22 of file pparser.cpp.

00023 {
00024        State state = INIT;
00025 // every datagram start with "fr" tag that mean framepointer
00026        if ('f' == mp_packet[0] && 'r' == mp_packet[1] && ' ' == mp_packet[2])
00027        {
00028               m_packet_index = 3; // set packet iterator to next number
00029               m_frame_counter = parse_fr();
00030               std::cout << parse_int();
00031        }
00032        else
00033        {      
00034               return false; // bad packet syntax!
00035        }
00036 
00037        while ( m_packet_index < m_packet_length) // while not end of the packet
00038        {
00039               char chunk =  mp_packet[m_packet_index++]; // get next chunk
00040               switch (state)
00041               {
00042               case INIT:
00043                      {
00044                             // changing state
00045                                  if ('t' == chunk) state = S1;
00046                             else if ('3' == chunk) state = S3;
00047                             else if ('g' == chunk) state = S5;
00048                             else if ('6' == chunk) state = S7;
00049                             else return false; // instead of going to error state
00050                             break;
00051                      }
00052               case S1:
00053                      {
00054                             if ('s' == chunk) state = S2;
00055                             else return false; // insted of going to error state
00056                             break;
00057                      }
00058               case S2:
00059                      {
00060                             if (' ' == chunk) 
00061                             {
00062                                    parse_ts(); // tag is OK - now parsing arguments of tag...
00063                                    state = INIT; // after parsing tag - INIT state
00064                             }
00065                             else return false; // instead of going to error state
00066                             break;
00067                      }
00068               case S3:
00069                      {
00070                             if ('d' == chunk) state = S4;
00071                             else return false;
00072                             break;
00073                      }
00074               case S4:
00075                      {
00076                             if (' ' == chunk)
00077                             {
00078                                    parse_3DOF(); // tag OK - parse rest of line
00079                                    state = INIT; // try to fing another parser
00080                             }
00081                             else return false;
00082                             break; 
00083                      }
00084               case S5:
00085                      {
00086                             if ('l' == chunk) state = S6;
00087                             else return false;
00088                             break;
00089                      }
00090               case S6:
00091                      {
00092                             if (' ' == chunk)
00093                             {
00094                                    parse_gl();
00095                                    state = INIT;
00096                             }
00097                             else return false;
00098                             break;
00099                      }
00100               case S7:
00101                      {
00102                             if ('d' == chunk) state = S8;
00103                             else return false;
00104                             break;
00105                      }
00106               case S8:
00107                      {
00108                                  if ('f' == chunk) state = S9;
00109                             else if ('c' == chunk) state = S11;
00110                             else if (' ' == chunk)
00111                             {
00112                                    parse_6DOF();
00113                                    state = INIT;
00114                             }
00115                             else return false;
00116                             break;
00117                      }
00118               case S9:
00119                      {
00120                             if ('2' == chunk) state = S10;
00121                             else if (' ' == chunk)
00122                             {
00123                                    parse_flystick();
00124                                    state = INIT;
00125                             }
00126                             else return false;
00127                             break;
00128                      }
00129               case S10:
00130                      {
00131                             if (' ' == chunk)
00132                             {
00133                                    parse_flystick2();
00134                                    state = INIT;
00135                             }
00136                             else return false;
00137                             break;
00138                      }
00139               case S11:
00140                      {
00141                             if ('a' == chunk) state = S12;
00142                             else return false;
00143                             break;
00144                      }
00145               case S12:
00146                      {
00147                             if ('l' == chunk) state = S13;
00148                             else return false;
00149                             break;
00150                      }
00151               case S13:
00152                      {
00153                             if (' ' == chunk)
00154                             {
00155                                    parse_6dcal();
00156                                    state = INIT;
00157                             }
00158                             else return false;
00159                             break;
00160                      }
00161               default: return false; // Also error state- if ERR or undefined state - parsing unsuccesfull
00162               }
00163        }
00164        return true;
00165 }

Member Data Documentation

char* PParser::mp_packet [private]

Pointer to byte array (char[]).

Definition at line 18 of file pparser.h.

unsigned int PParser::m_packet_length [private]

Length of array pointed with mp_packet.

Definition at line 21 of file pparser.h.

unsigned int PParser::m_packet_index [private]

index to next chunk to read while parsing datagram

Definition at line 23 of file pparser.h.

unsigned int PParser::m_frame_counter [private]

the last frame counter

0 (zero) on init.

Definition at line 28 of file pparser.h.

The documentation for this class was generated from the following files:
Generated on Tue Mar 10 14:41:38 2009 for VRUT by  doxygen 1.5.5