passwordfile.h

Go to the documentation of this file.

#ifndef PASSWORD_FILE_IO_PASSWORD_FILE_H
#define PASSWORD_FILE_IO_PASSWORD_FILE_H
 
#include "../global.h"
 
#include <c++utilities/io/binaryreader.h>
#include <c++utilities/io/binarywriter.h>
#include <c++utilities/io/nativefilestream.h>
#include <c++utilities/misc/flagenumclass.h>
 
#include <cstdint>
#include <memory>
#include <string>
 
namespace Io {
 
class NodeEntry;
 
enum class PasswordFileOpenFlags : std::uint64_t {
    None = 0,
    ReadOnly = 1,
    Default = None,
};
 
PASSWORD_FILE_EXPORT std::string flagsToString(PasswordFileOpenFlags flags);
 
enum class PasswordFileSaveFlags : std::uint64_t {
    None = 0,
    Encryption = (1 << 0),
    Compression = (1 << 1),
    PasswordHashing = (1 << 2),
    AllowToCreateNewFile = (1 << 3),
    Default = Encryption | Compression | PasswordHashing | AllowToCreateNewFile,
};
 
PASSWORD_FILE_EXPORT std::string flagsToString(PasswordFileSaveFlags flags);
 
class PASSWORD_FILE_EXPORT PasswordFile {
public:
    explicit PasswordFile();
    explicit PasswordFile(const std::string &path, const std::string &password);
    PasswordFile(const PasswordFile &other);
    PasswordFile(PasswordFile &&other);
    ~PasswordFile();
    CppUtilities::NativeFileStream &fileStream();
    void open(PasswordFileOpenFlags options = PasswordFileOpenFlags::Default);
    void opened();
    void generateRootEntry();
    void create();
    void close();
    void load();
    std::uint32_t mininumVersion(PasswordFileSaveFlags options) const;
    void save(PasswordFileSaveFlags options = PasswordFileSaveFlags::Default);
    void write(PasswordFileSaveFlags options = PasswordFileSaveFlags::Default);
    void clearEntries();
    void clear();
    void exportToTextfile(const std::string &targetPath) const;
    void doBackup();
    bool hasRootEntry() const;
    const NodeEntry *rootEntry() const;
    NodeEntry *rootEntry();
    const std::string &path() const;
    const std::string &password() const;
    void setPath(const std::string &value);
    void clearPath();
    void setPassword(const std::string &password);
    void setPassword(const char *password, const std::size_t passwordSize);
    void clearPassword();
    bool isEncryptionUsed();
    bool isOpen() const;
    std::string &extendedHeader();
    const std::string &extendedHeader() const;
    std::string &encryptedExtendedHeader();
    const std::string &encryptedExtendedHeader() const;
    std::size_t size();
    std::uint32_t version() const;
    PasswordFileOpenFlags openOptions() const;
    PasswordFileSaveFlags saveOptions() const;
    std::string summary(PasswordFileSaveFlags saveOptions) const;
 
private:
    std::string m_path;
    std::string m_password;
    std::unique_ptr<NodeEntry> m_rootEntry;
    std::string m_extendedHeader;
    std::string m_encryptedExtendedHeader;
    CppUtilities::NativeFileStream m_file;
    CppUtilities::BinaryReader m_freader;
    CppUtilities::BinaryWriter m_fwriter;
    std::uint32_t m_version;
    PasswordFileOpenFlags m_openOptions;
    PasswordFileSaveFlags m_saveOptions;
};

inline CppUtilities::NativeFileStream &PasswordFile::fileStream()
{
    return m_file;
}

inline const std::string &PasswordFile::path() const
{
    return m_path;
}

inline void PasswordFile::clearPath()
{
    close();
    m_path.clear();
}

inline const std::string &PasswordFile::password() const
{
    return m_password;
}

inline void PasswordFile::setPassword(const std::string &password)
{
    m_password = password;
}

inline void PasswordFile::setPassword(const char *password, const size_t passwordSize)
{
    m_password.assign(password, passwordSize);
}

inline void PasswordFile::clearPassword()
{
    m_password.clear();
}

inline bool PasswordFile::isOpen() const
{
    return m_file.is_open();
}

inline std::string &PasswordFile::extendedHeader()
{
    return m_extendedHeader;
}

inline const std::string &PasswordFile::extendedHeader() const
{
    return m_extendedHeader;
}

inline std::string &PasswordFile::encryptedExtendedHeader()
{
    return m_encryptedExtendedHeader;
}

inline const std::string &PasswordFile::encryptedExtendedHeader() const
{
    return m_encryptedExtendedHeader;
}

inline std::uint32_t PasswordFile::version() const
{
    return m_version;
}

inline PasswordFileOpenFlags PasswordFile::openOptions() const
{
    return m_openOptions;
}

inline PasswordFileSaveFlags PasswordFile::saveOptions() const
{
    return m_saveOptions;
}
 
} // namespace Io
 
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(Io, Io::PasswordFileOpenFlags);
CPP_UTILITIES_MARK_FLAG_ENUM_CLASS(Io, Io::PasswordFileSaveFlags);
 
#endif // PASSWORD_FILE_IO_PASSWORD_FILE_H