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 <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)
      throw(Exception::FileNotFound);

    virtual ~File();

    virtual void clear();


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



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

    bool reopen()
      throw (Exception::FileNotFound);

    bool reopen(File::OpenMode open_mode)
      throw (Exception::FileNotFound);

    void close();

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

    const String& getOriginalName() const;

    Size getSize()
      throw(Exception::FileNotFound);

    static Size getSize(String name)
      throw (Exception::FileNotFound);

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

    Type getType(bool trace_link)
      const throw(Exception::FileNotFound);

    static bool copy(String source_name, String destination_name, Size buffer_size = 4096)
      throw(Exception::FileNotFound);

    bool copyTo(const String& destination_name, Size buffer_size = 4096)
      throw(Exception::FileNotFound);

    static bool move(const String& source_name, const String& destination_name)
      throw(Exception::FileNotFound);

    bool moveTo(const String& destination_name)
      throw(Exception::FileNotFound);

    static bool remove(String name);

    bool remove();

    static bool rename(String old_path, String new_path)
      throw (Exception::FileNotFound);

    bool renameTo(const String& new_path)
      throw (Exception::FileNotFound);

    static bool truncate(String path, Size size = 0)
      throw (Exception::FileNotFound);

    bool truncate(Size size = 0)
      throw (Exception::FileNotFound);
      
    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 throw (Exception::FileNotFound);

    bool isCanonized()
      const throw (Exception::FileNotFound);
  
    static bool isReadable(String name)
      throw (Exception::FileNotFound);

    bool isReadable()
      const throw (Exception::FileNotFound);

    static bool isWritable(String name)
      throw (Exception::FileNotFound);

    bool isWritable()
      const throw (Exception::FileNotFound);

    static bool isExecutable(String name)
      throw (Exception::FileNotFound);

    bool isExecutable()
      const throw (Exception::FileNotFound);
 


    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 TransformationManager  transformation_manager_;
    static Size                   transformation_methods_;
  };


  template <typename T>
  class BinaryFileAdaptor
  {

    public:



    BinaryFileAdaptor();

    BinaryFileAdaptor(const T& data, bool swap_endian = false);




    void setSwapEndian(bool swap_endian);

    bool getSwapEndian() const;

    void setData(const T& data);

    const T& getData() const;

    T& getData();


    protected:

    //_ The member data.
    T data_;

    //_ A flag indicating whether we should swap all reads and writes
    bool swap_endian_;
  };

  template <typename T>
  BALL_INLINE
  BinaryFileAdaptor<T>::BinaryFileAdaptor()
    : data_(),
      swap_endian_(false)
  {
  }

  template <typename T>
  BALL_INLINE
  BinaryFileAdaptor<T>::BinaryFileAdaptor(const T& data, bool swap_endian)
    : data_(data),
      swap_endian_(swap_endian)
  {
  }

  template <typename T>
  BALL_INLINE
  void BinaryFileAdaptor<T>::setSwapEndian(bool swap_endian)
  {
    swap_endian_ = swap_endian;
  }

  template <typename T>
  BALL_INLINE
  bool BinaryFileAdaptor<T>::getSwapEndian() const
  {
    return swap_endian_;
  }

  template <typename T>
  BALL_INLINE
  void BinaryFileAdaptor<T>::setData(const T& data)
  {
    data_ = data;
  }

  template <typename T>
  BALL_INLINE
  const T& BinaryFileAdaptor<T>::getData() const 
  {
    return data_;
  }

  template <typename T>
  BALL_INLINE
  T& BinaryFileAdaptor<T>::getData()
  {
    return data_;
  }

  template <typename T>
  std::ostream& operator << (std::ostream& os, const BinaryFileAdaptor<T>& data)
  {
    // do we need to swap endianness?
    if (!data.getSwapEndian())
    {
      os.write(reinterpret_cast<const char*>(&data.getData()), sizeof(T));
    }
    else
    {
      T swapped_data = data.getData();
      swapBytes(swapped_data);
      os.write(reinterpret_cast<const char*>(&swapped_data), sizeof(T));
    }
    return os;
  }

  template <typename T>
  std::istream& operator >> (std::istream& is, BinaryFileAdaptor<T>& data)
  {
    // do we need to swap endianness?
    if (!data.getSwapEndian())
    {
      is.read(reinterpret_cast<char*>(&data.getData()), sizeof(T));
    }
    else
    {
      T swapped_data;
      is.read(reinterpret_cast<char*>(&swapped_data), sizeof(T));
      swapBytes(swapped_data);
      data.setData(swapped_data);
    }
    return is;
  }


  template <typename T>
  BALL_INLINE
  void swapBytes(T& t)
  {
    if (sizeof(T) % 2 != 0)
    {
      Log.error() << "Cannot swap types of uneven size." << std::endl;
      return;
    }

    char* tmp = reinterpret_cast<char*>(&t);
    std::reverse(tmp, tmp + sizeof(T));
  }
  

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

#endif // BALL_SYSTEM_FILE_H

---