ippResponseParser.h

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 


#ifndef PARSERRES_HH
#define PARSERRES_HH
#include "ippdme/ippdme.h"

#include "ippdme/ippResponseNameType.h"
#include "ippdme/Response/ippResponse.h"
#include "ippdme/ippTag.h"
#include "ippdme/Property/ippOnePropertyAlignment.h"
#include "ippdme/Property/ippOnePropertyAlignmentVolume.h"                            
#include "ippdme/Property/ippOnePropertyName.h"
#include "ippdme/Property/ippOnePropertyNumber.h"
#include "ippdme/Property/ippOnePropertyId.h"
#include "ippdme/Property/ippOnePropertyCollisionVolume.h"                            

#include <string>
#include <vector>
/* error codes

*/
namespace ipp
{
typedef enum parserResErrorId {
  OK = 0,
  BAD_CHARACTER_AFTER_KEYWORD,
  BAD_CHARACTER_AFTER_RESPONSE_END,
  BAD_COORDINATE_SYSTEM,
  BAD_E_NUMBER_EXPONENT_MUST_HAVE_ONE_TWO_OR_THREE_DIGITS,
  BAD_ERROR_CODE,
  BAD_GOTOPAR_PROPERTY,
  BAD_KEYWORD,
  BAD_MACHINE_CLASS,
  BAD_NUMBER_MORE_THAN_16_DIGITS,
  BAD_NUMBER_NO_DIGITS,
  BAD_NUMBER_TWO_DECIMAL_POINTS,
  BAD_PTMEASPAR_PROPERTY,
  BAD_RESPONSE_ITEMS,
  BAD_SECOND_KEYWORD,
  BAD_SEVENTH_CHARACTER_IN_RESPONSE,
  BAD_SEVERITY,
  BAD_STRING,
  BAD_TAG_CHARACTER,
  BAD_TEXT,
  BAD_THIRD_KEYWORD,
  BUG,
  ER_USED_TWICE,
  ERROR_CODE_MUST_HAVE_FOUR_DIGITS,
  FIRST_ARGUMENT_MUST_BE_SWITCH_ROTATE_MOVEAUTO_OR_MOVEMAN,
  IJK_USED_TWICE,
  IJKACT_USED_TWICE,
  Q_USED_TWICE,
  IJK_VALUES_MUST_BE_ZERO,
  ILLEGAL_SPACE,
  R_USED_TWICE,
  RESPONSE_NAME_MUST_BE_ERROR,
  SEVERITY_MUST_HAVE_ONE_DIGIT,
  SPACE_MISSING_AFTER_TAG,
  SPACE_MISSING_AT_EIGHTH_CHARACTER_OF_RESPONSE,
  TAG_NUMBER_OUT_OF_RANGE_FOR_COMMAND_TAG,
  TOOL_A_USED_TWICE,
  TOOL_B_USED_TWICE,
  TOOL_C_USED_TWICE,
  VALUE_MUST_BE_0_OR_1,
  X_USED_TWICE,
  Y_USED_TWICE,
  Z_USED_TWICE,
  ZERO_TAG_MUST_BE_SERVER_INITIATED_RESPONSE,
  BAD_PROPERTY,
};
}

typedef enum resItemType {
  RESCOMMA     = ',',
  RESDOT       = '.',
  RESDOUBLE    = '#', 
  RESKEYWORD   = 'k',
  RESPARENLEFT = '(',
  RESPARENRIGHT= ')',
  RESSTRING    = 's'
};


/* parserRes

To use the parser, the setInput() method must first be called to copy an
input string into the parser's inputArray. An alternative would be to
have a string as an argument to the parseXXX methods. Copying to
inputArray takes time, but it prevents the parser from messing up the
original string.

The caller should then call parseResponse(), which makes an instance of
the Response from the input string (if there is no error in the string).
If there is an error in the string, parseResponse returns NULL.

After calling parseResponse, the caller should call getParserErr()
to see if there was an error. If the returned error code is not OK,
the caller can call getErrorMessageString(buffer) to get an error message
that describes the error. The buffer should be at least 100 chars long.
If no error occurs until after the responseNameType is identified, the
responseNameType is given at the beginning of the error message.

If the error code is OK, the caller can start processing the Response
instance.

The caller may call parseTag() before calling parseResponse(), but that
is not required.

*/





