Disk ARchive  2.5.2
Full featured and portable backup and archiving tool
Classes | Namespaces | Files | Defines | Typedefs | Enumerations | Functions | Variables
Private

Symbols that are not to be used by external software. More...

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::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::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...

Namespaces

namespace  libdar
 

libdar namespace encapsulate all libdar symbols


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 operations

This 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 archives

The 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.hpp

This 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 fichier

the 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 integers

the 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 interface

this 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 implementation

the 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 memory

secure 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  sparse_file.hpp
 

class sparse_file definition, used to handle holes in files

this 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 catalogue

the 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


Defines

#define CONTEXT_INIT   "init"
#define CONTEXT_OP   "operation"
#define CONTEXT_LAST_SLICE   "last_slice"
#define BUFFER_SIZE   102400
#define GLOBAL_ELASTIC_BUFFER_SIZE   51200
#define SPARSE_FIXED_ZEROED_BLOCK   40960
#define LOCK_IN
#define LOCK_OUT
#define LOCK_IN_CONST
#define LOCK_OUT_CONST

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  libdar::gf_mode { libdar::gf_read_only, libdar::gf_write_only, libdar::gf_read_write }
 generic_file openning modes More...
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

bool libdar::compatible_signature (unsigned char a, unsigned char b)
unsigned char libdar::mk_signature (unsigned char base, saved_status state)
unsigned char libdar::get_base_signature (unsigned char a)
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)
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)
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 >
libdar::int_tools_rotate_right_one_bit (T v)
template<class 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 ()
libdar::limitint< B >::debug_get_max () const
libdar::limitint< B >::debug_get_bytesize () const
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

Variables

const U_32 libdar::SAUV_MAGIC_NUMBER = 123
const label libdar::label_zero
const int libdar::WR_OK = 0
const int libdar::WR_MEM_ERROR = 1
const int libdar::WR_VERSION_ERROR = 2
const int libdar::WR_STREAM_ERROR = 3
const int libdar::WR_DATA_ERROR = 4
const int libdar::WR_NO_FLUSH = 5
const int libdar::WR_BUF_ERROR = 6
const int libdar::WR_STREAM_END = 7
const int libdar::WR_FINISH = 8

Detailed Description

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.


Enumeration Type Documentation

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.


Function Documentation

template<class T >
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

Parameters:
[in,out]refgives the type of the object to look for, and gets the address of the first object found starting from the top
Note:
if no object of that type could be found in the stack ref is set to nullptr

Definition at line 199 of file pile.hpp.

template<class T >
bool libdar::pile::pop_and_close_if_type_is ( T *  ptr)

remove the top generic_file and destroy it

Parameters:
[in]ptris the type of the object that must be found on the top of the stack. It may be the type of an parent class.
Returns:
true if and only if the object on the top of the stack could be matched to the given type, this object is then poped from the stack and destroyed.

Definition at line 178 of file pile.hpp.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines