dir.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_dir_h
#define INCL_evo_dir_h

#include "impl/sysio_dir.h"
#include "filepath.h"

#if defined(_WIN32)
    #include "ustring.h"
#endif

// Namespace: evo
namespace evo {


inline String& get_cwd(String& outpath) {
#if defined(_WIN32)
    outpath.set();
    DWORD sz = ::GetCurrentDirectory(0, NULL);
    if (sz > 0 && (sz = ::GetCurrentDirectory(sz, outpath.advBuffer(sz))) > 0)
        outpath.advSize(sz);
    else
        outpath = "C:\\"; // unknown so guess C drive root
#else
    const size_t DEFAULT_BUF_SIZE = 512;
    for (size_t sz = DEFAULT_BUF_SIZE;; sz *= 2) {
        outpath.set().reserve(sz);
        const char* p = ::getcwd(outpath.advBuffer(sz), sz);
        if (p != NULL) {
            assert( p == outpath.data() );
            outpath.advSize(strlen(p));
            break;
        } else if (errno != ERANGE) {
            outpath = "/"; // unknown so use root
            break;
        }
    }
#endif
    return outpath;
}

inline Error set_cwd(const char* path, bool excep=EVO_EXCEPTIONS) {
    Error err = ENone;
#if defined(_WIN32)
    if (::SetCurrentDirectory(path) != 0)
        return ENone;
    err = EFail;
#else
    if (::chdir(path) == 0)
        return ENone;
    const int code = errno;
    switch (code) {
        case EACCES:       err = EAccess;    break;
        case EFAULT:       err = EPtr;       break;
        case ELOOP:        // fallthrough
        case ENAMETOOLONG: err = ESize;      break;
        case ENOENT:       err = ENotFound;  break;
        case ENOTDIR:      err = ENotDir;    break;
        default:           err = EFail;      break;
    }
#endif
    EVO_THROW_ERR_CHECK(evo::Exception, "Error setting working directory", err, excep);
    return err;
}

inline String& get_abspath(String& outpath, SubString& path) {
    if (path.null()) {
        return outpath.set();
    } else if (FilePath::abs(path, false)) {
        outpath = path;
    } else {
        get_cwd(outpath);
        FilePath::join(outpath, path);
    }
    return FilePath::normalize(outpath, outpath);
}


class ExceptionDirOpen : public Exception
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionDirOpen, Exception) };


class Directory : public SafeBool<Directory> {
public:
    Directory(bool excep=EVO_EXCEPTIONS) : excep_(excep) {
    }

    Directory(const char* path, bool excep=EVO_EXCEPTIONS) : excep_(excep) {
        open(path);
    }

    bool operator!() const {
        return (error_ != ENone);
    }

    bool excep() const {
        return excep_;
    }

    void excep(bool val) {
        excep_ = val;
    }

    Error error() const {
        return error_;
    }

    bool isopen() const {
        return (dir_.handle != NULL);
    }

    bool open(const char* path) {
        error_ = dir_.open(path);
        EVO_THROW_ERR_CHECK(evo::ExceptionDirOpen, "Directory::open() failed", error_, (excep_ && error_ != ENone));
        return error_ == ENone;
    }

    void close() {
        dir_.close();
        error_ = ENone;
    }

    void seek() {
        dir_.seek();
    }

    bool read(SubString& entry) {
        return dir_.read(entry);
    }

#if !defined(_WIN32) || defined(DOXYGEN)

    bool chdir() {
        return dir_.chdir();
    }
#endif

private:
    // Disable copying
    Directory(const Directory&) EVO_ONCPP11(= delete);
    Directory& operator=(const Directory&) EVO_ONCPP11(= delete);

    SysDir dir_;        
    Error error_;       
    bool  excep_;       
};


}
#endif