TarEntry.h

/* Copyright (C) 2008 Marc Boris Duerner
   SPDX-License-Identifier: LGPL-2.1-or-later WITH mif-exception
*/
 
#ifndef PT_SYSTEM_TAR_ENTRY_H
#define PT_SYSTEM_TAR_ENTRY_H
 
#include <Pt/System/Api.h>
#include <Pt/System/FileInfo.h>
#include <Pt/System/Path.h>
#include <Pt/DateTime.h>
#include <Pt/String.h>
#include <Pt/Types.h>
 
#include <cstddef>
 
namespace Pt {
 
namespace System {

class TarEntry
{
  public:
    enum Type
    {
        Invalid   = 0, 
        File      = 1, 
        Directory = 2, 
        Link      = 3, 
        Hardlink  = 4  
    };

    static const Pt::uint32_t NoId = static_cast<Pt::uint32_t>(-1);
 
  public:
    TarEntry() = default;

    TarEntry(TarEntry&&) = default;

    TarEntry& operator=(TarEntry&&) = default;

    ~TarEntry() = default;

    void clear()
    { *this = TarEntry(); }

    bool isEnd() const
    { return _avail == _remaining; }

    const Pt::System::Path& path() const
    { return _path; }

    std::size_t size() const
    { return _size; }

    std::size_t avail() const
    { return _avail; }

    const char* data() const
    { return _data; }

    Type type() const
    { return _type; }

    const Pt::System::Path& linkTarget() const
    { return _linkTarget; }

    Pt::System::FileInfo::Perms permissions() const
    { return _permissions; }

    const Pt::DateTime& mtime() const
    { return _mtime; }

    Pt::uint32_t ownerId() const
    { return _ownerId; }

    const Pt::String& ownerName() const
    { return _ownerName; }

    Pt::uint32_t groupId() const
    { return _groupId; }

    const Pt::String& groupName() const
    { return _groupName; }

    void setPath(const Pt::System::Path& path)
    { _path = path; }

    void setSize(std::size_t size)
    { _size = size; }

    void setType(Type type)
    { _type = type; }

    void setLinkTarget(const Pt::System::Path& target)
    { _linkTarget = target; }

    void setPermissions(Pt::System::FileInfo::Perms permissions)
    { _permissions = permissions; }

    void setMtime(const Pt::DateTime& mtime)
    { _mtime = mtime; }

    void setOwnerId(Pt::uint32_t id)
    { _ownerId = id; }

    void setOwnerName(const Pt::String& name)
    { _ownerName = name; }

    void setGroupId(Pt::uint32_t id)
    { _groupId = id; }

    void setGroupName(const Pt::String& name)
    { _groupName = name; }

    void setContent(const char* data, std::size_t avail, std::size_t remaining)
    {
        _data = data;
        _avail = avail;
        _remaining = remaining;
    }
 
  private:
    TarEntry(const TarEntry&) = delete;
 
    TarEntry& operator=(const TarEntry&) = delete;
 
  private:
    Pt::System::Path            _path;
    std::size_t                 _size = 0;
    std::size_t                 _remaining = 0;
    std::size_t                 _avail = 0;
    const char*                 _data = 0;
    Type                        _type = Invalid;
    Pt::System::Path            _linkTarget;
    Pt::System::FileInfo::Perms _permissions = Pt::System::FileInfo::NoPerms;
    Pt::DateTime                _mtime;
    Pt::uint32_t                _ownerId = NoId;
    Pt::String                  _ownerName;
    Pt::uint32_t                _groupId = NoId;
    Pt::String                  _groupName;
};
 
} // namespace System
 
} // namespace Pt
 
#endif // PT_SYSTEM_TAR_ENTRY_H