266 lines
7.1 KiB
C++
266 lines
7.1 KiB
C++
#include "./basicfileinfo.h"
|
|
|
|
#include <c++utilities/conversion/stringconversion.h>
|
|
|
|
using namespace std;
|
|
using namespace CppUtilities;
|
|
|
|
/*!
|
|
* \brief Contains all classes and functions of the TagInfo library.
|
|
*/
|
|
namespace TagParser {
|
|
/*!
|
|
* \class BasicFileInfo
|
|
* \brief The BasicFileInfo class provides basic file information such as
|
|
* file name, extension, directory and size for a specified file.
|
|
*/
|
|
|
|
/*!
|
|
* \brief Constructs a new BasicFileInfo for the specified file.
|
|
*
|
|
* \param path Specifies the absolute or relative path of the file.
|
|
*/
|
|
BasicFileInfo::BasicFileInfo()
|
|
: m_size(0)
|
|
, m_readOnly(false)
|
|
{
|
|
m_file.exceptions(ios_base::failbit | ios_base::badbit);
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new BasicFileInfo for the specified file.
|
|
*
|
|
* \param path Specifies the absolute or relative path of the file.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
* \brief Constructs a new BasicFileInfo for the specified file.
|
|
*
|
|
* \param path Specifies the absolute or relative path of the file.
|
|
*/
|
|
BasicFileInfo::BasicFileInfo(std::string_view path)
|
|
: m_path(path)
|
|
, m_size(0)
|
|
, m_readOnly(false)
|
|
{
|
|
m_file.exceptions(ios_base::failbit | ios_base::badbit);
|
|
}
|
|
|
|
/*!
|
|
* \brief Destroys the BasicFileInfo.
|
|
*
|
|
* A possibly opened std::fstream will be closed.
|
|
*/
|
|
BasicFileInfo::~BasicFileInfo()
|
|
{
|
|
close();
|
|
}
|
|
|
|
/*!
|
|
* \brief Opens a std::fstream for the current file. Does nothing a stream is already open.
|
|
* \param readOnly Indicates whether the stream should be opend as read-only.
|
|
* \throws Throws std::ios_base::failure when an IO error occurs.
|
|
*/
|
|
void BasicFileInfo::open(bool readOnly)
|
|
{
|
|
if (!isOpen()) {
|
|
reopen(readOnly);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Opens a std::fstream for the current file. Closes a possibly already opened stream and
|
|
* clears all flags before.
|
|
* \param readOnly Indicates whether the stream should be opend as read-only.
|
|
* \throws Throws std::ios_base::failure when an IO error occurs.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
* \brief A possibly opened std::fstream will be closed. All flags of the stream will be cleared.
|
|
*/
|
|
void BasicFileInfo::close()
|
|
{
|
|
if (isOpen()) {
|
|
m_file.close();
|
|
}
|
|
m_file.clear();
|
|
}
|
|
|
|
/*!
|
|
* \brief Invalidates the file info manually.
|
|
*/
|
|
void BasicFileInfo::invalidate()
|
|
{
|
|
invalidated();
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the current file.
|
|
*
|
|
* A possibly opened std::fstream will be closed and invalidated() will be called.
|
|
*
|
|
* \param path Specifies the absolute or relative path of the file to be set.
|
|
*/
|
|
void BasicFileInfo::setPath(std::string_view path)
|
|
{
|
|
if (path != m_path) {
|
|
invalidated();
|
|
m_path = path;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Sets the current file.
|
|
*
|
|
* A possibly opened std::fstream will be closed and invalidated() will be called.
|
|
*
|
|
* \param path Specifies the absolute or relative path of the file to be set.
|
|
*/
|
|
void BasicFileInfo::setPath(std::string &&path)
|
|
{
|
|
if (path != m_path) {
|
|
invalidated();
|
|
m_path = path;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the file name of the given file.
|
|
*
|
|
* \param path Specifies the path of the file.
|
|
* \param cutExtension Indicates whether the extension/suffix should be cut.
|
|
*/
|
|
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));
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the file name of the current file.
|
|
*
|
|
* \param cutExtension Indicates whether the extension should be cut.
|
|
*/
|
|
std::string BasicFileInfo::fileName(bool cutExtension) const
|
|
{
|
|
return fileName(m_path, cutExtension);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the extension of the given file.
|
|
*
|
|
* \param path Specifies the path of the file.
|
|
*/
|
|
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);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the extension of the current file.
|
|
*/
|
|
std::string BasicFileInfo::extension() const
|
|
{
|
|
return extension(m_path);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns a copy of the given path without the extension/suffix.
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the path of the current file without the extension/suffix.
|
|
*/
|
|
std::string BasicFileInfo::pathWithoutExtension() const
|
|
{
|
|
return pathWithoutExtension(m_path);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the path of the directory containing the given file.
|
|
*/
|
|
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();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the path of the directory containing the current file.
|
|
*
|
|
* The returned path is relative if the path of the file (specified using
|
|
* the setPath() method) is relative.
|
|
*/
|
|
string BasicFileInfo::containingDirectory() const
|
|
{
|
|
return containingDirectory(m_path);
|
|
}
|
|
|
|
/*!
|
|
* \brief This function is called when the BasicFileInfo gets invalidated.
|
|
* This is the case when the current file changes or is reopened.
|
|
*
|
|
* When subclassing and overwriting this virtual method invoke the base
|
|
* implementation by calling BasicFileInfo::invalidated() before the reimplemented code.
|
|
*/
|
|
void BasicFileInfo::invalidated()
|
|
{
|
|
m_size = 0;
|
|
close();
|
|
}
|
|
|
|
} // namespace TagParser
|