Tools/PotentialFields/PfcParser.h

Go to the documentation of this file.

/**
* @file PfcParser.h
* 
* Definition of class Parser
* This parser is used to parse pfc-files for potential fields
*
* @author <a href="mailto:timlaue@informatik.uni-bremen.de">Tim Laue</a>
*/

#ifndef PFC_PARSER_H_
#define PFC_PARSER_H_

#include "PfieldConfig.h"
#include <string>
#include <vector>
#ifdef POTENTIALFIELDS_FOR_GT2004_
#include "Tools/Streams/InStreams.h"  
#else
#include <fstream>
#endif //POTENTIALFIELDS_FOR_GT2004_
#include "PotentialfieldComposition.h"

class PotentialFieldsObject;
class FormationObject;
class SingleFormation;
class Action;
class Potentialfield;
class PotentialfieldTransformation;
class PotentialfieldFunction;
class PfPose;
class PfVec;
class PfieldGeometricObject;


/**
* @class InstanceGroup
*
* A container for temporary storage of 
* a group of object instances
*/
class InstanceGroup
{
public:
  /** The name of the group*/
  std::string name;
  /** The objects belonging to the group*/
  std::vector<PotentialFieldsObject*> objects;
};


/**
* @class Parser
*
* The parser for PotentialfieldComposition
*/
class Parser
{
public:
  /** Destructor */
  ~Parser();

  /** Executes the parser
  * @param composition The calling PotentialfieldComposition
  * @param filename The file to open and parse
  */
  void parse(PotentialfieldComposition* composition, std::string filename);

private:
#ifdef POTENTIALFIELDS_FOR_GT2004_
  /** A file object */
  InBinaryFile* file;
#else
  /** A file object */
  std::ifstream file;
#endif //POTENTIALFIELDS_FOR_GT2004_
  /** The last parsed token*/
  std::string currentToken;
  /** Parsed objects*/
  std::vector<PotentialFieldsObject*> objects;
  /** Fast mapping from name to index*/
  NameToIndexMap objectMap;
  /** The cached instance groups*/
  std::vector<InstanceGroup> instanceGroups;
  /** The calling PotentialfieldComposition*/
  PotentialfieldComposition* composition;

  /** Returns the next token from file
  * @return A Token
  */
  std::string nextToken();

  /** Returns one character from file
  * @return A character
  */
  char nextChar();

  /** Tests for the end of the file
  * @return true, if the end of the file has been reached
  */
  bool endOfFile();

  /** Parses an angle
  * @return The angle in radian
  */
  double parseAngle();

  /** Parses parameters for PotentialfieldComposition*/
  void parseComposition();
  
  /** Parses an object
  * @return A pointer to the parsed object
  */
  PotentialFieldsObject* parseObject();

  /** Parses an object and inserts it in the object list */
  void parseAndInsertObject();

  /** Parses an ObjectStateSymbol*/
  void parseObjectStateSymbol();

  /** Parses a group of instances*/
  void parseInstanceGroup();

  /** Parses the instance of an object*/
  void parseInstance();

  /** Parses a formation object*/
  void parseFormationObject();

  /** Parses and creates single formation rule for a formation
  * @param formation The single formation
  * @param formationToken Tehe first token to parse
  */
  void parseSingleFormation(SingleFormation*& formation, const std::string& formationToken);

  /** Parses a Motionfield*/
  void parseMotionfield();

  /** Parses and creates a transformation
  * @param transformation The transformation
  * @param typeToken The first token (indicates the type)
  */
  void parseTransformation(PotentialfieldTransformation*& transformation,
                           const std::string& typeToken);

  /** Parses an Action for an Actionfield
  * @param action The action
  */
  void parseAction(Action& action);

  /** Parses an Actionfield*/
  void parseActionfield();

  /** Parses and creates a function
  * @param function The function to parse
  */
  void parseFunction(PotentialfieldFunction*& function);

  /** Parses and creates a geometric object
  * @param geometricObject A pointer to a geometric object
  * @param preparsedToken The first token to parse
  */
  void parseGeometricObject(PfieldGeometricObject*& geometricObject,
                            const std::string& preparsedToken = "");

  /** Parses a list of object references
  * @param nameOfFirst The name of the first object
  * @param field The field to which the objects will be assigned
  */
  void parseObjectsForField(const std::string& nameOfFirst, Potentialfield* field);

  /** Parses some timing variables for a field
  * @param field The field
  */
  void parseTimeConstraintsForField(Potentialfield* field);

  /** Adds the elements of an object group to a field
  * @param groupName The name of the group
  * @param field The field to which the group is assigned
  */
  void addGroupToField(const std::string& groupName, Potentialfield* field);

  /** Finds an object given its name
  * @param name The name
  * @return A pointer to the object
  */
  PotentialFieldsObject* getObject(const std::string& name);

  /** Finds an object given its name and creates an instance
  * @param name The name
  * @return A pointer to the object
  */
  PotentialFieldsObject* getInstance(const std::string& name);
};


#endif  //PFC_PARSER_H_

---