worldfile.hh

Go to the documentation of this file.

/*
 *  Stage : a multi-robot simulator.
 *  Copyright (C) 2001, 2002 Richard Vaughan, Andrew Howard and Brian Gerkey.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
/*
 * Desc: A class for reading in the world file.
 * Author: Andrew Howard, Richard Vaughan
 * Date: 15 Nov 2001
 * CVS info: $Id$
 */

#ifndef WORLDFILE_HH
#define WORLDFILE_HH


#include <stdint.h> // for portable int types eg. uint32_t
#include <stdio.h> // for FILE ops

namespace Stg {

  class CProperty
  {
  public:
    int entity;

     std::string name;
    
     std::vector<int> values;

    int line;

    bool used;
        
     CProperty( int entity, const char* name, int line ) :
        entity(entity), 
        name(name),
        values(),
        line(line),
        used(false) {}
  };


  // Class for loading/saving world file.  This class hides the syntax
  // of the world file and provides an 'entity.property = value' style
  // interface.  Global settings go in entity 0; every other entity
  // refers to a specific entity.  Parent/child relationships are
  // encoded in the form of entity/subentity relationships.
  class Worldfile
  {
     // Standard constructors/destructors
  public: Worldfile();
  public: ~Worldfile();

     // replacement for fopen() that checks STAGEPATH dirs for the named file
     // (thanks to  Douglas S. Blank <dblank@brynmawr.edu>)
  protected: FILE* FileOpen(const std::string& filename, const char* method);

     // Load world from file
  public: bool Load(const std::string& filename );

    // Save world into named file
  public: bool Save(const std::string& filename);
    
     // Check for unused properties and print warnings
  public: bool WarnUnused();
     
     // Read a string
  public: const std::string ReadString(int entity, const char* name, const std::string& value);

     // Write a string
  public: void WriteString(int entity, const char *name, const std::string& value );

     // Read an integer 
  public: int ReadInt(int entity, const char *name, int value);

     // Write an integer
  public: void WriteInt(int entity, const char *name, int value);

     // Read a float 
  public: double ReadFloat(int entity, const char *name, double value);

     // Write a float
  public: void WriteFloat(int entity, const char *name, double value);

     // Read a length (includes unit conversion)
  public: double ReadLength(int entity, const char *name, double value)
    {
      return (ReadFloat( entity, name, value/unit_length ) * unit_length);
    }

     // Write a length (includes units conversion)
  public: void WriteLength(int entity, const char *name, double value);
  
     // Read an angle (includes unit conversion)
  public: double ReadAngle(int entity, const char *name, double value)
    {
      return (ReadFloat( entity, name, value/unit_angle ) * unit_angle);
    }

     // Read a boolean
     // REMOVE? public: bool ReadBool(int entity, const char *name, bool value);

     // Read a color (includes text to RGB conversion)
  public: uint32_t ReadColor(int entity, const char *name, uint32_t value);

     // Read a file name.  Always returns an absolute path.  If the
     // filename is entered as a relative path, we prepend the world
     // files path to it.
  public: const char *ReadFilename(int entity, const char *name, const char *value);
      
    // Read a series of values from a tuplee
  public: int ReadTuple( const int entity, const char* name, 
             const unsigned int first, const unsigned int num, const char* format, ... );
    
    // Write a series of values to a tuple
  public: void WriteTuple( const int entity, const char *name,
               const unsigned int first, const unsigned int count, const char* format, ... );
              

     // Private methods used to load stuff from the world file
  
     // Load tokens from a file.
  private: bool LoadTokens(FILE *file, int include);

     // Read in a comment token
  private: bool LoadTokenComment(FILE *file, int *line, int include);

     // Read in a word token
  private: bool LoadTokenWord(FILE *file, int *line, int include);

     // Load an include token; this will load the include file.
  private: bool LoadTokenInclude(FILE *file, int *line, int include);

     // Read in a number token
  private: bool LoadTokenNum(FILE *file, int *line, int include);

     // Read in a string token
  private: bool LoadTokenString(FILE *file, int *line, int include);

     // Read in a whitespace token
  private: bool LoadTokenSpace(FILE *file, int *line, int include);

     // Save tokens to a file.
  private: bool SaveTokens(FILE *file);

     // Clear the token list
  private: void ClearTokens();

     // Add a token to the token list
  private: bool AddToken(int type, const char *value, int include);

     // Set a token in the token list
  private: bool SetTokenValue(int index, const char *value);

