Disk ARchive  2.4.21
Files | Namespaces | Classes | Macros | Typedefs | Enumerations | Functions | Variables
Private

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  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.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  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.hpp
 class fichier definition. This is a full implementation of a generic_file applied to a plain file
 
file  filesystem.hpp
 defines several classes that realize the interface with the filesystem
 
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  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 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_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  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  pile.hpp
 class pile definition. Used to manage a stack of generic_file objects
 
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 class holds all the slicing feature
 
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_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  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  special_alloc.hpp
 re-definition of new and delete class operatorthis is a set of macro that makes the new and delete operator for a class be re-defined in a way that allocation is done in big chunks at the system level, and is split in small requested pieces for a given object allocation. This bring some performance improvment, because a lot a small objects that live and die toghether have to be allocated.
 
file  storage.hpp
 contains a class that permits arbitrary large data storage
 
file  string_file.hpp
 emulate a generic_file from a string of characters
 
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  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 several 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::archive_version
 class archive_version manages the version of the archive format More...
 
class  libdar::cache
 the cache class implements a very basic read/write caching mechanism More...
 
struct  libdar::entree_stats
 holds the statistics contents of a catalogue More...
 
class  libdar::entree
 the root class from all other inherite for any entry in the catalogue More...
 
class  libdar::eod
 the End of Directory entry class More...
 
class  libdar::nomme
 the base class for all entry that have a name More...
 
class  libdar::inode
 the root class for all inode More...
 
class  libdar::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::mirage
 the hard link implementation, mirage is the named entry owned by a directory it points to a common "etoile class" More...
 
class  libdar::file
 the plain file class More...
 
class  libdar::door
 the class for Door IPC (mainly for Solaris) More...
 
class  libdar::lien
 the symbolic link inode class More...
 
class  libdar::directory
 the directory inode class More...
 
class  libdar::device
 the special device root class More...
 
class  libdar::chardev
 the char device class More...
 
class  libdar::blockdev
 the block device class More...
 
class  libdar::tube
 the named pipe class More...
 
class  libdar::prise
 the Unix socket inode class More...
 
class  libdar::detruit
 the deleted file entry More...
 
class  libdar::ignored
 the present file to ignore (not to be recorded as deleted later) More...
 
class  libdar::ignored_dir
 the ignored directory class, to be promoted later as empty directory if needed More...
 
class  libdar::catalogue
 the catalogue class which gather all objects contained in a give archive More...
 
class  libdar::crypto_sym
 implementation of encryption using symetrical cryptography used in libgcrypt (among which is blowfish) More...
 
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::ea_attributs
 the class ea_attributs manages the set of EA that can be associated to an inode More...
 
class  libdar::elastic
 the elastic buffer class More...
 
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::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...
 
struct  libdar::header_version
 manages of the archive header and trailer More...
 
class  libdar::limitint< B >
 
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::infinint
 the arbitrary large positive integer class More...
 
class  libdar::sar
 Sar class stands for Segmentation And Reassembly class. More...
 
class  libdar::trivial_sar
 "trivial sar" emulates the behavior of sar when all data must be keept in a arbitrary length single slice 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::storage
 arbitrary large storage structure More...
 
class  libdar::string_file
 class string_file emulates a generic_file frome a std::string 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
 Type Length Value Structure. More...
 
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...
 

Macros

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

Typedefs

typedef U_16 libdar::archive_num
 
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::elastic_direction { elastic_forward, elastic_backward }
 
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 }
 

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)
 
compression libdar::char2compression (char a)
 
crc * libdar::create_crc_from_file (generic_file &f, bool old=false)
 
crc * libdar::create_crc_from_size (infinint width)
 
void libdar::crypto_split_algo_pass (const secu_string &all, crypto_algo &algo, secu_string &pass)
 
generic_file * libdar::database_header_create (user_interaction &dialog, const std::string &filename, bool overwrite)
 create the header for a dar_manager database More...
 
ea_attributs * libdar::ea_filesystem_read_ea (const std::string &chemin, const mask &filter)
 read EA associated to a given file More...
 
