file.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_SYSTEM_FILE_H
#define BALL_SYSTEM_FILE_H

#ifndef BALL_DATATYPE_REGULAREXPRESSION_H
# include <BALL/DATATYPE/regularExpression.h>
#endif

#ifndef BALL_DATATYPE_STRING_H
# include <BALL/DATATYPE/string.h>
#endif

#ifndef BALL_SYSTEM_FILESYSTEM_H
# include <BALL/SYSTEM/fileSystem.h>
#endif

#include <BALL/DATATYPE/hashSet.h>

#include <stdlib.h>                   // 'getenv'
#include <sys/stat.h>                 // 'stat', 'lstat'
#include <stdio.h>                    // 'rename'
#include <algorithm>                  // 'reverse'

#ifdef BALL_COMPILER_MSVC
#ifndef S_ISREG
# define S_ISREG _S_ISREG
#endif
#ifndef S_ISDIR
# define S_ISDIR _S_ISDIR
#endif
# define S_ISCHR _S_ISCHR
# define S_ISBLK _S_ISBLK
# define S_ISFIFO _S_ISFIFO
# define access _access
#endif

#include <iostream>
#include <fstream>
#include <sys/types.h>
#include <map>
#include <algorithm>

#ifdef BALL_HAS_UNISTD_H
# include <unistd.h>      // 'access', 'rename', 'truncate'
#endif

#ifdef BALL_COMPILER_MSVC
# include <fcntl.h>
# include <io.h>
  // Define the missing symbols from <unistd.h>,
  // which M$, in its infinite wisdom, was unable to provide.
# define F_OK 0
# define W_OK 2
# define R_OK 4
#endif


namespace BALL 
{
  class BALL_EXPORT TransformationManager
  { 
    public:
      
    
    TransformationManager();
    
    ~TransformationManager();
    

    
    void registerTransformation(const String& pattern, const String& command);
    
    void unregisterTransformation(const String& pattern);
    
    String findTransformation(const String& name) const;

    String transform(const String& name);

    protected:
    
    std::map<String, String>  transformation_methods_;
  };
    
  class BALL_EXPORT File
    : public std::fstream
  {
    public:

    class BALL_EXPORT CannotWrite
      : public Exception::GeneralException
    {
      public:
      CannotWrite(const char* file, int line, const String& filename);

      ~CannotWrite()
        throw();

      String getFilename() const;

      protected:
      std::string filename_;
    };

      
    typedef std::ios::openmode OpenMode;      



    static const OpenMode MODE_IN;

    static const OpenMode MODE_OUT;

    static const OpenMode MODE_APP;

    static const OpenMode MODE_BINARY;

    static const OpenMode MODE_ATE;

    static const OpenMode MODE_TRUNC;


    enum Transformation
    {
      TRANSFORMATION__EXEC = 1,
      TRANSFORMATION__FILTER = 2,
      TRANSFORMATION__URL = 3
    };

    enum Type
    {
      TYPE__UNKNOWN            = 0,
      TYPE__DIRECTORY          = 1,
      TYPE__CHAR_SPECIAL_FILE  = 2,
      TYPE__BLOCK_SPECIAL_FILE = 3,
      TYPE__REGULAR_FILE       = 4,
      TYPE__SYMBOLIC_LINK      = 5,
      TYPE__SOCKET             = 6,
      TYPE__FIFO_SPECIAL_FILE  = 7
    };

    static const String TRANSFORMATION_EXEC_PREFIX;

    static const String TRANSFORMATION_FILE_PREFIX;

    static const String TRANSFORMATION_FTP_PREFIX;

    static const String TRANSFORMATION_HTTP_PREFIX;



    File();

    File(const String& name, OpenMode open_mode = std::ios::in);

    virtual ~File();

    virtual void clear();


//    const File& operator = (const File& file);



    bool open(const String& name, File::OpenMode open_mode = std::ios::in);

    bool reopen();

    bool reopen(File::OpenMode open_mode);

    void close();

    const String& getName() const;
    
    void setName(const String& name);

    const String& getOriginalName() const;

    Size getSize();

    static Size getSize(String name);

    File::OpenMode getOpenMode() const;
    
    static Type getType(String name, bool trace_link);

    Type getType(bool trace_link) const;

    static bool copy(String source_name, String destination_name, Size buffer_size = 4096);

    bool copyTo(const String& destination_name, Size buffer_size = 4096);

    static bool move(const String& source_name, const String& destination_name);

    bool moveTo(const String& destination_name);

    static bool remove(String name);

    bool remove();

    static bool rename(String old_path, String new_path);

    bool renameTo(const String& new_path);

    static bool truncate(String path, Size size = 0);

    bool truncate(Size size = 0);
      
    static bool createTemporaryFilename(String& temporary, const String& suffix = ".TMP");

    std::fstream& getFileStream();



    TransformationManager& getTransformationManager();

    const TransformationManager& getTransformationManager() const;
    
    static void enableTransformation(Transformation transformation);

    static void disableTransformation(Transformation transformation);

    static bool isTransformationEnabled(Transformation transformation);

    static void registerTransformation(const String& pattern, const String& exec);

    static void unregisterTransformation(const String& pattern);



    bool operator == (const File& file) const;
    
    bool operator != (const File& file) const;

    bool isOpen() const;

    bool isClosed() const;

    static bool isAccessible(String name);

    bool isAccessible() const;

    bool isCanonized() const;
  
    static bool isReadable(String name);

    bool isReadable() const;

    static bool isWritable(String name);

    bool isWritable() const;

    static bool isExecutable(String name);

    bool isExecutable() const;
 


    bool isValid() const;


    private:
      const File& operator = (const File& file);

    protected:

    String    name_;
    String    original_name_;
    OpenMode  open_mode_;
    bool      is_open_;
    bool      is_temporary_;
    static HashSet<String> created_temp_filenames_;

    static TransformationManager  transformation_manager_;
    static Size                   transformation_methods_;
  };

# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/SYSTEM/file.iC>
# endif
  
} // namespace BALL

#endif // BALL_SYSTEM_FILE_H

---