CUPathname.h

//
//  CUPathname.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for an abstract pathname.  This pathname
//  provides a cross-platform way to create directories and access files.
//  It is used by all of the other I/O classes.
//
//  Because pathnames are intended to be on the stack, we do not provide any
//  shared pointer support in this class.
//
//  This module is heavily inspired by the Java File class.  Much of the API
//  is taken from that class.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 11/22/16
//
#ifndef __CU_PATHNAME_H__
#define __CU_PATHNAME_H__
#include <string>
#include <vector>
#include <functional>

namespace cugl {

#pragma mark -
#pragma mark Pathname

class Pathname {
private:
    std::string _shortname;
    std::string _pathname;
    std::string _fullpath;
    
#pragma mark Normalization

    static std::string normalize(const std::string& path);

    static std::string canonicalize(const std::string& path);

    static bool isAbsolute(const std::string& path);

    
#pragma mark -
#pragma mark Constructors

    Pathname() {}

public:
    Pathname(const Pathname& copy);

    Pathname(Pathname&& copy) noexcept;

    Pathname(const std::string& path);

    Pathname(const char* path) : Pathname(std::string(path)) {}
    
    Pathname(const std::string& parent, const std::string& child);
    
    Pathname(const char* parent, const std::string& child) : Pathname(std::string(parent),child) {}
    
    Pathname(const std::string& parent, const char* child) : Pathname(parent,std::string(child)) {}
    
    Pathname(const char* parent, const char* child) : Pathname(std::string(parent),std::string(child)) {}

    Pathname(const Pathname& parent, const std::string& child);
    
    Pathname(const Pathname& parent, const char* child) : Pathname(parent,std::string(child)) {}
    
    ~Pathname() {}

    
#pragma mark -
#pragma mark Path Types

    bool exists() const;
    
    bool isDirectory() const;
    
    bool isFile() const;

    bool isHidden() const { return exists() && _shortname[0] == '.'; }
    
    
#pragma mark -
#pragma mark Path Names

    bool isAbsolute() const { return _pathname == _fullpath; }
    
    std::string getName() const { return _shortname; }

    std::string getPathname() const { return _pathname; }

    std::string getParentName() const;
    
    Pathname getParentPath() const;
    
    std::string getAbsoluteName() const { return _fullpath; }

    Pathname getAbsolutePath() const;
    
    std::string getSuffix() const;
    
    
#pragma mark -
#pragma mark Path Hierarchy

    std::string getVolume() const;

    static std::string getSeparator();

    std::vector<std::string> getComponents() const;
    
    std::vector<std::string> list() const;
    
    std::vector<std::string> list(const std::function<bool(const std::string& file)>& filter) const;

    std::vector<Pathname> listPaths() const;
    
    std::vector<Pathname> listPaths(const std::function<bool(const Pathname& path)>& filter) const;
    

#pragma mark -
#pragma mark Path Creation

    bool createFile();

    bool deleteFile();

    bool createDirectory();
    
    bool deleteDirectory();
    
    bool createPath();
    
    bool renameTo(const std::string& path)  {
        return renameTo(Pathname(path));
    }

    bool renameTo(const char* path) {
        return renameTo(Pathname(path));
    }

    bool renameTo(const Pathname& dest);
    
    
#pragma mark -
#pragma mark Path Access

    bool canRead();

    bool canSearch();

    bool canWrite();

    bool setReadable(bool readable);
    
    bool setReadable(bool readable, bool ownerOnly);
    
    bool setReadOnly();

    bool setSearchable(bool searchable);
    
    bool setSearchable(bool searchable, bool ownerOnly);

    bool setWritable(bool writable);
    
    bool setWritable(bool writable, bool ownerOnly);
    

    
#pragma mark -
#pragma mark Path Size

    size_t length() const;

    long lastModified() const;
    
    size_t getFreeSpace() const;

    size_t getAvailableSpace() const;

    size_t getTotalSpace() const;

    
#pragma mark -
#pragma mark Path Operators

    bool operator<(const Pathname& other) const {
        return getAbsoluteName() < other.getAbsoluteName();
    }
    
    bool operator<=(const Pathname& other) const {
        return getAbsoluteName() <= other.getAbsoluteName();
    }
    
    bool operator>(const Pathname& other) const {
        return getAbsoluteName() > other.getAbsoluteName();
    }

    bool operator>=(const Pathname& other) const {
        return getAbsoluteName() >= other.getAbsoluteName();
    }

    bool operator==(const Pathname& other) const {
        return getAbsoluteName() == other.getAbsoluteName();
    }

    bool operator!=(const Pathname& other) const{
        return getAbsoluteName() != other.getAbsoluteName();
    }
    
};

}
#endif /* __CU_PATHNAME_H__ */