Page.h

# ifndef Conjecture_Page_h
# define Conjecture_Page_h Conjecture_Page_h

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

// C++ Dependencies
# include <iostream>
# include "Element.h"

// Declaration
namespace Conjecture {

    // C++ Dependencies
    class Env;             // belongs-to
    class OCRModule;       // returns
    
    class Page : public Element {
        // For now, Env gets to set certain fields of Page that
        // violate total encapsulation. FUTURE FIX: This 'friend'
        // statement needs to be refined to a list of methods within
        // Env - the current statement is unnecessarily permissive.
        // And if possible, the friendship should be removed entirely.
        friend class Env;

        // In order to allow all Parts access to an image stored only
        // in Page, we must allow Part::image access to
        // Page::imageRef()
        friend const Image* Element::pageImage() const;

      public:
        /*
         * The "normal" way to create a Page instance
         *
         */
        Page(Env* env, const std::string& file);

        /*
         * A "special" Page constructor used to establish training sets.
         *
         */
        Page(Env* env, const std::string& imagefile, const std::string& validfile);

        virtual bool process();

        virtual bool segment();

        virtual bool identify();

        virtual bool format();

        virtual Page* asPage() { return this; }
        virtual const Page* asPage() const { return this; }

        virtual void printSummary(std::ostream& os = std::cerr, const std::string& indent = "", int index = -1) const;

        virtual void writeText(std::ostream& os) const;

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

        // *********
        // Accessors
        inline const Env* env()           const { return this->_env;   }
        inline const std::string & file() const { return this->_file;  }
        inline const Image*    image()    const { return this->_image; }

      protected:
        OCRModule* algorithms() const;

        // *********
        // Accessors
        inline void envIs(Env* env) { this->_env = env; }
        inline void fileIs(const std::string & file) { this->_file = file; }
        virtual int type() const    { return Type; }
        inline void imageIs(Image* image) { this->_image = image; }

      private:
        // *********
        // Accessors
        inline Env* &          envRef()  { return this->_env;  }
        inline std::string &   fileRef() { return this->_file; }
        inline Image* &        imageRef() { return this->_image; }

        // *****
        // State
        static const ElementType Type = ELEMENT_PAGE;

         Env*            _env;

         /*
          * The input file to be processed.
          *
          * This file is also used to establish a prefix for various
          * output files.
          */
         std::string     _file;

         Image*          _image;
    };
};

// C++ Dependencies
# include "Env.h"    // belongs-to

# endif // Conjecture_Page_h

---