basicfileinfo.cpp

Go to the documentation of this file.

#include "./basicfileinfo.h"
 
#include <c++utilities/conversion/stringconversion.h>
 
using namespace std;
using namespace CppUtilities;
 
namespace TagParser {
BasicFileInfo::BasicFileInfo()
    : m_size(0)
    , m_readOnly(false)
{
    m_file.exceptions(ios_base::failbit | ios_base::badbit);
}
 
BasicFileInfo::BasicFileInfo(std::string &&path)
    : m_path(std::move(path))
    , m_size(0)
    , m_readOnly(false)
{
    m_file.exceptions(ios_base::failbit | ios_base::badbit);
}
 
BasicFileInfo::BasicFileInfo(std::string_view path)
    : m_path(path)
    , m_size(0)
    , m_readOnly(false)
{
    m_file.exceptions(ios_base::failbit | ios_base::badbit);
}
 
BasicFileInfo::~BasicFileInfo()
{
    close();
}
 
void BasicFileInfo::open(bool readOnly)
{
    if (!isOpen()) {
        reopen(readOnly);
    }
}
 
void BasicFileInfo::reopen(bool readOnly)
{
    invalidated();
    m_file.open(
        pathForOpen(path()).data(), (m_readOnly = readOnly) ? ios_base::in | ios_base::binary : ios_base::in | ios_base::out | ios_base::binary);
    m_file.seekg(0, ios_base::end);
    m_size = static_cast<std::uint64_t>(m_file.tellg());
    m_file.seekg(0, ios_base::beg);
}
 
void BasicFileInfo::close()
{
    if (isOpen()) {
        m_file.close();
    }
    m_file.clear();
}
 
void BasicFileInfo::invalidate()
{
    invalidated();
}
 
void BasicFileInfo::setPath(std::string_view path)
{
    if (path != m_path) {
        invalidated();
        m_path = path;
    }
}
 
void BasicFileInfo::setPath(std::string &&path)
{
    if (path != m_path) {
        invalidated();
        m_path = path;
    }
}
 
std::string BasicFileInfo::fileName(std::string_view path, bool cutExtension)
{
    const auto lastSlash = path.rfind('/');
    const auto lastBackSlash = path.rfind('\\');
    const auto lastPoint = cutExtension ? path.rfind('.') : string::npos;
    auto lastSeparator = decltype(lastSlash)();
    if (lastSlash == string::npos && lastBackSlash == string::npos) {
        return std::string(lastPoint == string::npos ? path : path.substr(0, lastPoint));
    } else if (lastSlash == string::npos) {
        lastSeparator = lastBackSlash;
    } else if (lastBackSlash == string::npos) {
        lastSeparator = lastSlash;
    } else {
        lastSeparator = lastSlash > lastBackSlash ? lastSlash : lastBackSlash;
    }
    return std::string(lastPoint != string::npos ? path.substr(lastSeparator + 1, lastPoint - lastSeparator - 1) : path.substr(lastSeparator + 1));
}
 
std::string BasicFileInfo::fileName(bool cutExtension) const
{
    return fileName(m_path, cutExtension);
}
 
std::string BasicFileInfo::extension(std::string_view path)
{
    const auto lastPoint = path.rfind('.');
    if (lastPoint == std::string::npos) {
        return std::string();
    } else {
        return std::string(path.data() + lastPoint, path.size() - lastPoint);
    }
}
 
std::string BasicFileInfo::extension() const
{
    return extension(m_path);
}
 
std::string BasicFileInfo::pathWithoutExtension(std::string_view fullPath)
{
    const auto lastPoint = fullPath.rfind('.');
    return std::string(lastPoint != std::string::npos ? fullPath.substr(0, lastPoint) : fullPath);
}
 
std::string BasicFileInfo::pathWithoutExtension() const
{
    return pathWithoutExtension(m_path);
}
 
std::string BasicFileInfo::containingDirectory(std::string_view path)
{
    const auto lastSlash = path.rfind('/');
    const auto lastBackSlash = path.rfind('\\');
    auto lastSeparator = decltype(lastSlash)();
    if (lastSlash == string::npos && lastBackSlash == std::string::npos) {
        return std::string();
    } else if (lastSlash == string::npos) {
        lastSeparator = lastBackSlash;
    } else if (lastBackSlash == string::npos) {
        lastSeparator = lastSlash;
    } else {
        lastSeparator = lastSlash > lastBackSlash ? lastSlash : lastBackSlash;
    }
    if (lastSeparator > 0) {
        return std::string(path.substr(0, lastSeparator));
    } else {
        return std::string();
    }
}
 
string BasicFileInfo::containingDirectory() const
{
    return containingDirectory(m_path);
}
 
void BasicFileInfo::invalidated()
{
    m_size = 0;
    close();
}
 
} // namespace TagParser