text: //C-  -*- C++ -*-
  //C- -------------------------------------------------------------------
  //C- DjVuLibre-3.5
  //C- Copyright (c) 2002  Leon Bottou and Yann Le Cun.
  //C- Copyright (c) 2001  AT&T
  //C-
  //C- This software is subject to, and may be distributed under, the
  //C- GNU General Public License, either Version 2 of the license,
  //C- or (at your option) any later version. The license should have
  //C- accompanied the software or you may obtain a copy of the license
  //C- from the Free Software Foundation at http://www.fsf.org .
  //C-
  //C- This program is distributed in the hope that it will be useful,
  //C- but WITHOUT ANY WARRANTY; without even the implied warranty of
  //C- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  //C- GNU General Public License for more details.
  //C- 
  //C- DjVuLibre-3.5 is derived from the DjVu(r) Reference Library from
  //C- Lizardtech Software.  Lizardtech Software has authorized us to
  //C- replace the original DjVu(r) Reference Library notice by the following
  //C- text (see doc/lizard2002.djvu and doc/lizardtech2007.djvu):
  //C-
  //C-  ------------------------------------------------------------------
  //C- | DjVu (r) Reference Library (v. 3.5)
  //C- | Copyright (c) 1999-2001 LizardTech, Inc. All Rights Reserved.
  //C- | The DjVu Reference Library is protected by U.S. Pat. No.
  //C- | 6,058,214 and patents pending.
  //C- |
  //C- | This software is subject to, and may be distributed under, the
  //C- | GNU General Public License, either Version 2 of the license,
  //C- | or (at your option) any later version. The license should have
  //C- | accompanied the software or you may obtain a copy of the license
  //C- | from the Free Software Foundation at http://www.fsf.org .
  //C- |
  //C- | The computer code originally released by LizardTech under this
  //C- | license and unmodified by other parties is deemed "the LIZARDTECH
  //C- | ORIGINAL CODE."  Subject to any third party intellectual property
  //C- | claims, LizardTech grants recipient a worldwide, royalty-free, 
  //C- | non-exclusive license to make, use, sell, or otherwise dispose of 
  //C- | the LIZARDTECH ORIGINAL CODE or of programs derived from the 
  //C- | LIZARDTECH ORIGINAL CODE in compliance with the terms of the GNU 
  //C- | General Public License.   This grant only confers the right to 
  //C- | infringe patent claims underlying the LIZARDTECH ORIGINAL CODE to 
  //C- | the extent such infringement is reasonably necessary to enable 
  //C- | recipient to make, have made, practice, sell, or otherwise dispose 
  //C- | of the LIZARDTECH ORIGINAL CODE (or portions thereof) and not to 
  //C- | any greater extent that may be necessary to utilize further 
  //C- | modifications or combinations.
  //C- |
  //C- | The LIZARDTECH ORIGINAL CODE is provided "AS IS" WITHOUT WARRANTY
  //C- | OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  //C- | TO ANY WARRANTY OF NON-INFRINGEMENT, OR ANY IMPLIED WARRANTY OF
  //C- | MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  //C- +------------------------------------------------------------------
  
  #ifndef _GURL_H_
  #define _GURL_H_
  #ifdef HAVE_CONFIG_H
  #include "config.h"
  #endif
  #if NEED_GNUG_PRAGMAS
  # pragma interface
  #endif
  
  
  #include "GString.h"
  #include "Arrays.h"
  #include "GThreads.h"
  
  
  #ifdef HAVE_NAMESPACES
  namespace DJVU {
  # ifdef NOT_DEFINED // Just to fool emacs c++ mode
  }
  #endif
  #endif
  
  /** @name GURL.h
      Files #"GURL.h"# and #"GURL.cpp"# contain the implementation of the
      \Ref{GURL} class used to store URLs in a system independent format.
      @memo System independent URL representation.
      @author Andrei Erofeev <eaf@geocities.com>
  
  // From: Leon Bottou, 1/31/2002
  // This has been heavily changed by Lizardtech.
  // They decided to use URLs for everyting, including
  // the most basic file access.  The URL class now is a unholy 
  // mixture of code for syntactically parsing the urls (which is was)
  // and file status code (only for local file: urls).
  
  */
  
  //@{
  
  /** System independent URL representation.
  
      This class is used in the library to store URLs in a system independent
      format. The idea to use a general class to hold URL arose after we
      realized, that DjVu had to be able to access files both from the WEB
      and from the local disk. While it is strange to talk about system
      independence of HTTP URLs, file names formats obviously differ from
      platform to platform. They may contain forward slashes, backward slashes,
      colons as separators, etc. There maybe more than one URL corresponding
      to the same file name. Compare #file:/dir/file.djvu# and
      #file://localhost/dir/file.djvu#.
  
      To simplify a developer's life we have created this class, which contains
      inside a canonical representation of URLs.
  
      File URLs are converted to internal format with the help of \Ref{GOS} class.
  
      All other URLs are modified to contain only forward slashes.
  */
  
  class DJVUAPI GURL
  {
  public:
    class Filename;
    class UTF8;
    class Native;
  protected:
        /** @name Constructors
  	  Accept the string URL, check that it starts from #file:/#
  	  or #http:/# and convert to internal system independent
  	  representation.
        */
        //@{
        ///
     GURL(const char * url_string);
        //@}
  
  public:
     GURL(void);
  
     GURL(const GUTF8String & url_string);
  
     GURL(const GNativeString & url_string);
  
     GURL(const GUTF8String &xurl, const GURL &codebase);
  
     GURL(const GNativeString &xurl, const GURL &codebase);
  
        /// Copy constructor
     GURL(const GURL & gurl);
  
        /// The destructor
     virtual ~GURL(void) {}
  
  private:
        // The 'class_lock' should be locked whenever you're accessing
        // url, or cgi_name_arr, or cgi_value_arr.
     GCriticalSection	class_lock;
  protected:
     GUTF8String	url;
     DArray<GUTF8String>	cgi_name_arr, cgi_value_arr;
     bool validurl;
  
     void		init(const bool nothrow=false);
     void		convert_slashes(void);
     void		beautify_path(void);
     static GUTF8String	beautify_path(GUTF8String url);
  
     static GUTF8String	protocol(const GUTF8String& url);
     void		parse_cgi_args(void);
     void		store_cgi_args(void);
  public:
     /// Test if the URL is valid. If invalid, reinitialize.
     bool is_valid(void) const;     // const lies to the compiler because of dependency problems
  
        /// Extracts the {\em protocol} part from the URL and returns it
     GUTF8String	protocol(void) const;
  
        /** Returns string after the first '\#' with decoded
  	  escape sequences. */
     GUTF8String	hash_argument(void) const;
  
        /** Inserts the #arg# after a separating hash into the URL.
  	  The function encodes any illegal character in #arg# using
  	  \Ref{GOS::encode_reserved}(). */
     void		set_hash_argument(const GUTF8String &arg);
  
        /** Returns the total number of CGI arguments in the URL.
  	  CGI arguments follow '#?#' sign and are separated by '#&#' signs */
     int		cgi_arguments(void) const;
  
        /** Returns the total number of DjVu-related CGI arguments (arguments
  	  following #DJVUOPTS# in the URL). */
     int		djvu_cgi_arguments(void) const;
  
        /** Returns that part of CGI argument number #num#, which is
  	  before the equal sign. */
     GUTF8String	cgi_name(int num) const;
  
        /** Returns that part of DjVu-related CGI argument number #num#,
  	  which is before the equal sign. */
     GUTF8String	djvu_cgi_name(int num) const;
  
        /** Returns that part of CGI argument number #num#, which is
  	  after the equal sign. */
     GUTF8String	cgi_value(int num) const;
     
        /** Returns that part of DjVu-related CGI argument number #num#,
  	  which is after the equal sign. */
     GUTF8String	djvu_cgi_value(int num) const;
     
        /** Returns array of all known CGI names (part of CGI argument before
  	  the equal sign) */
     DArray<GUTF8String>cgi_names(void) const;
  
        /** Returns array of names of DjVu-related CGI arguments (arguments
  	  following #DJVUOPTS# option. */
     DArray<GUTF8String>djvu_cgi_names(void) const;
     
        /** Returns array of all known CGI names (part of CGI argument before
  	  the equal sign) */
     DArray<GUTF8String>cgi_values(void) const;
  
        /** Returns array of values of DjVu-related CGI arguments (arguments
  	  following #DJVUOPTS# option. */
     DArray<GUTF8String>djvu_cgi_values(void) const;
  
        /// Erases everything after the first '\#' or '?'
     void		clear_all_arguments(void);
  
        /// Erases everything after the first '\#'
     void		clear_hash_argument(void);
  
        /// Erases DjVu CGI arguments (following "#DJVUOPTS#")
     void		clear_djvu_cgi_arguments(void);
  
        /// Erases all CGI arguments (following the first '?')
     void		clear_cgi_arguments(void);
  
        /** Appends the specified CGI argument. Will insert "#DJVUOPTS#" if
  	  necessary */
     void		add_djvu_cgi_argument(const GUTF8String &name, const char * value=0);
     
        /** Returns the URL corresponding to the directory containing
  	  the document with this URL. The function basically takes the
  	  URL and clears everything after the last slash. */
     GURL		base(void) const;
  
        /// Returns the aboslute URL without the host part.
     GUTF8String pathname(void) const;
  
        /** Returns the name part of this URL.
  	  For example, if the URL is #http://www.lizardtech.com/file%201.djvu# then
            this function will return #file%201.djvu#. \Ref{fname}() will
            return #file 1.djvu# at the same time. */
     GUTF8String	name(void) const;
  
        /** Returns the name part of this URL with escape sequences expanded.
  	  For example, if the URL is #http://www.lizardtech.com/file%201.djvu# then
            this function will return #file 1.djvu#. \Ref{name}() will
            return #file%201.djvu# at the same time. */
     GUTF8String	fname(void) const;
  
        /// Returns the extention part of name of document in this URL.
     GUTF8String	extension(void) const;
  
        /// Checks if this is an empty URL
     bool		is_empty(void) const;
  
        /// Checks if the URL is local (starts from #file:/#) or not
     bool		is_local_file_url(void) const;
  
        /** @name Concatenation operators
  	  Concatenate the GURL with the passed {\em name}. If the {\em name}
  	  is absolute (has non empty protocol prefix), we just return
  	  #GURL(name)#. Otherwise the #name# is appended to the GURL after a
  	  separating slash.
        */
        //@{
        ///
  //   GURL		operator+(const GUTF8String &name) const;
        //@}
  
        /// Returns TRUE if #gurl1# and #gurl2# are the same
     bool	operator==(const GURL & gurl2) const;
  
        /// Returns TRUE if #gurl1# and #gurl2# are different
     bool	operator!=(const GURL & gurl2) const;
  
        /// Assignment operator
     GURL &	operator=(const GURL & url);
  
        /// Returns Internal URL representation
     operator	const char*(void) const { return url; };
  
    /** Returns a string representing the URL.  This function normally
        returns a standard file URL as described in RFC 1738.  
        Some versions of MSIE do not support this standard syntax.
        A brain damaged MSIE compatible syntax is generated
        when the optional argument #useragent# contains string #"MSIE"# or
        #"Microsoft"#. */
     GUTF8String get_string(const GUTF8String &useragent) const;
  
     GUTF8String get_string(const bool nothrow=false) const;
  
        /// Escape special characters
     static GUTF8String encode_reserved(const GUTF8String &gs);
  
     /** Decodes reserved characters from the URL.
        See also: \Ref{encode_reserved}(). */
     static GUTF8String decode_reserved(const GUTF8String &url);
  
    /// Test if this url is an existing file, directory, or device.
    bool is_local_path(void) const;
  
    /// Test if this url is an existing file.
    bool is_file(void) const;
  
    /// Test if this url is an existing directory.
    bool is_dir(void) const;
  
    /// Follows symbolic links.
    GURL follow_symlinks(void) const;
  
    /// Creates the specified directory.
    int mkdir(void) const;
  
    /** Deletes file or directory.
        Directories are not deleted unless the directory is empty.
        Returns a negative number if an error occurs. */
    int deletefile(void) const;
  
    /** Recursively erases contents of directory. The directory
        itself will not be removed. */
    int cleardir(const int timeout=0) const;
  
    /// Rename a file or directory.
    int renameto(const GURL &newurl) const;
  
    /// List the contents of a directory. 
    GList<GURL> listdir(void) const;
  
    /** Returns a filename for a URL. Argument #url# must be a legal file URL.
        This function applies heuristic rules to convert the URL into a valid
        file name. It is guaranteed that this function can properly parse all
        URLs generated by #filename_to_url#. The heuristics also work better when
        the file actually exists.  The empty string is returned when this
        function cannot parse the URL or when the URL is not a file URL.
          URL formats are as described in RFC 1738 plus the following alternative
        formats for files on the local host:
  
                  file://<letter>:/<path>
                  file://<letter>|/<path>
                  file:/<path>
  
        which are accepted because various browsers recognize them.*/
     GUTF8String UTF8Filename(void) const;
     /// Same but returns a native string.
     GNativeString NativeFilename(void) const;
  
        /** Hashing function.
  	  @return hash suitable for usage in \Ref{GMap} */
     friend unsigned int	hash(const GURL & gurl);
  
    /** Returns fully qualified file names.  This functions constructs the fully
        qualified name of file or directory #filename#. When provided, the
        optional argument #fromdirname# is used as the current directory when
        interpreting relative specifications in #filename#.  Function
        #expand_name# is very useful for logically concatenating file names.  It
        knows which separators should be used for each operating system and it
        knows which syntactical rules apply. */
    static GUTF8String expand_name(const GUTF8String &filename, const char *fromdirname=0);
  };
  
  class DJVUAPI GURL::UTF8 : public GURL
  {
  public:
    UTF8(const GUTF8String &xurl);
    UTF8(const GUTF8String &xurl, const GURL &codebase);
  };
  
  class DJVUAPI GURL::Native : public GURL
  {
  public:
    Native(const GNativeString &xurl);
    Native(const GNativeString &xurl, const GURL &codebase);
  };
  
  class DJVUAPI GURL::Filename : public GURL
  {
  public:
    Filename(const GUTF8String &filename);
    Filename(const GNativeString &filename);
    class UTF8;
    class Native;
  };
  
  class DJVUAPI GURL::Filename::UTF8 : public GURL::Filename
  {
  public:
    UTF8(const GUTF8String &filename);
  };
  
  class DJVUAPI GURL::Filename::Native : public GURL::Filename
  {
  public:
    Native(const GNativeString &filename);
  };
  
  
  inline bool
  GURL::operator!=(const GURL & gurl2) const
  {
    return !(*this == gurl2);
  }
  
  inline GUTF8String
  GURL::protocol(void) const
  {
     return protocol(get_string());
  }
  
  inline bool
  GURL::is_empty(void) const
  {
     return !url.length()||!get_string().length();
  }
  
  // Test if the URL is valid.
  // If invalid, reinitialize and return the result.
  inline bool
  GURL::is_valid(void) const
  {
    if(!validurl)
      const_cast<GURL *>(this)->init(true);
    return validurl;
  }
  
  
  
  //@}
  
  
  #ifdef HAVE_NAMESPACES
  }
  # ifndef NOT_USING_DJVU_NAMESPACE
  using namespace DJVU;
  # endif
  #endif
  #endif
  