src/KM_fileio.h

   1 /*
   2 Copyright (c) 2004-2009, John Hurst
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27   /*! \file    KM_fileio.h
  28     \version $Id$
  29     \brief   portable file i/o
  30   */
  31
  32 #ifndef _KM_FILEIO_H_
  33 #define _KM_FILEIO_H_
  34
  35 #include <KM_util.h>
  36 #include <string>
  37
  38 #ifdef KM_WIN32
  39 # include <io.h>
  40 #else
  41 # include <dirent.h>
  42 # include <unistd.h>
  43 # include <time.h>
  44 # include <sys/types.h>
  45 #include <regex.h>
  46 #endif
  47
  48 #include <sys/stat.h>
  49
  50
  51
  52 namespace Kumu
  53 {
  54   //
  55   class DirScanner
  56     {
  57     public:
  58 #ifdef KM_WIN32
  59       __int64               m_Handle;
  60       struct _finddatai64_t m_FileInfo;
  61 #else
  62       DIR*       m_Handle;
  63 #endif
  64
  65       DirScanner()  {};
  66       ~DirScanner() { Close(); }
  67
  68       Result_t Open(const char*);
  69       Result_t Close();
  70       Result_t GetNext(char*);
  71     };
  72
  73 #ifdef KM_WIN32
  74   typedef __int64  fsize_t;
  75   typedef __int64  fpos_t;
  76   typedef HANDLE FileHandle;
  77
  78   enum SeekPos_t {
  79     SP_BEGIN = FILE_BEGIN,
  80     SP_POS   = FILE_CURRENT,
  81     SP_END   = FILE_END
  82   };
  83 #else
  84   typedef off_t    fsize_t;
  85   typedef off_t    fpos_t;
  86   typedef int      FileHandle;
  87   const FileHandle INVALID_HANDLE_VALUE = -1L;
  88
  89   enum SeekPos_t {
  90     SP_BEGIN = SEEK_SET,
  91     SP_POS   = SEEK_CUR,
  92     SP_END   = SEEK_END
  93   };
  94 #endif
  95
  96   //
  97 #ifndef KM_SMALL_FILES_OK
  98   template <bool sizecheck>    void compile_time_size_checker();
  99   template <> inline void compile_time_size_checker<false>() {}
 100   //
 101   // READ THIS if your compiler is complaining about a previously declared implementation of
 102   // compile_time_size_checker(). For example, GCC 4.0.1 looks like this:
 103   //
 104   // error: 'void Kumu::compile_time_size_checker() [with bool sizecheck = false]' previously declared here
 105   //
 106   // This is happening because the equality being tested below is false. The reason for this
 107   // will depend on your OS, but on Linux it is probably because you have not used -D_FILE_OFFSET_BITS=64
 108   // Adding this magic macro to your CFLAGS will get you going again. If you are on a system that
 109   // does not support 64-bit files, you can disable this check by using -DKM_SMALL_FILES_OK. You
 110   // will then of course be limited to file sizes < 4GB.
 111   //
 112   template <> inline void compile_time_size_checker<sizeof(Kumu::fsize_t)==sizeof(ui64_t)>() {}
 113 #endif
 114   //
 115
 116   const ui32_t Kilobyte = 1024;
 117   const ui32_t Megabyte = Kilobyte * Kilobyte;
 118   const ui32_t Gigabyte = Megabyte * Kilobyte;
 119
 120   const ui32_t MaxFilePath = Kilobyte;
 121
 122   // Path Manglers
 123   //
 124   typedef std::list<std::string> PathCompList_t; // a list of path components
 125   typedef std::list<std::string> PathList_t; // a list of paths
 126
 127   bool        PathExists(const std::string& Path); // true if the path exists in the filesystem
 128   bool        PathIsFile(const std::string& Path); // true if the path exists in the filesystem and is a file
 129   bool        PathIsDirectory(const std::string& Path); // true if the path exists in the filesystem and is a directory
 130   fsize_t     FileSize(const std::string& Path); // returns the size of a regular file, 0 for a directory or device
 131   bool        PathsAreEquivalent(const std::string& lhs, const std::string& rhs); // true if paths point to the same filesystem entry
 132
 133   // split and reassemble pats as lists of path components
 134   PathCompList_t& PathToComponents(const std::string& Path, PathCompList_t& CList, char separator = '/'); // removes '//'
 135   std::string ComponentsToPath(const PathCompList_t& CList, char separator = '/');
 136   std::string ComponentsToAbsolutePath(const PathCompList_t& CList, char separator = '/'); // add separator to the front
 137   bool        PathHasComponents(const std::string& Path, char separator = '/'); // true if paths starts with separator
 138
 139   bool        PathIsAbsolute(const std::string& Path, char separator = '/'); // true if path begins with separator
 140   std::string PathMakeAbsolute(const std::string& Path, char separator = '/'); // compute position of relative path using getcwd()
 141   std::string PathMakeLocal(const std::string& Path, const std::string& Parent); // remove Parent from front of Path, if it exists
 142   std::string PathMakeCanonical(const std::string& Path, char separator = '/'); // remove '.' and '..'
 143
 144   std::string PathBasename(const std::string& Path, char separator = '/'); // returns right-most path element (list back())
 145   std::string PathDirname(const std::string& Path, char separator = '/'); // returns everything but the right-most element
 146   std::string PathGetExtension(const std::string& Path); // returns everything in the right-most element following the right-most '.'
 147   std::string PathSetExtension(const std::string& Path, const std::string& Extension); // empty extension removes '.' as well
 148
 149   //
 150   //
 151   class IPathMatch
 152   {
 153   public:
 154     virtual ~IPathMatch() {}
 155     virtual bool Match(const std::string& s) const = 0;
 156   };
 157
 158  class PathMatchAny : public IPathMatch
 159   {
 160   public:
 161     virtual ~PathMatchAny() {}
 162     inline bool Match(const std::string& s) const { return true; }
 163   };
 164
 165 #ifndef KM_WIN32
 166  class PathMatchRegex : public IPathMatch
 167   {
 168     regex_t m_regex;
 169     PathMatchRegex();
 170     const PathMatchRegex& operator=(const PathMatchRegex&);
 171
 172   public:
 173     PathMatchRegex(const std::string& Pattern);
 174     PathMatchRegex(const PathMatchRegex&);
 175     virtual ~PathMatchRegex();
 176     bool Match(const std::string& s) const;
 177   };
 178
 179  class PathMatchGlob : public IPathMatch
 180   {
 181     regex_t m_regex;
 182     PathMatchGlob();
 183     const PathMatchGlob& operator=(const PathMatchGlob&);
 184
 185   public:
 186     PathMatchGlob(const std::string& Pattern);
 187     PathMatchGlob(const PathMatchGlob&);
 188     virtual ~PathMatchGlob();
 189     bool Match(const std::string& s) const;
 190   };
 191 #endif /* !KM_WIN32 */
 192
 193   // Search all paths in SearchPaths for filenames matching Pattern (no directories are returned).
 194   // Put results in FoundPaths. Returns after first find if one_shot is true.
 195   PathList_t& FindInPath(const IPathMatch& Pattern, const std::string& SearchDir,
 196                          PathList_t& FoundPaths, bool one_shot = false, char separator = '/');
 197
 198   PathList_t& FindInPaths(const IPathMatch& Pattern, const PathList_t& SearchPaths,
 199                           PathList_t& FoundPaths, bool one_shot = false, char separator = '/');
 200
 201
 202   // Instant IO for strings
 203   //
 204   // Reads an entire file into a string.
 205   Result_t ReadFileIntoString(const char* filename, std::string& outString, ui32_t max_size = 8 * Megabyte);
 206
 207   // Writes a string to a file, overwrites the existing file if present.
 208   Result_t WriteStringIntoFile(const char* filename, const std::string& inString);
 209
 210   // Instant IO for archivable objects
 211   //
 212   // Unarchives a file into an object
 213   Result_t ReadFileIntoObject(const std::string& Filename, IArchive& Object, ui32_t max_size = 8 * Kumu::Megabyte);
 214
 215   // Archives an object into a file
 216   Result_t WriteObjectIntoFile(const IArchive& Object, const std::string& Filename);
 217
 218   //
 219   class FileReader
 220     {
 221       KM_NO_COPY_CONSTRUCT(FileReader);
 222
 223     protected:
 224       std::string m_Filename;
 225       FileHandle  m_Handle;
 226
 227     public:
 228       FileReader() : m_Handle(INVALID_HANDLE_VALUE) {}
 229       virtual ~FileReader() { Close(); }
 230
 231       Result_t OpenRead(const char*) const;                          // open the file for reading
 232       Result_t Close() const;                                        // close the file
 233       fsize_t  Size() const;                                         // returns the file's current size
 234       Result_t Seek(Kumu::fpos_t = 0, SeekPos_t = SP_BEGIN) const;   // move the file pointer
 235       Result_t Tell(Kumu::fpos_t* pos) const;                        // report the file pointer's location
 236       Result_t Read(byte_t*, ui32_t, ui32_t* = 0) const;             // read a buffer of data
 237
 238       inline Kumu::fpos_t Tell() const                               // report the file pointer's location
 239         {
 240           Kumu::fpos_t tmp_pos;
 241           Tell(&tmp_pos);
 242           return tmp_pos;
 243         }
 244
 245       inline bool IsOpen() {                                         // returns true if the file is open
 246         return (m_Handle != INVALID_HANDLE_VALUE);
 247       }
 248     };
 249
 250   //
 251   class FileWriter : public FileReader
 252     {
 253       class h__iovec;
 254       mem_ptr<h__iovec>  m_IOVec;
 255       KM_NO_COPY_CONSTRUCT(FileWriter);
 256
 257     public:
 258       FileWriter();
 259       virtual ~FileWriter();
 260
 261       Result_t OpenWrite(const char*);                               // open a new file, overwrites existing
 262       Result_t OpenModify(const char*);                              // open a file for read/write
 263
 264       // this part of the interface takes advantage of the iovec structure on
 265       // platforms that support it. For each call to Writev(const byte_t*, ui32_t, ui32_t*),
 266       // the given buffer is added to an internal iovec struct. All items on the list
 267       // are written to disk by a call to Writev();
 268       Result_t Writev(const byte_t*, ui32_t);                       // queue buffer for "gather" write
 269       Result_t Writev(ui32_t* = 0);                                 // write all queued buffers
 270
 271       // if you call this while there are unwritten items on the iovec list,
 272       // the iovec list will be written to disk before the given buffer,as though
 273       // you had called Writev() first.
 274       Result_t Write(const byte_t*, ui32_t, ui32_t* = 0);            // write buffer to disk
 275    };
 276
 277 } // namespace Kumu
 278
 279
 280 #endif // _KM_FILEIO_H_
 281
 282
 283 //
 284 // end KM_fileio.h
 285 //