     // Get the value of a token
  private: const char *GetTokenValue(int index);

     // Dump the token list (for debugging).
  private: void DumpTokens();

     // Parse a line
  private: bool ParseTokens();

     // Parse an include statement
  private: bool ParseTokenInclude(int *index, int *line);

     // Parse a macro definition
  private: bool ParseTokenDefine(int *index, int *line);

     // Parse an word (could be a entity or an property) from the token list.
  private: bool ParseTokenWord(int entity, int *index, int *line);

     // Parse a entity from the token list.
  private: bool ParseTokenEntity(int entity, int *index, int *line);

     // Parse an property from the token list.
  private: bool ParseTokenProperty(int entity, int *index, int *line);

     // Parse a tuple.
  private: bool ParseTokenTuple( CProperty*  property, int *index, int *line);

     // Clear the macro list
  private: void ClearMacros();

     // Add a macro
  private: void AddMacro(const char *macroname, const char *entityname,
                                 int line, int starttoken, int endtoken);

     // Lookup a macro by name

     // Returns a pointer to a macro with this name, or NULL if there is none..
     class CMacro;
  private: CMacro* LookupMacro(const char *macroname);

     // Dump the macro list for debugging
  private: void DumpMacros();

     // Clear the entity list
  private: void ClearEntities();

     // Add a entity
  private: int AddEntity(int parent, const char *type);

    // Get the number of entities.
  public: int GetEntityCount();

     // Get a entity (returns the entity type value)
  public: const char *GetEntityType(int entity);

     // Lookup a entity number by type name
     // Returns -1 if there is entity with this type
  public: int LookupEntity(const char *type);
  
     // Get a entity's parent entity.
     // Returns -1 if there is no parent.
  public: int GetEntityParent(int entity);

     // Dump the entity list for debugging
  private: void DumpEntities();

     // Clear the property list
  private: void ClearProperties();

     // Add an property
  private: CProperty* AddProperty(int entity, const char *name, int line);
     // Add an property value.
  private: void AddPropertyValue( CProperty* property, int index, int value_token);
  
     // Get an property
  public: CProperty* GetProperty(int entity, const char *name);

     // returns true iff the property exists in the file, so that you can
     // be sure that GetProperty() will work
     bool PropertyExists( int section, const char* token );

     // Set the value of an property.
  private: void SetPropertyValue( CProperty* property, int index, const char *value);

     // Get the value of an property.
  public:  const char *GetPropertyValue( CProperty* property, int index);

     // Dump the property list for debugging
  private: void DumpProperties();

     // Token types.
  private: enum
     {
        TokenComment,
        TokenWord, TokenNum, TokenString,
        TokenOpenEntity, TokenCloseEntity,
        TokenOpenTuple, TokenCloseTuple,
        TokenSpace, TokenEOL
     };
    
     // Token structure.
  private: 
     class CToken
     {
     public:
        // Non-zero if token is from an include file.
        int include;
        
        // Token type (enumerated value).
        int type;
        
        // Token value
        std::string value;
        
        CToken( int include, int type, const char* value ) :
          include(include), type(type), value(value) {}
     };
     
     // A list of tokens loaded from the file.
     // Modified values are written back into the token list.
     //private: int token_size, token_count;
  private:  std::vector<CToken> tokens;

     // Private macro class
  private: 
     class CMacro
     {
     public:
        // Name of macro
        std::string macroname;
        
        // Name of entity
        std::string entityname;
        
        // Line the macro definition starts on.
        int line;
        
        // Range of tokens in the body of the macro definition.
                 int starttoken, endtoken;
        
        CMacro(const char *macroname, const char *entityname,
                 int line, int starttoken, int endtoken) :
          macroname(macroname),
          entityname(entityname),
          line(line),
          starttoken(starttoken),
          endtoken(endtoken) {}
     };
     
     // Macro table
  private: std::map<std::string,CMacro> macros;
     
     // Private entity class
  private: 
     class CEntity
     {
     public:
        // Parent entity
        int parent;
        
        // Type of entity (i.e. position, laser, etc).
        std::string type;
        
        CEntity( int parent, const char* type ) : parent(parent), type(type) {} 
     };
     
     // Entity list
  private: std::vector<CEntity> entities;
     
     // Property list
  private: std::map<std::string,CProperty*> properties; 
     
     // Name of the file we loaded
  public: std::string filename;
     
     // Conversion units
  public: double unit_length;
  public: double unit_angle;
     
  };
    
};

#endif