Loading...
Searching...
No Matches
list_entry.hpp
Go to the documentation of this file.
/*********************************************************************/
// dar - disk archive - a backup/restoration program
// Copyright (C) 2002-2024 Denis Corbin
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// to contact the author, see the AUTHOR file
/*********************************************************************/
#ifndef LIST_ENTRY_HPP
#define LIST_ENTRY_HPP
#include <string>
#include <set>
#include "../my_config.h"
#include "infinint.hpp"
#include "deci.hpp"
#include "compression.hpp"
#include "integers.hpp"
#include "datetime.hpp"
#include "range.hpp"
#include "cat_status.hpp"
#include "ea.hpp"
#include "fsa_family.hpp"
namespace libdar
{
class crc;
class list_entry
{
public:
list_entry() { clear(); };
list_entry(const list_entry & ref) = default;
list_entry(list_entry && ref) = default;
list_entry & operator = (const list_entry & ref) = default;
list_entry & operator = (list_entry && ref) noexcept = default;
~list_entry() = default;
bool is_eod() const { return type == 'z'; };
// methods for API users
// field that are not set are returned as empty string
const std::string & get_name() const { return my_name; };
unsigned char get_type() const { return type; };
bool is_dir() const { return type == 'd'; };
bool is_file() const { return type == 'f'; };
bool is_symlink() const { return type == 'l'; };
bool is_char_device() const { return type == 'c'; };
bool is_block_device() const { return type == 'b'; };
bool is_unix_socket() const { return type == 's'; };
bool is_named_pipe() const { return type == 'p'; };
bool is_hard_linked() const { return hard_link; };
bool is_removed_entry() const { return type == 'x'; };
bool is_door_inode() const { return type == 'o'; };
bool is_empty_dir() const { return empty_dir; };
unsigned char get_removed_type() const;
bool has_data_present_in_the_archive() const { return data_status == saved_status::saved || data_status == saved_status::delta; };
std::string get_data_flag() const;
saved_status get_data_status() const { return data_status; };
bool has_EA() const { return ea_status != ea_saved_status::none && ea_status != ea_saved_status::removed; };
bool has_EA_saved_in_the_archive() const { return ea_status == ea_saved_status::full; };
std::string get_ea_flag() const;
ea_saved_status get_ea_status() const { return ea_status; };
bool has_FSA() const { return fsa_status != fsa_saved_status::none; };
bool has_FSA_saved_in_the_archive() const { return fsa_status == fsa_saved_status::full; };
std::string get_fsa_flag() const;
std::string get_uid(bool try_resolving_name = false) const;
std::string get_gid(bool try_resolving_name = false) const;
std::string get_perm() const;
std::string get_last_access() const;
std::string get_last_modif() const;
std::string get_last_change() const;
std::string get_removal_date() const;
time_t get_last_access_s() const { return datetime2time_t(last_access); };
time_t get_last_modif_s() const;
time_t get_last_change_s() const { return datetime2time_t(last_change); };
time_t get_removal_date_s() const;
void get_last_access(datetime::time_unit tu, time_t & second, time_t & fraction) const
{ last_access.get_value(second, fraction, tu); }
void get_last_modif(datetime::time_unit tu, time_t & second, time_t & fraction) const
{ last_modif.get_value(second, fraction, tu); }
void get_last_change(datetime::time_unit tu, time_t & second, time_t & fraction) const
{ last_change.get_value(second, fraction, tu); }
std::string get_file_size(bool size_in_bytes = true) const;
std::string get_compression_ratio() const;
std::string get_compression_ratio_flag() const;
bool is_sparse() const { return sparse_file; };
std::string get_sparse_flag() const { return sparse_file ? "[X]" : "[ ]"; };
std::string get_compression_algo() const { return compression2string(compression_algo); };
bool is_dirty() const { return dirty; };
std::string get_link_target() const { return target; };
std::string get_major() const;
std::string get_minor() const;
const range & get_slices() const { return slices; };
bool has_delta_signature() const { return delta_sig; };
std::string get_delta_flag() const;
bool get_archive_offset_for_data(infinint & val) const { val = offset_for_data; return !val.is_zero(); };
bool get_archive_offset_for_data(U_64 & val) const;
std::string get_archive_offset_for_data() const { return offset_for_data.is_zero() ? "" : deci(offset_for_data).human(); };
bool get_storage_size_for_data(infinint & val) const { val = storage_size_for_data; return !val.is_zero(); };
bool get_storage_size_for_data(U_64 & val) const;
std::string get_storage_size_for_data(bool size_in_bytes = true) const;
bool get_archive_offset_for_EA(infinint & val) const { val = offset_for_EA; return !val.is_zero(); };
bool get_archive_offset_for_EA(U_64 & val) const;
std::string get_archive_offset_for_EA() const { return offset_for_EA.is_zero() ? "" : deci(offset_for_EA).human(); };
bool get_storage_size_for_EA(infinint & val) const { val = storage_size_for_EA; return !val.is_zero(); };
bool get_storage_size_for_EA(U_64 & val) const;
std::string get_storage_size_for_EA() const { return storage_size_for_EA.is_zero() ? "" : deci(storage_size_for_EA).human(); };
bool get_archive_offset_for_FSA(infinint & val) const { val = offset_for_FSA; return !val.is_zero(); };
bool get_archive_offset_for_FSA(U_64 & val) const;
std::string get_archive_offset_for_FSA() const { return offset_for_FSA.is_zero() ? "" : deci(offset_for_FSA).human(); };
bool get_storage_size_for_FSA(infinint & val) const { val = storage_size_for_FSA; return !val.is_zero(); };
bool get_storage_size_for_FSA(U_64 & val) const;
std::string get_storage_size_for_FSA() const { return storage_size_for_FSA.is_zero() ? "" : deci(storage_size_for_FSA).human(); };
void get_ea_reset_read() const { it_ea = ea.begin(); };
bool get_ea_read_next(std::string & key) const;
std::string get_etiquette() const { return deci(etiquette).human(); };
fsa_scope get_fsa_scope() const { return fsa_sc; };
std::string get_data_crc() const { return data_crc; };
std::string get_delta_patch_base_crc() const { return patch_base_crc; };
std::string get_delta_patch_result_crc() const { return patch_result_crc; };
// methods for libdar to setup the object
void set_name(const std::string & val) { my_name = val; };
void set_type(unsigned char val) { type = val; };
void set_removed_type(unsigned char val);
void set_hard_link(bool val) { hard_link = val; };
void set_uid(const infinint & val) { uid = val; };
void set_gid(const infinint & val) { gid = val; };
void set_perm(U_16 val) { perm = val; };
void set_last_access(const datetime & val) { last_access = val; };
void set_last_modif(const datetime & val) { last_modif = val; };
void set_removal_date(const datetime & val);
void set_saved_status(saved_status val) { data_status = val; };
void set_ea_status(ea_saved_status val) { ea_status = val; };
void set_last_change(const datetime & val) { last_change = val; };
void set_fsa_status(fsa_saved_status val) { fsa_status = val; };
void set_file_size(const infinint & val) { file_size = val; };
void set_is_sparse_file(bool val) { sparse_file = val; };
void set_compression_algo(compression val) { compression_algo = val; };
void set_dirtiness(bool val) { dirty = val; };
void set_link_target(const std::string & val) { target = val; };
void set_major(int val) { major = val; };
void set_minor(int val) { minor = val; };
void set_slices(const range & sl) { slices = sl; };
void set_delta_sig(bool val) { delta_sig = val; };
void set_archive_offset_for_data(const infinint & val) { offset_for_data = val; };
void set_storage_size_for_data(const infinint & val) { storage_size_for_data = val; };
void set_archive_offset_for_EA(const infinint & val) { offset_for_EA = val; };
void set_storage_size_for_EA(const infinint & val) { storage_size_for_EA = val; };
void set_archive_offset_for_FSA(const infinint & val) { offset_for_FSA = val; };
void set_storage_size_for_FSA(const infinint & val) { storage_size_for_FSA = val; };
void set_ea(const ea_attributs & arg);
void set_etiquette(const infinint & arg) { etiquette = arg; };
void set_fsa_scope(const fsa_scope & arg) { fsa_sc = arg; };
void set_data_crc(const crc & ptr);
void set_delta_patch_base_crc(const crc & ptr);
void set_delta_patch_result_crc(const crc & ptr);
void set_empty_dir(bool val) { if(!is_dir()) throw SRC_BUG; empty_dir = val; };
void clear();
private:
std::string my_name;
bool hard_link;
unsigned char type;
infinint uid;
infinint gid;
U_16 perm;
datetime last_access;
datetime last_modif;
saved_status data_status;
ea_saved_status ea_status;
datetime last_change;
fsa_saved_status fsa_status;
fsa_scope fsa_sc;
infinint file_size;
bool sparse_file;
compression compression_algo;
bool dirty;
std::string target;
int major;
int minor;
range slices;
bool delta_sig;
infinint offset_for_data;
infinint storage_size_for_data;
infinint offset_for_EA;
infinint storage_size_for_EA;
infinint offset_for_FSA;
infinint storage_size_for_FSA;
std::deque<std::string> ea;
mutable std::deque<std::string>::const_iterator it_ea;
infinint etiquette;
std::string data_crc;
std::string patch_base_crc;
std::string patch_result_crc;
bool empty_dir;
static time_t datetime2time_t(const datetime & val);
};
} // end of namespace
#endif
cat_status.hpp
the different status of data and EA
libdar::datetime
stores time information
Definition datetime.hpp:59
libdar::datetime::get_value
bool get_value(time_t &second, time_t &subsecond, time_unit unit) const
return a time as time_t arguments
libdar::deci
decimal class, convert infinint from and to decimal represention
Definition deci.hpp:51
libdar::deci::human
std::string human() const
this produce a string from the decimal stored in the current object
libdar::infinint
the arbitrary large positive integer class
Definition real_infinint.hpp:62
libdar::list_entry
Definition list_entry.hpp:60
libdar::list_entry::get_archive_offset_for_FSA
bool get_archive_offset_for_FSA(infinint &val) const
offset in byte where to find the first byte of Filesystem Specific Attributes
Definition list_entry.hpp:199
libdar::list_entry::get_last_modif
void get_last_modif(datetime::time_unit tu, time_t &second, time_t &fraction) const
yet an alternative method to get the last modification date (see get_last_access() for details)
Definition list_entry.hpp:129
libdar::list_entry::get_storage_size_for_data
bool get_storage_size_for_data(infinint &val) const
amount of byte used to store the file's data
Definition list_entry.hpp:176
libdar::list_entry::get_ea_reset_read
void get_ea_reset_read() const
reset the reading of Extended Attributes names
Definition list_entry.hpp:211
libdar::list_entry::get_last_access
void get_last_access(datetime::time_unit tu, time_t &second, time_t &fraction) const
yet an alternative method to get last access time
Definition list_entry.hpp:125
libdar::list_entry::get_removal_date
std::string get_removal_date() const
for removed_entry only
libdar::list_entry::get_last_change
void get_last_change(datetime::time_unit tu, time_t &second, time_t &fraction) const
yet an alternative method to get the last change date (see get_last_access() for details)
Definition list_entry.hpp:133
libdar::list_entry::get_fsa_scope
fsa_scope get_fsa_scope() const
this is the hard-link ID, only valid for hard linked entries
Definition list_entry.hpp:224
libdar::list_entry::is_eod
bool is_eod() const
method used to know whether the returned entry signals a End of Directory
Definition list_entry.hpp:74
libdar::list_entry::last_modif
datetime last_modif
also used to store removal_date for removed entries
Definition list_entry.hpp:279
libdar::list_entry::etiquette
infinint etiquette
hard link identification
Definition list_entry.hpp:302
libdar::list_entry::target
std::string target
target[0] used to store signature of removed entry for removed entries
Definition list_entry.hpp:289
libdar::list_entry::get_storage_size_for_EA
bool get_storage_size_for_EA(infinint &val) const
amount of byte used to store the file's EA
Definition list_entry.hpp:190
libdar::list_entry::get_removed_type
unsigned char get_removed_type() const
valid only for removed_entries
libdar::list_entry::get_ea_read_next
bool get_ea_read_next(std::string &key) const
read the next Extended Attribute name
libdar::list_entry::get_storage_size_for_FSA
bool get_storage_size_for_FSA(infinint &val) const
amount of byte used to store the file's FSA
Definition list_entry.hpp:204
libdar::list_entry::get_slices
const range & get_slices() const
provides slice information
Definition list_entry.hpp:152
libdar::list_entry::get_removal_date_s
time_t get_removal_date_s() const
for removed_entry only
libdar::list_entry::get_archive_offset_for_EA
bool get_archive_offset_for_EA(infinint &val) const
offset in byte whert to find the first byte of Extended Attributes
Definition list_entry.hpp:185
libdar::list_entry::get_archive_offset_for_data
bool get_archive_offset_for_data(infinint &val) const
offset in byte where to find first byte of data
Definition list_entry.hpp:168
libdar::range
stores a range of integers or a set of ranges
Definition range.hpp:44
compression.hpp
compression parameters for API
datetime.hpp
this file contains the definition of class datetime that stores unix times in a portable way
deci.hpp
manages the decimal representation of infinint
ea.hpp
contains a set of routines to manage EA values associated to a file
fsa_family.hpp
filesystem specific attributes available families and fsa_scope definition
libdar::compression2string
std::string compression2string(compression c)
convert a compression to its string representation
libdar::fsa_scope
std::set< fsa_family > fsa_scope
set of fsa families
Definition fsa_family.hpp:70
libdar::compression
compression
the different compression algorithm available
Definition compression.hpp:46
libdar::infinint::is_zero
bool is_zero() const
libdar::fsa_saved_status
fsa_saved_status
FSA saved status for an entry.
Definition cat_status.hpp:74
libdar::saved_status
saved_status
data saved status for an entry
Definition cat_status.hpp:45
libdar::ea_saved_status
ea_saved_status
EA saved status for an entry.
Definition cat_status.hpp:56
libdar::fsa_saved_status::none
@ none
no FSA saved
libdar::fsa_saved_status::full
@ full
FSA saved.
libdar::saved_status::saved
@ saved
inode is saved in the archive
libdar::saved_status::delta
@ delta
inode is saved but as delta binary from the content (delta signature) of what was found in the archiv...
libdar::ea_saved_status::none
@ none
no EA present for this inode in filesystem
libdar::ea_saved_status::removed
@ removed
EA were present in the reference version, but not present anymore.
libdar::ea_saved_status::full
@ full
EA present in filesystem and attached to this inode.
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
integers.hpp
are defined here basic integer types that tend to be portable
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
range.hpp
class than provide a way to manipulate and represent range of integer numbers (infinint)