Env.h

# ifndef Conjecture_Env_h
# define Conjecture_Env_h Conjecture_Env_h

// Insert SVN header substitution variable here
// Class Champion: Unassigned

// C++ Dependencies
# include "Root.h"            // parent
# include <vector>            // uses
# include <map>               // uses
# include "Page.h"            // has-a  (needed here to define friends)

// Declaration
namespace Conjecture {

  class OCRModule;       // has-a
    
  class Env : public Root {
  public:

      // Constructors
    Env(int argc, const char* argv[]);
    virtual ~Env();

    bool processArgs(int argc, const char** argv);

    Page* registerPage(const std::string& file);

    Page* currentPage() { return this->currentRef(); }

    void wrapup();

    static void test(int argc = 0, const char* argv[] = NULL);

    // Accessors

  public:
    inline const std::string & moduleId() const     { return this->_moduleId; }
    inline const Page* current() const              { return this->_current;  }
    inline const int verbose() const                { return this->_verbose;  }
    inline const std::string & infile() const       { return this->_infile;   }
    inline const std::string & outfile() const      { return this->_outfile;  }
    inline const std::vector<Page*> & pages() const { return this->_pages;    }
    inline const std::string & rawdata() const      { return this->_rawdata;  }
    inline const char** argv() const                { return this->_argv;     }
    inline unsigned argc() const                    { return this->_argc;     }

    inline const OCRModule* module() const { return this->_module; }

    virtual OCRModule* makeModule();

  protected:
    inline void currentIs(Page* current)                  { this->_current = current;   }
    inline void moduleIdIs(const std::string & moduleId)  { this->_moduleId = moduleId; }
    inline void pagesIs(const std::vector<Page*> & pages) { this->_pages = pages;       }
    inline void verboseIs(int verbose)                    { this->_verbose = verbose;   }
    inline void outfileIs(const std::string & outfile)    { this->_outfile = outfile;   }
    inline void infileIs(const std::string & infile)      { this->_infile = infile;     }
    inline void rawdataIs(const std::string & rawdata)    { this->_rawdata = rawdata;   }
    inline void argcIs(int argc)                          { this->_argc = argc;         }
    inline void argvIs(const char** argv)                 { this->_argv = argv;         }

  private: 
    inline Page*&                currentRef()  { return this->_current;  }
    inline std::string &         moduleIdRef() { return this->_moduleId; }
    inline std::string &         rawdataRef()  { return this->_rawdata;  }
    inline int&                  verboseRef()  { return this->_verbose;  }
    inline std::string &         outfileRef()  { return this->_outfile;  }
    inline std::string &         infileRef()   { return this->_infile;   }
    inline std::vector<Page*>&   pagesRef()    { return this->_pages;    }

    std::string _rawdata;

    std::string     _moduleId;

    OCRModule* _module;
    inline void moduleIs(OCRModule* module) { this->_module = module; }
    inline OCRModule* & moduleRef() { return this->_module; }

    std::string _outfile;

    std::string _infile;

    Page* _current; 

    std::vector<Page*> _pages;   

    int _verbose;

    unsigned _argc;

    const char** _argv;

  };
};

// C++ Dependencies
# include "Page.h" // has-a

# endif // Conjecture_Env_h

---