class IPPDME_EXT_CLASS  ippResponseParser
{
public:
  ippResponseParser();
  virtual ~ippResponseParser();

  std::string getErrorMessageString() const; 

  ipp::parserResErrorId  getParserErr() const { return _errorCode;}
  tagIdType getTagType() const {return _tagType;}
  int getTag() const {return _tag;}

  ippResponsePtr parseResponse();
  
  void parseTag();
  
  void setInput(const char * input);

private:

  int _arrayIndex;                           
  ipp::parserResErrorId       _errorCode;    
  char _inputArray[IPPSIZE];                 

  int  _itemCount;                           

  std::vector<double>          _resDoubles;  
  std::vector<ippOtherKeyType> _resKeywords; 
 
  int _resSize;                              
  std::vector<std::string> _resStrings;      
  std::vector<resItemType> _resTypes;        
  
  ippResponseNameType      _responseName;    
  tagIdType                _tagType;

  int _tag;                  
  // tag number of command being parsed


  void makeArraysBigger();
  ippOnePropertyAlignmentPtr makeOnePropertyAlignment(int * n);
  ippOnePropertyAlignmentVolumePtr makeOnePropertyAlignmentVolume(int* n);
  ippOnePropertyCollisionVolumePtr makeOnePropertyCollisionVolume(int * n);

  ippOnePropertyIdPtr makeOnePropertyId(int * n);
  ippOnePropertyNamePtr makeOnePropertyName(int * n);
  ippResponsePtr makeAlignResponse();
  ippResponsePtr makeCenterPartResponse();
  ippResponsePtr makeChangeToolEResponse();
  ippResponsePtr makeDataResponse();
  ippResponsePtr makeEnumPropResponse();
  ippResponsePtr makeErrorResponse();
  ippResponsePtr makeGetChangeToolActionResponse();
  ippResponsePtr makeGetCoordSystemResponse();
  ippResponsePtr makeGetCsyTransformationResponse();
  ippResponsePtr makeGetDMEVersionResponse();
  ippResponsePtr makeGetErrStatusEResponse();
  ippResponsePtr makeGetMachineClassResponse();
  ippResponsePtr makeGetPropResponse();
  ippResponsePtr makeGoToEResponse();
  ippResponsePtr makeIsHomedResponse();
  ippResponsePtr makeIsUserEnabledResponse();
  ippResponsePtr makeKeyPressEResponse();
  ippResponsePtr makePtMeasEResponse();
  ippResponsePtr makePtMeasOrGetResponse();
  ippResponsePtr makeScanResponse();
  ippResponsePtr makeServerInitiatedResponse();
  ippResponsePtr makeSetPropEResponse();
  ippResponsePtr makeStringResponse();
  ippResponsePtr makeTiltCenterPartResponse();
  ippResponsePtr makeTiltPartResponse();
  
  void parseResItems();
  void parseKeyword();
  void parseNumber();
  void parseString();
  void unSpaceInputArray();
private:
  ippResponseParser(const ippResponseParser&);
  void operator=(const ippResponseParser&);

  void dump_token(int k);
  
  bool CheckOptionalArgument(
    int& n,
    bool& hasArgurment,
    ippOtherKeyType type,
    double& value,
    parserResErrorId errorIfDuplicated
  ); 

  bool CheckOptionalArgument(
    int& n,
    bool& hasArgurment,
    ippOtherKeyType type1,
    ippOtherKeyType type2,
    double& value,
    parserResErrorId errorIfDuplicated
  ); 
  bool CheckOptionalArgument(
    int& n,
    bool& hasArgurment,
    ippOtherKeyType type,
    double& value1,
    double& value2,
    double& value3,
    parserResErrorId errorIfDuplicated
  ); 
};

#endif /* #ifndef PARSERRES_HH */

---