![]() |
Disk ARchive
2.5.9
Full featured and portable backup and archiving tool
|
Symbols that are not to be used by external software. More...
Files | |
file | archive_version.hpp |
class archive_version that rules which archive format to follow | |
file | cache.hpp |
contains the cache class | |
file | capabilities.hpp |
provide information about current thread (underlying using the widthdrawn POSIX.1e API) | |
file | cat_all_entrees.hpp |
include file gathering all entree found in a catalogue | |
file | cat_blockdev.hpp |
class used to record block special devices in a catalogue | |
file | cat_chardev.hpp |
class used to record character special devices in a catalogue | |
file | cat_detruit.hpp |
used to record information in a catalogue about a deleted file (differential backup context) | |
file | cat_device.hpp |
parent class for all special devices inodes | |
file | cat_directory.hpp |
class used to organize objects in tree in catalogue as like directories in a filesystem | |
file | cat_door.hpp |
class used in a catalogue to store solaris door filesystem entries | |
file | cat_entree.hpp |
base class for all object contained in a catalogue | |
file | cat_eod.hpp |
object exchanged with a catalogue (never stored in it) to signal the end of a directory | |
file | cat_etoile.hpp |
class holding an cat_inode object that get pointed by multiple mirage objects (smart pointers) to record hard links in a catalogue | |
file | cat_file.hpp |
class used to record plain files in a catalogue | |
file | cat_ignored.hpp |
class used to remember that an entry has been ignored and shall not be recorded as deleted using a detruit object in a catalogue | |
file | cat_ignored_dir.hpp |
class used to remember in a catalogue that a cat_directory has been ignored | |
file | cat_inode.hpp |
base object for all inode types, managed EA and FSA, dates, permissions, ownership, ... | |
file | cat_lien.hpp |
class used to store symbolic links in a catalogue | |
file | cat_mirage.hpp |
smart pointer to an etoile object. Used to store hard link information inside a catalogue | |
file | cat_nomme.hpp |
base class of all objects contained in a catalogue and that can be named | |
file | cat_prise.hpp |
class to record filesystem (UNIX) sockets in a catalogue | |
file | cat_tools.hpp |
set of routines used by catalogue related classes | |
file | cat_tube.hpp |
class to record named pipes in a catalogue | |
file | catalogue.hpp |
here is defined the many classed which is build of the catalogue | |
file | compressor.hpp |
compression engine implementation | |
file | crc.hpp |
class crc definition, used to handle Cyclic Redundancy Checks | |
file | crypto_asym.hpp |
the asymetric cryptographical algoritms relying on gpgme | |
file | crypto.hpp |
the crypto algoritm definition | |
file | cygwin_adapt.hpp |
thin adaptation layer to Cygwin specifities | |
file | data_tree.hpp |
two classes used to store tree information in dar_manager databases | |
file | database_header.hpp |
defines the database structure in file | |
file | datetime.hpp |
this file contains the definition of class datetime that stores unix times in a portable way | |
file | defile.hpp |
here is defined the defile class | |
file | ea.hpp |
contains a set of routines to manage EA values associated to a file | |
file | ea_filesystem.hpp |
filesystem dependent Extended Attributes operationsThis file contains a set of routines used to manipulate (read, write or test the presence of) Extended Attributes | |
file | elastic.hpp |
here is defined the elastic class | |
file | erreurs_ext.hpp |
contains some additional exception class thrown by libdar | |
file | escape.hpp |
class escape definition, used for sequential reading of archivesThe class escape is used to insert escape sequences before each new file's data in an archive. The normal file's data is also rewritten if it contains such an escape sequence for it does not collide with real escape sequences At reading time, this class revert backs modification done to file's data containing escape sequences for they contain the original data. This class also provides the feature to skip to the next (real) escape sequence. This class inherits of generic files and its objects are to be used in a stack of generic file's objects. The object below contains modified data and escape sequences, the file over gets the normal file data and does never see escape sequences. Expected implementation is to have a compressor above an escape object and a sar or scrambler/blowfish/... object above it. | |
file | escape_catalogue.hpp |
class escape_catalogue definition. Used for sequential writing to archives, as well as several other inherited classes from catalogue.hppThis class inherits from the class catalogue and implements the pre_add(...) method, which role is to add an escape sequence followed by an entry dump (usually used at the end of archive is the so called catalogue part of the archive). This sequence followed by entry dump is added before each file's data all along the archive. Other inherited classes, implement the escape specific part, used when performing sequential reading of the catalogue | |
file | etage.hpp |
definition of the etage structure is done here | |
file | fichier_local.hpp |
class fichier_global definition. This is a full implementation/inherited class of class fichier_global this type of object are generated by entrepot_local. | |
file | filesystem.hpp |
defines several classes that realize the interface with the filesystem | |
file | filesystem_specific_attribute.hpp |
filesystem specific attributes | |
file | filtre.hpp |
here is all the core routines for the operations | |
file | generic_file.hpp |
class generic_file is defined here as well as class fichierthe generic_file interface is widely used in libdar it defines the standard way of transmitting data between different part of the library | |
file | generic_file_overlay_for_gpgme.hpp |
adaptation class from gpgme data buffer to libdar generic_file interface | |
file | generic_thread.hpp |
class generic_thread provides a way to interact with a generic_file ran in an other thread | |
file | generic_to_global_file.hpp |
this class provides an fichier_global interface for any type of generic_file object | |
file | hash_fichier.hpp |
class hash_fichier definition.This is an inherited class from class fichier Objects of that class are write-only objects that provide a hash of the written data other hash algorithm may be added in the future | |
file | header.hpp |
slice header structure is defined here | |
file | header_version.hpp |
archive global header/trailer structure is defined here | |
file | infinint.hpp |
switch module to limitint (32 ou 64 bits integers) or infinint | |
file | int_tools.hpp |
elementary operation for infinint integers | |
file | integers.hpp |
are defined here basic integer types that tend to be portable | |
file | label.hpp |
define the datastructure "label" used to identify slice membership to an archive | |
file | limitint.hpp |
the reviewed implementation of infinint based on system limited integersthe limitint template class implementation defined in this module can handle positive integers and detect overflow. It shares with infinint the same interface, so it can be use in place of it, but throw Elimitint exceptions if overflow is detected. | |
file | macro_tools.hpp |
macroscopic tools for libdar internals | |
file | mem_allocator.hpp |
this is the base class of object that can provide dynamically allocated memory blocks | |
file | mem_cluster.hpp |
defines mem_cluster class that holds a fixed set of fixed size allocatable memory blocks | |
file | mem_sized.hpp |
defines mem_sized class that holds a variable sized set of fixed sized blocks using class mem_cluster | |
file | mem_ui.hpp |
class mem_ui definition. This class is to be used as parent class to handle user_interaction object management | |
file | memory_file.hpp |
Memory_file is a generic_file class that only uses virtual memory. | |
file | messaging.hpp |
messaging_decode and messaging_encode are used to insert messages in a flow if data blocks | |
file | nls_swap.hpp |
provides a set of macro to change the NLS from user application domaine to libdar domain and viceversa | |
file | null_file.hpp |
/dev/null type file implementation under the generic_file interfacethis class is used in particular when doing dry-run execution | |
file | on_pool.hpp |
this is the base class of object that can be allocated on a memory pool | |
file | pile.hpp |
class pile definition. Used to manage a stack of generic_file objects | |
file | pile_descriptor.hpp |
optimization structure to quickly access some commonly used layers of a stack of generic_file | |
file | range.hpp |
class than provide a way to manipulate and represent range of integer numbers (infinint) | |
file | real_infinint.hpp |
the original infinint class implementationthe infinint class implementation defined in this module can handle arbitrary large positive integer numbers | |
file | sar.hpp |
the sar and trivial_sar classes, they manage the slicing layer | |
file | sar_tools.hpp |
a set of tools aims to help Segmentation And Reassemblement (sar) class | |
file | scrambler.hpp |
contains the definition of the scrambler class, a very weak encryption scheme | |
file | secu_memory_file.hpp |
secu_memory_file is a generic_file class that only uses secured memory (not swappable and zeroed after use) | |
file | secu_string.hpp |
this file contains the definition of secu_string class, a std::string like class but allocated in secure memorysecure memory is a allocated memory that is never swapped out (wrote to disk) the implementation relies on gcrypt_malloc_secure() call (libgcrypt) rather than relying on mlock()/munlock() posix system call. as the need for secure string is for strong encryption, there is no much interest in re-inventing the wheel as the need is dependent on gcrypt availability | |
file | semaphore.hpp |
definition of class semaphore, used to manage invocation of backup hook for files | |
file | slave_thread.hpp |
class slave_thread is runs a I/O operations on a given genercif_file in a separated thread | |
file | slice_layout.hpp |
object describing the slicing of an archive | |
file | smart_pointer.hpp |
template class implementing memory efficient smart pointer | |
file | sparse_file.hpp |
class sparse_file definition, used to handle holes in filesthis class is used to receive plain file's data to be written to the archive or to be read out from an archive. The class uses escape sequences to replace holes in files (long serie of zeros) by the number of zeros preceeded by a escape sequence mark. this class internally uses an escape object, with a modifed fixed escape sequence that optimizes the use of sparse_file objects with other escape objects. | |
file | storage.hpp |
contains a class that permits arbitrary large data storage | |
file | terminateur.hpp |
the terminateur class which defines the position of the cataloguethe terminateur is a byte sequence present as the last bytes of an archive which indicates how much byte backward libdar must skip back to find the beginning of the catalogue. | |
file | tlv.hpp |
Generic Type Length Value data structures. | |
file | tlv_list.hpp |
List of Generic Type Length Value data structures. | |
file | trivial_sar.hpp |
the trivial_sar classes manages the slicing layer when single slice is used | |
file | tronc.hpp |
defines a limited segment over another generic_file.This is used to read a part of a file as if it was a real file generating end of file behavior when reaching the given length. | |
file | tronconneuse.hpp |
defines a block structured file.Mainly used for strong encryption. | |
file | trontextual.hpp |
class trontextual is a contextual variant of class tronc | |
file | tuyau.hpp |
defines the implementation of pipe under the generic_file interface.mainly used between zapette and slave_zapette, this is a full implementation of the generic_file interface that takes care of dead lock when two pipes needs to be openned between the same two entities, each having one for reading and the other for writing. | |
file | user_group_bases.hpp |
defines class that speed up the uid to username and gid to group name lookup | |
file | wrapperlib.hpp |
libz and libbz2 wrapper to have identical interface to these libraries.libz and libbz2 library differ in the way they return values in certain circumpstances. This module defines the wrapperlib class that make their use homogeneous. | |
file | zapette.hpp |
remote control between dar and dar_slave.Two classes are defined in this module | |
Namespaces | |
libdar | |
libdar namespace encapsulate all libdar symbols | |
Classes | |
class | libdar::cat_blockdev |
the block device class More... | |
class | libdar::cat_chardev |
the char device class More... | |
class | libdar::cat_detruit |
the deleted file entry More... | |
class | libdar::cat_device |
the special cat_device root class More... | |
class | libdar::cat_directory |
the cat_directory inode class More... | |
class | libdar::cat_door |
the class for Door IPC (mainly for Solaris) More... | |
struct | libdar::entree_stats |
holds the statistics contents of a catalogue More... | |
class | libdar::cat_entree |
the root class from all other inherite for any entry in the catalogue More... | |
class | libdar::cat_eod |
the End of Directory entry class More... | |
class | libdar::cat_etoile |
the hard link implementation (etoile means star in French, seen a star as a point from which are thrown many ray of light) More... | |
class | libdar::cat_file |
the plain file class More... | |
class | libdar::cat_ignored |
the present file to ignore (not to be recorded as deleted later) More... | |
class | libdar::cat_ignored_dir |
the ignored cat_directory class, to be promoted later as empty cat_directory if needed More... | |
class | libdar::cat_inode |
the root class for all cat_inode More... | |
class | libdar::cat_lien |
the symbolic link inode class More... | |
class | libdar::cat_mirage |
the hard link implementation, cat_mirage is the named entry owned by a directory it points to a common "cat_etoile class" More... | |
class | libdar::cat_nomme |
the base class for all entry that have a name More... | |
class | libdar::cat_prise |
the Unix socket inode class More... | |
class | libdar::cat_tube |
the named pipe class More... | |
class | libdar::catalogue |
the catalogue class which gather all objects contained in a give archive More... | |
class | libdar::crypto_sym |
class | libdar::data_tree |
the data_tree class stores presence of a given file in a set of archives More... | |
class | libdar::data_dir |
the data_dir class inherits from data_tree and holds the directory tree's parent relationship More... | |
class | libdar::defile |
the defile class keep trace of the real path of files while the flow in the filter routines More... | |
class | libdar::elastic |
the elastic buffer class More... | |
class | libdar::entrepot |
the Entrepot interface More... | |
class | libdar::entrepot_local |
class | libdar::Ethread_cancel_with_attr |
Ethread_cancel with infinint attribute. More... | |
struct | libdar::etage |
the etage structure keep trace of directory contents More... | |
class | libdar::fichier_global |
abstraction of filesystem files for entrepot More... | |
class | libdar::fichier_local |
filesystem local files More... | |
class | libdar::filesystem_hard_link_read |
keep trace of hard links when reading the filesystem More... | |
class | libdar::filesystem_backup |
make a flow sequence of inode to feed the backup filtering routing More... | |
class | libdar::filesystem_diff |
make a flow of inode to feed the difference filter routine More... | |
class | libdar::filesystem_hard_link_write |
keep trace of already written inodes to restore hard links More... | |
class | libdar::filesystem_restore |
receive the flow of inode from the restoration filtering routing and promotes these to real filesystem objects More... | |
class | libdar::filesystem_specific_attribute |
class | libdar::generic_file |
this is the interface class from which all other data transfer classes inherit More... | |
class | libdar::header |
this class manages the header of each slice More... | |
class | libdar::header_version |
manages the archive header and trailer More... | |
class | libdar::limitint< B > |
class | libdar::mem_allocator |
generic interface of objects that need to be informed that a memory block they manage has been released More... | |
class | libdar::mem_manager |
generic interface of memory managers that create and delete mem_allocator objects depending on requests More... | |
class | libdar::mem_ui |
class mem_ui to keep a copy of a user_interaction object More... | |
class | libdar::null_file |
the null_file class implements the /dev/null behavior More... | |
class | libdar::on_pool |
class | libdar::infinint |
the arbitrary large positive integer class More... | |
class | libdar::sar |
Sar class stands for Segmentation And Reassembly class. More... | |
class | libdar::scrambler |
scrambler is a very weak encryption scheme More... | |
class | libdar::secu_string |
class secu_string More... | |
class | libdar::semaphore |
class semaphore More... | |
class | libdar::statistics |
structure returned by libdar call to give a summary of the operation done in term of file treated More... | |
class | libdar::storage |
arbitrary large storage structure More... | |
class | libdar::terminateur |
terminateur class indicates the location of the beginning of the catalogue More... | |
class | libdar::thread_cancellation |
class to be used as parent to provide checkpoints to inherited classes More... | |
class | libdar::tlv |
class | libdar::trivial_sar |
class | libdar::tronc |
makes a segment of a generic_file appear like a real generic_file More... | |
class | libdar::tronconneuse |
this is a partial implementation of the generic_file interface to cypher/decypher data block by block. More... | |
class | libdar::tuyau |
pipe implementation under the generic_file interface. More... | |
class | libdar::wrapperlib |
this class encapsulates calls to libz or libbz2 More... | |
class | libdar::zapette |
zapette emulate a file that is remotely controlled by slave_zapette More... | |
class | libdar::slave_zapette |
this class answers to order given by a zapette object More... | |
Typedefs | |
typedef U_32 | libdar::magic_number |
typedef unsigned char | libdar::int_tools_bitfield [8] |
Enumerations | |
enum | saved_status { s_saved, s_fake, s_not_saved } |
enum | get_data_mode { keep_compressed, keep_hole, normal, plain } |
enum | { empty, from_path, from_cat } |
enum | libdar::cat_inode::comparison_fields { cf_all, cf_ignore_owner, cf_mtime, cf_inode_type } |
flag used to only consider certain fields when comparing/restoring inodes | |
enum | ea_status { ea_none, ea_partial, ea_fake, ea_full, ea_removed } |
enum | fsa_status { fsa_none, fsa_partial, fsa_full } |
enum | mirage_format { fmt_mirage, fmt_hard_link, fmt_file_etiquette } |
enum | lookup { found_present, found_removed, not_found, not_restorable } |
enum | etat { et_saved, et_present, et_removed, et_absent } |
enum | time_unit { tu_nanosecond, tu_microsecond, tu_second } |
enum | sequence_type { seqt_undefined, seqt_not_a_sequence, seqt_file, seqt_ea, seqt_catalogue, seqt_data_name, seqt_file_crc, seqt_ea_crc, seqt_changed, seqt_dirty, seqt_failed_backup, seqt_fsa, seqt_fsa_crc } |
enum | advise { advise_normal, advise_sequential, advise_random, advise_noreuse, advise_willneed, advise_dontneed } |
enum | action_done_for_data { done_data_restored, done_no_change_no_data, done_no_change_policy, done_data_removed } |
enum | libdar::gf_mode { libdar::gf_read_only, libdar::gf_write_only, libdar::gf_read_write } |
generic_file openning modes More... | |
enum | skippability { skip_backward, skip_forward } |
enum | flag_type { flag_type_terminal = 'T', flag_type_non_terminal = 'N', flag_type_located_at_end_of_slice = 'E' } |
enum | wrapperlib_mode { zlib_mode, bzlib_mode, xz_mode } |
Functions | |
std::string | libdar::local_perm (const cat_inode &ref, bool hard) |
std::string | libdar::local_uid (const cat_inode &ref) |
std::string | libdar::local_gid (const cat_inode &ref) |
std::string | libdar::local_size (const cat_inode &ref, bool sizes_in_bytes) |
std::string | libdar::local_storage_size (const cat_inode &ref) |
std::string | libdar::local_date (const cat_inode &ref) |
std::string | libdar::local_flag (const cat_inode &ref, bool isolated, bool dirty_seq) |
void | libdar::xml_listing_attributes (user_interaction &dialog, const std::string &beginning, const std::string &data, const std::string &metadata, const cat_entree *obj=nullptr, bool list_ea=false) |
bool | libdar::extract_base_and_status (unsigned char signature, unsigned char &base, saved_status &saved) |
void | libdar::local_display_ea (user_interaction &dialog, const cat_inode *ino, const std::string &prefix, const std::string &suffix, bool xml_output=false) |
unsigned char | libdar::mk_signature (unsigned char base, saved_status state) |
void | libdar::unmk_signature (unsigned char sig, unsigned char &base, saved_status &state, bool isolated) |
bool | libdar::compatible_signature (unsigned char a, unsigned char b) |
unsigned char | libdar::get_base_signature (unsigned char a) |
std::string | libdar::entree_to_string (const cat_entree *obj) |
crc * | libdar::create_crc_from_file (generic_file &f, memory_pool *pool, bool old=false) |
crc * | libdar::create_crc_from_size (infinint width, memory_pool *pool) |
archive_version | libdar::db2archive_version (unsigned char db_version) |
converts dar_manager database version to dar archive version in order to properly read time fields | |
template<class T > | |
T * | libdar::cloner (const T *x, memory_pool *p) |
const char * | libdar::generic_file_get_name (gf_mode mode) |
provides a human readable string defining the gf_mode given in argument | |
std::string | libdar::hash_algo_to_string (hash_algo algo) |
libdar::header_version::header_version (const header_version &ref) | |
const header_version & | libdar::header_version::operator= (const header_version &ref) |
void | libdar::header_version::read (generic_file &f, user_interaction &dialog, bool lax_mode) |
read the header or trailer from the archive | |
void | libdar::header_version::write (generic_file &f) const |
write down the object to the archive (as header if wrote at the beginning of the archive, as trailer is at the end) | |
void | libdar::header_version::set_edition (const archive_version &ed) |
void | libdar::header_version::set_compression_algo (const compression &zip) |
void | libdar::header_version::set_command_line (const std::string &line) |
void | libdar::header_version::set_initial_offset (const infinint &offset) |
void | libdar::header_version::set_sym_crypto_algo (const crypto_algo &algo) |
void | libdar::header_version::set_crypted_key (memory_file *key) |
the object pointed to by key passes to the responsibility of this header_version object | |
void | libdar::header_version::clear_crypted_key () |
void | libdar::header_version::set_slice_layout (slice_layout *layout) |
the object pointed to by layout is passed under the responsibility of this header_version object | |
void | libdar::header_version::clear_slice_layout () |
void | libdar::header_version::set_tape_marks (bool presence) |
void | libdar::header_version::set_signed (bool is_signed) |
const archive_version & | libdar::header_version::get_edition () const |
compression | libdar::header_version::get_compression_algo () const |
const std::string & | libdar::header_version::get_command_line () const |
const infinint & | libdar::header_version::get_initial_offset () const |
bool | libdar::header_version::is_ciphered () const |
bool | libdar::header_version::is_signed () const |
crypto_algo | libdar::header_version::get_sym_crypto_algo () const |
memory_file * | libdar::header_version::get_crypted_key () const |
const slice_layout * | libdar::header_version::get_slice_layout () const |
bool | libdar::header_version::get_tape_marks () const |
void | libdar::int_tools_swap_bytes (unsigned char &a, unsigned char &b) |
void | libdar::int_tools_swap_bytes (unsigned char *a, U_I size) |
void | libdar::int_tools_expand_byte (unsigned char a, int_tools_bitfield &bit) |
void | libdar::int_tools_contract_byte (const int_tools_bitfield &b, unsigned char &a) |
template<class T > | |
T | libdar::int_tools_rotate_right_one_bit (T v) |
template<class T > | |
T | libdar::int_tools_maxof_agregate (T unused) |
libdar::limitint< B >::limitint (size_t a=0) | |
libdar::limitint< B >::limitint (generic_file &x) | |
void | libdar::limitint< B >::dump (generic_file &x) const |
void | libdar::limitint< B >::read (generic_file &f) |
limitint & | libdar::limitint< B >::operator+= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator-= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator*= (const limitint &ref) |
template<class T > | |
limitint | libdar::limitint< B >::power (const T &exponent) const |
limitint & | libdar::limitint< B >::operator/= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator%= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator&= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator|= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator^= (const limitint &ref) |
limitint & | libdar::limitint< B >::operator>>= (U_32 bit) |
limitint & | libdar::limitint< B >::operator>>= (limitint bit) |
limitint & | libdar::limitint< B >::operator<<= (U_32 bit) |
limitint & | libdar::limitint< B >::operator<<= (limitint bit) |
limitint | libdar::limitint< B >::operator++ (int a) |
limitint | libdar::limitint< B >::operator-- (int a) |
limitint & | libdar::limitint< B >::operator++ () |
limitint & | libdar::limitint< B >::operator-- () |
U_32 | libdar::limitint< B >::operator% (U_32 arg) const |
template<class T > | |
void | libdar::limitint< B >::unstack (T &v) |
limitint | libdar::limitint< B >::get_storage_size () const |
unsigned char | libdar::limitint< B >::operator[] (const limitint &position) const |
bool | libdar::limitint< B >::is_zero () const |
bool | libdar::limitint< B >::operator< (const limitint &x) const |
bool | libdar::limitint< B >::operator== (const limitint &x) const |
bool | libdar::limitint< B >::operator> (const limitint &x) const |
bool | libdar::limitint< B >::operator<= (const limitint &x) const |
bool | libdar::limitint< B >::operator!= (const limitint &x) const |
bool | libdar::limitint< B >::operator>= (const limitint &x) const |
static bool | libdar::limitint< B >::is_system_big_endian () |
B | libdar::limitint< B >::debug_get_max () const |
B | libdar::limitint< B >::debug_get_bytesize () const |
B | libdar::limitint< B >::debug_get_field () const |
template<class B > | |
limitint< B > | libdar::operator+ (const limitint< B > &, const limitint< B > &) |
template<class B > | |
limitint< B > | libdar::operator+ (const limitint< B > &a, U_I b) |
template<class B > | |
limitint< B > | libdar::operator- (const limitint< B > &, const limitint< B > &) |
template<class B > | |
limitint< B > | libdar::operator- (const limitint< B > &a, U_I b) |
template<class B > | |
limitint< B > | libdar::operator* (const limitint< B > &, const limitint< B > &) |
template<class B > | |
limitint< B > | libdar::operator* (const limitint< B > &a, U_I b) |
template<class B > | |
limitint< B > | libdar::operator/ (const limitint< B > &, const limitint< B > &) |
template<class B > | |
limitint< B > | libdar::operator/ (const limitint< B > &a, U_I b) |
template<class B > | |
limitint< B > | libdar::operator% (const limitint< B > &, const limitint< B > &) |
template<class B > | |
limitint< B > | libdar::operator>> (const limitint< B > &a, U_32 bit) |
template<class B > | |
limitint< B > | libdar::operator>> (const limitint< B > &a, const limitint< B > &bit) |
template<class B > | |
limitint< B > | libdar::operator<< (const limitint< B > &a, U_32 bit) |
template<class B > | |
limitint< B > | libdar::operator<< (const limitint< B > &a, const limitint< B > &bit) |
template<class B > | |
limitint< B > | libdar::operator& (const limitint< B > &a, U_32 bit) |
template<class B > | |
limitint< B > | libdar::operator& (const limitint< B > &a, const limitint< B > &bit) |
template<class B > | |
limitint< B > | libdar::operator| (const limitint< B > &a, U_32 bit) |
template<class B > | |
limitint< B > | libdar::operator| (const limitint< B > &a, const limitint< B > &bit) |
template<class B > | |
limitint< B > | libdar::operator^ (const limitint< B > &a, U_32 bit) |
template<class B > | |
limitint< B > | libdar::operator^ (const limitint< B > &a, const limitint< B > &bit) |
template<class T > | |
void | libdar::euclide (T a, T b, T &q, T &r) |
template<class B > | |
void | libdar::euclide (limitint< B > a, U_I b, limitint< B > &q, limitint< B > &r) |
std::string | libdar::sar_make_filename (const std::string &base_name, const infinint &num, const infinint &min_digits, const std::string &ext) |
return the name of a slice given the base_name, slice number and extension | |
template<class T > | |
bool | libdar::pile::pop_and_close_if_type_is (T *ptr) |
template<class T > | |
void | libdar::pile::find_first_from_top (T *&ref) |
template<class T > | |
void | libdar::pile::find_first_from_bottom (T *&ref) |
this template is similar to the template "find_first_from_top" except that the search is started from the bottom of the stack | |
Symbols that are not to be used by external software.
never use threses symboles (function, macro, variables, types, etc.) they are not intended to be used by external programs and may change or disapear without any warning or backward compatibility. Some are however documented for libdar development ease.
enum libdar::gf_mode |
generic_file openning modes
Enumerator | |
---|---|
gf_read_only |
read only access |
gf_write_only |
write only access |
gf_read_write |
read and write access |
Definition at line 77 of file generic_file.hpp.
std::string libdar::entree_to_string | ( | const cat_entree * | obj | ) |
returns a string describing the object type
void libdar::pile::find_first_from_top | ( | T *& | ref | ) |
this template let the class user find out the higher object on the stack of the given type
[in,out] | ref | gives the type of the object to look for, and gets the address of the first object found starting from the top |
bool libdar::pile::pop_and_close_if_type_is | ( | T * | ptr | ) |
remove the top generic_file and destroy it
[in] | ptr | is the type of the object that must be found on the top of the stack. It may be the type of an parent class. |