al_File.hpp

#ifndef INCLUDE_AL_FILE_HPP
#define INCLUDE_AL_FILE_HPP
 
/*  Allocore --
        Multimedia / virtual environment application class library
 
        Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology,
   UCSB. Copyright (C) 2012. The Regents of the University of California. All
   rights reserved.
 
        Redistribution and use in source and binary forms, with or without
        modification, are permitted provided that the following conditions are
   met:
 
                Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 
                Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following disclaimer in the
                documentation and/or other materials provided with the
   distribution.
 
                Neither the name of the University of California nor the names
   of its contributors may be used to endorse or promote products derived from
                this software without specific prior written permission.
 
        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
        File description:
        Utilities for file management
 
        File author(s):
        Graham Wakefield, 2010, grrrwaaa@gmail.com
        Lance Putnam, 2010, putnam.lance@gmail.com
        Keehong Youn, 2017, younkeehong@gmail.com
*/
 
#include <stdio.h>
 
#include <algorithm>
#include <functional>
#include <iostream>
#include <list>
#include <mutex>
#include <string>
#include <vector>
 
#ifndef AL_FILE_DELIMITER_STR
#ifdef AL_WINDOWS
#define AL_FILE_DELIMITER_STR "\\"
#else
#define AL_FILE_DELIMITER_STR "/"
#endif
#endif
 
#define AL_FILE_DELIMITER (AL_FILE_DELIMITER_STR[0])
 
#define AL_PATH_MAX (4096)
 
typedef long long int
    al_nsec;           
typedef double al_sec; 
namespace al {
 
std::string demangle(const char *name); // Utility function.
class FilePath {
public:
  FilePath() {}
 
  FilePath(const std::string &file, const std::string &path);
 
  explicit FilePath(const std::string &fullpath);
 
  const std::string &file() const { return mFile; }
 
  const std::string &path() const { return mPath; }
 
  std::string filepath() const { return path() + file(); }
 
  bool valid() const { return file() != ""; }
 
  FilePath &file(const std::string &v) {
    mFile = v;
    return *this;
  }
 
  FilePath &path(const std::string &v) {
    mPath = v;
    return *this;
  }
 
protected:
  std::string mPath;
  std::string mFile;
};
 
#if 0 /* commenting out FileInfo */
class FileInfo{
public:
 
    enum Type{
        NOFILE,             
        REG,                
        DIR,                
        CHR,                
        BLOCK,              
        PIPE,               
        LINK,               
        SOCKET,             
        UNKNOWN = 127       
    };
 
    FileInfo& type(Type v){ mType=v; return *this; }
 
    const Type type() const { return mType; }
 
    FileInfo& name(const std::string& v){ mName=v; return *this; }
 
    const std::string& name() const { return mName; }
 
private:
    Type mType;
    std::string mName;
};
#endif /* commenting out FileInfo */
 
 
class File {
public:
  File(std::string path = ".", std::string mode = "r", bool open_ = false);
  File(const FilePath &path, std::string mode = "r", bool open_ = false);
 
  ~File();
 
 
  bool open(const std::string &path, const std::string &mode = "r");
 
 
  bool open();
 
  void close();
 
 
  File &mode(const std::string &v) {
    mMode = v;
    return *this;
  }
 
  File &path(const std::string &v) {
    mPath = v;
    return *this;
  }
 
  int write(const std::string &v) {
    return write(v.data(), 1, static_cast<int>(v.length()));
  }
 
  int write(const void *v, int itemSizeInBytes, int items = 1) {
    int itemsWritten = static_cast<int>(fwrite(v, itemSizeInBytes, items, mFP));
    mSizeBytes += itemsWritten * itemSizeInBytes;
    return itemsWritten;
  }
 
  int read(void *v, int size, int items = 1) {
    return static_cast<int>(fread(v, size, items, mFP));
  }
 
  const char *readAll();
 
  bool opened() const { return 0 != mFP; }
 
  const std::string &mode() const { return mMode; }
 
  const std::string &path() const { return mPath; }
 
  size_t size() const { return mSizeBytes; }
 
  // al_sec modified() const;
 
  // al_sec accessed() const;
 
  // al_sec created() const;
 
  // size_t sizeFile() const;
 
  // size_t storage() const;
 
  FILE *filePointer() { return mFP; }
 
  static std::string read(const std::string &path);
 
  static int write(const std::string &path, const void *v, int size,
                   int items = 1);
 
  static int write(const std::string &path, const std::string &data);
 
  static bool copy(const std::string &srcPath, const std::string &dstPath,
                   unsigned int bufferSize = 1e6);
 
  static bool remove(const std::string &path);
 
 
  static std::string conformDirectory(const std::string &dir);
 
 
  static std::string conformPathToOS(const std::string &path);
 
  static std::string absolutePath(const std::string &path);
 
  static bool isRelativePath(const std::string &path);
 
  static std::string currentPath();
 
  static bool isSamePath(const std::string &path1, const std::string &path2);
 
 
  static std::string baseName(const std::string &path,
                              const std::string &suffix = "");
 
 
  static std::string directory(const std::string &path);
 
 
  static std::string extension(const std::string &path);
 
  static bool exists(const std::string &path);
 
  static bool exists(const std::string &name, const std::string &path) {
    return exists(path + name);
  }
 