void libdar::filtre_restore (user_interaction &dialog, const mask &filtre, const mask &subtree, catalogue &cat, const path &fs_racine, bool fs_warn_overwrite, bool info_details, statistics &st, const mask &ea_mask, bool flat, inode::comparison_fields what_to_check, bool warn_remove_no_match, bool empty, bool display_skipped, bool empty_dir, const crit_action &x_overwrite, archive_options_extract::t_dirty dirty, bool only_deleted, bool not_deleted)
 
gf_mode libdar::generic_file_get_mode (S_I fd)
 
const char * libdar::generic_file_get_name (gf_mode mode)
 
std::string libdar::hash_algo_to_string (hash_algo algo)
 
void libdar::header_version::read (generic_file &f)
 
void libdar::header_version::write (generic_file &f)
 
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 (user_interaction &dialog, S_I fd)
 
 libdar::limitint< B >::limitint (generic_file &x)
 
void libdar::limitint< B >::dump (user_interaction &dialog, S_I fd) const
 
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 >::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
 
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
 
trivial_sar * libdar::sar_tools_open_archive_tuyau (user_interaction &dialog, S_I fd, gf_mode mode, const label &data_name, bool slice_header_format_07, const std::string &execute)
 create an container to write a archive to a pipe
 
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 U_I libdar::VERSION_FLAG_SAVED_EA_ROOT = 0x80
 
const U_I libdar::VERSION_FLAG_SAVED_EA_USER = 0x40
 
const U_I libdar::VERSION_FLAG_SCRAMBLED = 0x20
 
const U_I libdar::VERSION_FLAG_SEQUENCE_MARK = 0x10
 
const U_I libdar::VERSION_FLAG_INITIAL_OFFSET = 0x08
 
const U_I libdar::VERSION_FLAG_HAS_AN_EXTENDED_SIZE = 0x01
 
const U_I libdar::VERSION_SIZE = 3
 
const U_I libdar::HEADER_CRC_SIZE = 2
 
archive_version libdar::header_version::edition
 
char libdar::header_version::algo_zip
 
std::string libdar::header_version::cmd_line
 
unsigned char libdar::header_version::flag
 
infinint libdar::header_version::initial_offset
 
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.

Macro Definition Documentation

#define O_TEXT   0

Definition at line 45 of file cygwin_adapt.hpp.

Typedef Documentation

typedef U_16 libdar::archive_num

Definition at line 49 of file data_tree.hpp.

Enumeration Type Documentation

Definition at line 45 of file elastic.hpp.

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

compression libdar::char2compression ( char  a)
inline

Definition at line 86 of file libdar_4_4.hpp.

References libdar::char2compression().

Referenced by libdar_4_4::char2compression().

void libdar::crypto_split_algo_pass ( const secu_string all,
crypto_algo algo,
secu_string pass 
)
generic_file* libdar::database_header_create ( user_interaction dialog,
const std::string &  filename,
bool  overwrite 
)

create the header for a dar_manager database

Parameters
[in]dialogis used for user interaction
[in]filenameis the file's name to create/overwrite
[in]overwriteset to true to allow file overwriting (else generates an error if file exists)
Returns
the database header has been read and checked the database can now be read from the returned generic_file pointed by the returned value then it must be destroyed with the delete operator.
ea_attributs* libdar::ea_filesystem_read_ea ( const std::string &  chemin,
const mask filter 
)

read EA associated to a given file

Parameters
[in]cheminis the path to the file to read attributes of
[in]filteris a mask that defines which attributes names have to be considered only
Returns
NULL if no EA have been found under the specified mask, or returns a newly allocated object that the caller has the responsibility to delete when no more needed
void libdar::filtre_restore ( user_interaction dialog,
const mask filtre,
const mask subtree,
catalogue cat,
const path fs_racine,
bool  fs_warn_overwrite,
bool  info_details,
statistics st,
const mask ea_mask,
bool  flat,
inode::comparison_fields  what_to_check,
bool  warn_remove_no_match,
bool  empty,
bool  display_skipped,
bool  empty_dir,
const crit_action x_overwrite,
archive_options_extract::t_dirty  dirty,
bool  only_deleted,
bool  not_deleted 
)
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 NULL

Definition at line 187 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 166 of file pile.hpp.