| Disk ARchive 2.5.10 Full featured and portable backup and archiving tool

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

catalogue.hpp
Go to the documentation of this file.
1 /*********************************************************************/
2 // dar - disk archive - a backup/restoration program
3 // Copyright (C) 2002-2052 Denis Corbin
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 //
19 // to contact the author : http://dar.linux.free.fr/email.html
20 /*********************************************************************/
21
25
26 #ifndef CATALOGUE_HPP
27 #define CATALOGUE_HPP
28
29 #include "../my_config.h"
30
31 extern "C"
32 {
33 #if HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 } // end extern "C"
37
38 #include "infinint.hpp"
39 #include "generic_file.hpp"
40 #include "path.hpp"
41 #include "compressor.hpp"
42 #include "integers.hpp"
43 #include "mask.hpp"
44 #include "user_interaction.hpp"
45 #include "label.hpp"
46 #include "escape.hpp"
47 #include "on_pool.hpp"
48 #include "datetime.hpp"
49 #include "slice_layout.hpp"
50 #include "mem_ui.hpp"
51 #include "cat_entree.hpp"
52 #include "cat_nomme.hpp"
53 #include "cat_directory.hpp"
54
55 namespace libdar
56 {
57
60
62 class catalogue : protected mem_ui, public on_pool
63 {
64 public :
65 catalogue(const user_interaction & dialog,
66 const datetime & root_last_modif,
67 const label & data_name);
68 catalogue(const user_interaction & dialog,
69 const pile_descriptor & pdesc,
70 const archive_version & reading_ver,
71 compression default_algo,
72 bool lax,
73 const label & lax_layer1_data_name, //< ignored unless in lax mode, in lax mode unless it is a cleared label, forces the catalogue label to be equal to the lax_layer1_data_name for it be considered a plain internal catalogue, even in case of corruption
74 bool only_detruit = false); //< if set to true, only directories and detruit objects are read from the archive
75 catalogue(const catalogue & ref) : mem_ui(ref), out_compare(ref.out_compare) { partial_copy_from(ref); };
76 const catalogue & operator = (const catalogue &ref);
77 virtual ~catalogue() { detruire(); };
78
79
80 // reading methods. The reading is iterative and uses the current_read cat_directory pointer
81
82 virtual void reset_read() const; // set the reading cursor to the beginning of the catalogue
83 virtual void end_read() const; // set the reading cursor to the end of the catalogue
84 virtual void skip_read_to_parent_dir() const;
85 // skip all items of the current dir and of any subdir, the next call will return
86 // next item of the parent dir (no cat_eod to exit from the current dir !)
87 virtual bool read(const cat_entree * & ref) const;
88 // sequential read (generates cat_eod) and return false when all files have been read
89 virtual bool read_if_present(std::string *name, const cat_nomme * & ref) const;
90 // pseudo-sequential read (reading a directory still
91 // implies that following read are located in this subdirectory up to the next EOD) but
92 // it returns false if no entry of this name are present in the current directory
93 // a call with nullptr as first argument means to set the current dir the parent directory
94 void remove_read_entry(std::string & name);
95 // in the currently read directory, removes the entry which name is given in argument
96 const cat_directory & get_current_reading_dir() const { if(current_read == nullptr) throw SRC_BUG; return *current_read; };
97 // remove from the catalogue all the entries that have not yet been read
98 // by read().
99 void tail_catalogue_to_current_read();
100
101
102 void reset_sub_read(const path &sub); // initialise sub_read to the given directory
103 bool sub_read(const cat_entree * &ref); // sequential read of the catalogue, ignoring all that
104 // is not part of the subdirectory specified with reset_sub_read
105 // the read include the inode leading to the sub_tree as well as the pending cat_eod
106
107 // return true if the last read entry has already been read
108 // and has not to be counted again. This is never the case for catalogue but may occure
109 // with escape_catalogue (where from the 'virtual').
110 // last this method gives a valid result only if the last read() entry is a directory as
111 // only directory may be read() twice.
112 virtual bool read_second_time_dir() const { return false; };
113
114
115 // Additions methods. The addition is also iterative but uses its specific current_add directory pointer
116
117 void reset_add();
118
120 // real implementation is only needed in escape_catalogue class, here there nothing to be done
121 virtual void pre_add(const cat_entree *ref) const {};
122 virtual void pre_add_ea(const cat_entree *ref) const {};
123 virtual void pre_add_crc(const cat_entree *ref) const {};
124 virtual void pre_add_dirty() const {};
125 virtual void pre_add_ea_crc(const cat_entree *ref) const {};
126 virtual void pre_add_waste_mark() const {};
127 virtual void pre_add_failed_mark() const {};
128 virtual void pre_add_fsa(const cat_entree *ref) const {};
129 virtual void pre_add_fsa_crc(const cat_entree *ref) const {};
130 virtual escape *get_escape_layer() const { return nullptr; };
131
132 void add(cat_entree *ref); // add at end of catalogue (sequential point of view)
133 void re_add_in(const std::string &subdirname); // return into an already existing subdirectory for further addition
134 void re_add_in_replace(const cat_directory &dir); // same as re_add_in but also set the properties of the existing directory to those of the given argument
135 void add_in_current_read(cat_nomme *ref); // add in currently read directory
136 const cat_directory & get_current_add_dir() const { if(current_add == nullptr) throw SRC_BUG; return *current_add; };
137
138
139
140 // Comparison methods. The comparision is here also iterative and uses its specific current_compare directory pointer
141
142 void reset_compare() const;
143 bool compare(const cat_entree * name, const cat_entree * & extracted) const;
144 // returns true if the ref exists, and gives it back in second argument as it is in the current catalogue.
145 // returns false is no entry of that nature exists in the catalogue (in the current directory)
146 // if ref is a directory, the operation is normaly relative to the directory itself, but
147 // such a call implies a chdir to that directory. thus, a call with an EOD is necessary to
148 // change to the parent directory.
149 // note :
150 // if a directory is not present, returns false, but records the inexistant subdirectory
151 // structure defined by the following calls to this routine, this to be able to know when
152 // the last available directory is back the current one when changing to parent directory,
153 // and then proceed with normal comparison of inode. In this laps of time, the call will
154 // always return false, while it temporary stores the missing directory structure
155
156
157
158 // non interative methods
159
160
164 infinint update_destroyed_with(const catalogue & ref);
165
166
172 void update_absent_with(const catalogue & ref, infinint aborting_next_etoile);
173
174
176 void drop_all_non_detruits();
177
182 bool is_subset_of(const catalogue & ref) const;
183
185 void reset_dump() const;
186
188 void dump(const pile_descriptor & pdesc) const;
189
190 void listing(bool isolated,
191 const mask &selection,
192 const mask & subtree,
193 bool filter_unsaved,
194 bool list_ea,
195 bool sizes_in_bytes,
196 std::string marge) const;
197 void tar_listing(bool isolated,
198 const mask & selection,
199 const mask & subtree,
200 bool filter_unsaved,
201 bool list_ea,
202 bool sizes_in_bytes,
203 std::string beginning) const;
204 void xml_listing(bool isolated,
205 const mask & selection,
206 const mask & subtree,
207 bool filter_unsaved,
208 bool list_ea,
209 bool sizes_in_bytes,
210 std::string beginning) const;
211 void slice_listing(bool isolated,
212 const mask & selection,
213 const mask & subtree,
214 const slice_layout & slicing) const;
215
216 entree_stats get_stats() const { return stats; };
217
219 bool is_empty() const { if(contenu == nullptr) throw SRC_BUG; return contenu->is_empty(); };
220
221 const cat_directory *get_contenu() const { return contenu; }; // used by data_tree
222
223 const label & get_data_name() const { return ref_data_name; };
224 datetime get_root_dir_last_modif() const { return contenu->get_last_modif(); };
225
227 void launch_recursive_has_changed_update() const { contenu->recursive_has_changed_update(); };
228
230 void set_all_mirage_s_inode_wrote_field_to(bool val) const { const_cast<cat_directory *>(contenu)->set_all_mirage_s_inode_wrote_field_to(val); };
231
232 datetime get_root_mtime() const { return contenu->get_last_modif(); };
233
235 void reset_all();
236
237 void set_to_unsaved_data_and_FSA() { if(contenu == nullptr) throw SRC_BUG; contenu->recursively_set_to_unsaved_data_and_FSA(); };
238
240 void change_location(const pile_descriptor & pdesc);
241
242 protected:
243 entree_stats & access_stats() { return stats; };
244 void set_data_name(const label & val) { ref_data_name = val; };
245 void copy_detruits_from(const catalogue & ref); // needed for escape_catalogue implementation only.
246
247 const cat_eod * get_r_eod_address() const { return & r_eod; }; // cat_eod are never stored in the catalogue
248 // however it is sometimes required to return such a reference to a valid object
249 // owned by the catalogue.
250
251
254 void swap_stuff(catalogue & ref);
255
256 private :
257 cat_directory *contenu;
258 path out_compare;
259 cat_directory *current_compare;
260 cat_directory *current_add;
261 cat_directory *current_read;
262 path *sub_tree;
263 signed int sub_count;
264 entree_stats stats;
265 label ref_data_name;
266
267 void partial_copy_from(const catalogue &ref);
268 void detruire();
269
270 static const cat_eod r_eod; // needed to return eod reference, without taking risk of saturating memory
271 static const U_I CAT_CRC_SIZE;
272 };
273
274
275
277
278 } // end of namespace
279
280 #endif
libdar::on_pool
Definition: on_pool.hpp:52
libdar::catalogue::update_destroyed_with
infinint update_destroyed_with(const catalogue &ref)
cat_nomme.hpp
base class of all objects contained in a catalogue and that can be named
mem_ui.hpp
class mem_ui definition. This class is to be used as parent class to handle user_interaction object m...
cat_directory.hpp
class used to organize objects in tree in catalogue as like directories in a filesystem ...
integers.hpp
are defined here basic integer types that tend to be portable
libdar::catalogue
the catalogue class which gather all objects contained in a give archive
Definition: catalogue.hpp:62
libdar::catalogue::reset_all
void reset_all()
reset all pointers to the root (a bit better than reset_add() + reset_read() + reset_compare() + rese...
generic_file.hpp
class generic_file is defined here as well as class fichierthe generic_file interface is widely used ...
label.hpp
define the datastructure "label" used to identify slice membership to an archive
libdar::user_interaction
This is a pure virtual class that is used by libdar when interaction with the user is required...
Definition: user_interaction.hpp:98
libdar::cat_directory::recursive_has_changed_update
void recursive_has_changed_update() const
ask recursive update for the recursive_has_changed field
libdar::catalogue::swap_stuff
void swap_stuff(catalogue &ref)
libdar::catalogue::update_absent_with
void update_absent_with(const catalogue &ref, infinint aborting_next_etoile)
libdar::catalogue::reset_dump
void reset_dump() const
before dumping the catalogue, need to set all hardlinked inode they have not been saved once ...
slice_layout.hpp
object describing the slicing of an archive
libdar::cat_directory
the cat_directory inode class
Definition: cat_directory.hpp:51
libdar::cat_directory::is_empty
bool is_empty() const
whether this cat_directory is empty or not
Definition: cat_directory.hpp:125
libdar::catalogue::pre_add
virtual void pre_add(const cat_entree *ref) const
catalogue extension routines for escape sequence
Definition: catalogue.hpp:121
user_interaction.hpp
defines the interaction between libdar and the user.Three classes are defined
path.hpp
here is the definition of the path classthe path class handle path and provide several operation on t...
libdar::catalogue::launch_recursive_has_changed_update
void launch_recursive_has_changed_update() const
recursive evaluation of directories that have changed (make the cat_directory::get_recurisve_has_chan...
Definition: catalogue.hpp:227
escape.hpp
class escape definition, used for sequential reading of archivesThe class escape is used to insert es...
libdar::catalogue::is_subset_of
bool is_subset_of(const catalogue &ref) const
libdar::mem_ui::mem_ui
mem_ui(const user_interaction &dialog)
constructor
Definition: mem_ui.hpp:62
libdar::cat_nomme
the base class for all entry that have a name
Definition: cat_nomme.hpp:44
cat_entree.hpp
base class for all object contained in a catalogue
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
libdar::catalogue::set_all_mirage_s_inode_wrote_field_to
void set_all_mirage_s_inode_wrote_field_to(bool val) const
recursive setting of mirage inode_wrote flag
Definition: catalogue.hpp:230
mask.hpp
here lies a collection of mask classes
libdar::compression
compression
the different compression algorithm available
Definition: compressor.hpp:43
datetime.hpp
this file contains the definition of class datetime that stores unix times in a portable way ...
libdar::catalogue::drop_all_non_detruits
void drop_all_non_detruits()
remove/destroy from "this" all objects that are neither directory nor detruit objects ...
libdar::mem_ui
class mem_ui to keep a copy of a user_interaction object
Definition: mem_ui.hpp:53
libdar::catalogue::is_empty
bool is_empty() const
whether the catalogue is empty or not
Definition: catalogue.hpp:219
compressor.hpp
compression engine implementation
on_pool.hpp
this is the base class of object that can be allocated on a memory pool
libdar::archive_version
class archive_version manages the version of the archive format
Definition: archive_version.hpp:44
libdar::cat_entree
the root class from all other inherite for any entry in the catalogue
Definition: cat_entree.hpp:85
libdar::catalogue::dump
void dump(const pile_descriptor &pdesc) const
write down the whole catalogue to file
libdar::catalogue::change_location
void change_location(const pile_descriptor &pdesc)
change location where to find EA, FSA and DATA for all the objects of the catalogue ...
libdar
libdar namespace encapsulate all libdar symbols
Definition: archive.hpp:47
libdar::path
the class path is here to manipulate paths in the Unix notation: using'/'
Definition: path.hpp:50