  static bool isDirectory(const std::string &path);
 
 
  static bool searchBack(std::string &rootPath, const std::string &matchPath,
                         int maxDepth = 6);
 
  static bool searchBack(std::string &path, int maxDepth = 6);
 
  static al_sec modificationTime(const char *path);
  // TODO: Implement these.
  // static al_sec modified(const std::string& path){ return
  // File(path).modified(); } static al_sec accessed(const std::string& path){
  // return File(path).accessed(); } static al_sec created (const std::string&
  // path){ return File(path).created(); } static size_t sizeFile(const
  // std::string& path){ return File(path).sizeFile(); } static size_t storage
  // (const std::string& path){ return File(path).storage(); }
 
protected:
  // class Impl; Impl * mImpl;
 
  std::string mPath;
  std::string mMode;
  char *mContent;
  size_t mSizeBytes;
  FILE *mFP;
 
  void dtor();
  void freeContent();
  void allocContent(int n);
  void getSize();
 
  friend class Dir;
};
 
class PushDirectory {
public:
  PushDirectory(std::string directory, bool verbose = false);
 
  ~PushDirectory();
 
private:
  char previousDirectory[4096];
  bool mVerbose;
 
  static std::mutex mDirectoryLock; // Protects all instances of PushDirectory
};
 
class Dir {
public:
  // Dir() {};
 
  // Dir(std::string dirToOpen): mDirToOpen(dirToOpen) {};
 
  // ~Dir() = default;
 
 
  // bool open(const std::string& dirPath);
 
 
  // bool close();
 
 
  // bool read();
 
  // const FileInfo& entry() const { return mEntry; }
 
  // bool rewind();
 
  // static bool make(const std::string& path, bool recursive=true);
  static bool make(const std::string &path);
 
  static bool remove(const std::string &path);
 
  static bool removeRecursively(const std::string &path);
 
private:
  // class Impl; Impl * mImpl;
  // std::string mDirToOpen;
  // FileInfo mEntry;
};
 
class FileList {
public:
  typedef std::vector<FilePath>::iterator iterator;
 
  FileList() : indx(0) {}
 
  FilePath &operator()() { return mFiles[indx]; }
 
  // FilePath& select(const std::string& filename);
 
  FilePath &select(int i) {
    indx = i % count();
    return (*this)();
  }
  FilePath &next() {
    ++indx %= count();
    return (*this)();
  }
  FilePath &prev() {
    --indx;
    if (indx < 0)
      indx = count() - 1;
    return (*this)();
  }
 
  int count() { return static_cast<int>(mFiles.size()); }
 
  void sort();
 
  void print(std::ostream &stream = std::cout) const;
 
  FilePath &operator[](int i) { return mFiles[i]; }
  iterator begin() { return mFiles.begin(); }
  iterator end() { return mFiles.end(); }
 
  void add(FilePath &fp) { mFiles.push_back(fp); }
  void add(FilePath &&fp) { mFiles.push_back(fp); }
  void add(FileList const &fl) {
    mFiles.insert(mFiles.end(), fl.mFiles.begin(), fl.mFiles.end());
  }
  void sort(bool (*f)(FilePath, FilePath)) { std::sort(begin(), end(), f); }
 
protected:
  int indx;
  std::vector<FilePath> mFiles;
};
 
class SearchPaths {
public:
  typedef std::pair<std::string, bool> searchpath;
  typedef std::list<searchpath> searchpathlist;
  typedef std::list<searchpath>::iterator iterator;
 
  SearchPaths() {}
  SearchPaths(const std::string &file);
  SearchPaths(int argc, char *const argv[], bool recursive = true);
  SearchPaths(const SearchPaths &cpy);
 
  FilePath find(const std::string &filename);
  // FileList glob(const std::string& regex);
  FileList filter(bool (*f)(FilePath const &));
  FileList listAll();
 
  void addSearchPath(const std::string &path, bool recursive = true);
  void addRelativePath(std::string rel, bool recursive = true) {
    addSearchPath(appPath() + rel, recursive);
  }
 
  void addAppPaths(int argc, char *const argv[], bool recursive = true);
  void addAppPaths(int argc, const char **argv, bool recursive = true);
  void addAppPaths(std::string path, bool recursive = true);
  void addAppPaths(bool recursive = true);
 
  const std::string &appPath() const { return mAppPath; }
 
  void print(std::ostream &stream = std::cout) const;
 
  iterator begin() { return mSearchPaths.begin(); }
  iterator end() { return mSearchPaths.end(); }
 
protected:
  std::list<searchpath> mSearchPaths;
  std::string mAppPath;
};
 
// below are original to allolib and did not exist in AlloSystem
// TODO: NEED TO CLEAN THESE CALLS...
 
// not recursive, contains dirs
FileList itemListInDir(std::string const &dir);
 
// recursive, does not contain dirs
FileList fileListFromDir(std::string const &dir);
 
//
FilePath searchFileFromDir(std::string const &filename, std::string const &dir);
 
// pass lambda with given signature, returns list of files that f(file) is true
FileList filterInDir(std::string const &dir,
                     std::function<bool(FilePath const &)> f,
                     bool recursive = false);
 
// returns true if given file name/path ends in extension
bool checkExtension(std::string const &filename, std::string const &extension);
bool checkExtension(FilePath const &filepath, std::string const &extension);
 
} // namespace al
 
#endif