CommandStyleFileReader.h

Go to the documentation of this file.

/*=========================================================================
 
                                vtkbone
 
  VTK classes for building and analyzing Numerics88 finite element models.
 
  Copyright (c) 2010, Numerics88 Solutions Ltd.
  All rights reserved.
 
=========================================================================*/
 
#ifndef __CommandStyleFileReader_h
#define __CommandStyleFileReader_h
 
#include <iostream>
#include <string>
#include <sstream>
#include <map>
#include <stack>
 
#define FSDF_OK 0
#define FSDF_ERROR 1
 
class CommandStyleFileReader
{
public:
 
  // Defines a pointer to a member function that takes no arguments
  // and returns an int.
  typedef int (CommandStyleFileReader::*CommandHandler_t)();
 
  // A set of commmand handler methods mapped to command key words.
  typedef std::map<std::string,CommandHandler_t> CommandContext_t;
 
  // Constructor
  // stream - an already-opened input stream (file or string)
  CommandStyleFileReader (std::istream& stream);
 
  // Method that the user calls to read and process input stream.
  //
  // Returns FSDF_OK on success and FSDF_ERROR on failure.
  virtual int Read();
 
  virtual void DebugOn() {debug = 1;}
  virtual void DebugOff() {debug = 0;}
  virtual void SetDebug(int d) {debug = d;}
 
  int GetErrorStatus() {return errorStatus;}
  const char * GetErrorMsg() {return errorMsg.c_str();}
 
protected:
 
  // Register a method of your derived class to handle a particular command.
  //
  // commandName - identifying name of the command that you want to handle.
  // handler - member function pointer to your method.
  //           NOTE: You must use reinterpret_cast<CommandHandler_t> on this
  //                 argument when calling this function.  Refer to the above
  //                 discussion.
  int RegisterCommandHandler (const char* commandName,
                              CommandHandler_t handler);
 
  // Refer to the above discussion for the purpose, implementation, and
  // calling method of this function.
  virtual int CallCommandHandler (CommandHandler_t handler);
 
  // Called after all file lines have been read and processed.
  virtual int Finish() { return FSDF_OK; }
 
  // Reads the next line from the file and stores it in "line".
  // Checks for error conditions and increments lineCount.
  //
  // Returns 1 if a line is successfully obtained, and 0 otherwise.
  virtual int GetLine();
 
  // Returns 1 if the current line is a command.
  //
  // If a command is found, commandName should be set to the command name.
  virtual int IsCommand () = 0;
 
  // Returns 1 if the line is a comment line.
  // No default implementation, since comment line syntax varies considerably.
  // You don't need to implement this if you don't use it, since it is not
  // currently used by CommandStyleFileReader.
  virtual int IsCommentLine() = 0;
 
  // Search the input stream for a command.
  // If a command is found, commandName is set and ProcessCommand is called.
  //
  // Returns FSDF_OK on success and FSDF_ERROR on failure.
  virtual int FindCommand();
 
  // Check if the current command has been registered for any command
  // handlers, and if so, call that handler.
  // If no match is found, call FindCommandBoundaries (recursively) to
  // search for sub-commands.
  //
  // Returns FSDF_OK on success and FSDF_ERROR on failure.
  virtual int ProcessCommand();
 
  // Sets errorStatus to FSDF_ERROR and stores msg in erroMsg.
  // Will not overwrite a pre-existing error message.
  virtual void SetError (const std::string& msg);
 
  // Does nothing if debug is 0, otherwise prints msg to std::cerr.
  // Implement in derived class to provide your own debug message functionality.
  virtual void DebugMessage (const std::string& msg);
 
  // Prints msg to std::cerr.
  // Implement in derived class to provide your own debug message functionality.
  virtual void WarningMessage (const std::string& msg);
 
  std::istream&              stream;
  std::string                commandName;
  long                       lineCount;
  int                        repeatLastCommand;
 
  std::string                line;
 
  std::stack<CommandContext_t> commandContextStack;
 
  int                        debug;
 
  int                        errorStatus;
  std::string                errorMsg;
 
private:
  // Prevent compiler from making public versions of these.
  CommandStyleFileReader (const CommandStyleFileReader&);
  void operator= (const CommandStyleFileReader&);
 
};
 
//----------------------------------------------------------------------------
// This macro is used to record errors
// frSetErrorMsgMacro("Error message" << variable);
//
#define frSetErrorMsgMacro(x)                                \
   {                                                            \
   std::ostringstream msg;                                      \
   msg << "ERROR: In " << __FILE__ << ", line " << __LINE__     \
          << "\n" << this << ": " << x << "\n";                 \
   SetError(msg.str());                                         \
   }
 
//----------------------------------------------------------------------------
// This macro is used to print out debugging info
// frSetDebugMsgMacro("Debug message" << variable);
//
#define frSetDebugMsgMacro(x)                                \
   {                                                            \
   if (debug)                                                   \
   {                                                          \
     std::ostringstream msg;                                    \
     msg << "Debug: In " << __FILE__ << ", line " << __LINE__   \
         << "\n" << this << ": " << x << "\n";                  \
     DebugMessage (msg.str());                                  \
   }                                                          \
   }
 
//----------------------------------------------------------------------------
// This macro is used to print out debugging info
// frSetDebugMsgMacro("Debug message" << variable);
//
#define frSetWarningMsgMacro(x)                              \
   {                                                            \
   std::ostringstream msg;                                      \
   msg << "WARNING: In " << __FILE__ << ", line " << __LINE__   \
         << "\n" << this << ": " << x << "\n";                  \
   WarningMessage (msg.str());                                  \
   }
 
#endif  // __CommandStyleFileReader_h