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

Loading...
Searching...
No Matches
crc.hpp
Go to the documentation of this file.
1/*********************************************************************/
2// dar - disk archive - a backup/restoration program
3// Copyright (C) 2002-2024 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18//
19// to contact the author, see the AUTHOR file
20/*********************************************************************/
21
25
26#ifndef CRC_HPP
27#define CRC_HPP
28
29#include "../my_config.h"
30
31#include <string>
32#include <list>
33#include "integers.hpp"
34#include "storage.hpp"
35#include "infinint.hpp"
36#include "proto_generic_file.hpp"
37
38 namespace libdar
39{
40
43
45
46 class crc
47 {
48 public:
49 static constexpr U_I OLD_CRC_SIZE = 2;
50
51 crc() {};
52 crc(const crc & ref) = default;
53 crc(crc && ref) noexcept = default;
54 crc & operator = (const crc & ref) = default;
55 crc & operator = (crc && ref) noexcept = default;
56 virtual ~crc() = default;
57
58 virtual bool operator == (const crc & ref) const = 0;
59 bool operator != (const crc & ref) const { return ! (*this == ref); };
60
61 virtual void compute(const infinint & offset, const char *buffer, U_I length) = 0;
62 virtual void compute(const char *buffer, U_I length) = 0; // for sequential read only
63 virtual void clear() = 0;
64 virtual void dump(proto_generic_file & f) const = 0;
65 virtual std::string crc2str() const = 0;
66 virtual infinint get_size() const = 0;
67 virtual crc *clone() const = 0;
68 };
69
71 extern crc *create_crc_from_file(proto_generic_file & f, bool old = false);
72
74 extern crc *create_crc_from_size(infinint width);
75
77
78 class crc_i : public crc
79 {
80 public:
81 crc_i(const infinint & width);
82 crc_i(const infinint & width, proto_generic_file & f);
83 crc_i(const crc_i & ref) : size(ref.size), cyclic(ref.size) { copy_data_from(ref); pointer = cyclic.begin(); };
84 crc_i(crc_i && ref) noexcept = default;
85 crc_i & operator = (const crc_i & ref) { copy_from(ref); return *this; };
86 crc_i & operator = (crc_i && ref) noexcept = default;
87 ~crc_i() = default;
88
89 bool operator == (const crc & ref) const override;
90
91 virtual void compute(const infinint & offset, const char *buffer, U_I length) override;
92 virtual void compute(const char *buffer, U_I length) override; // for sequential read only
93 virtual void clear() override;
94 virtual void dump(proto_generic_file & f) const override;
95 virtual std::string crc2str() const override;
96 virtual infinint get_size() const override { return size; };
97
98 protected:
99 virtual crc *clone() const override { crc *tmp = new (std::nothrow) crc_i(*this); if(tmp == nullptr) throw Ememory("crc"); return tmp; };
100
101 private:
102
103 infinint size;
104 storage::iterator pointer;
105 storage cyclic;
106
107 void copy_from(const crc_i & ref);
108 void copy_data_from(const crc_i & ref);
109 };
110
111
113
114 class crc_n : public crc
115 {
116 public:
117
118 crc_n(U_I width);
119 crc_n(U_I width, proto_generic_file & f);
120 crc_n(const crc_n & ref) { copy_from(ref); };
121 crc_n(crc_n && ref) noexcept = default;
122 crc_n & operator = (const crc_n & ref);
123 crc_n & operator = (crc_n && ref) noexcept = default;
124 ~crc_n() { destroy(); };
125
126 bool operator == (const crc & ref) const override;
127
128 virtual void compute(const infinint & offset, const char *buffer, U_I length) override;
129 virtual void compute(const char *buffer, U_I length) override; // for sequential read only
130 virtual void clear() override;
131 virtual void dump(proto_generic_file & f) const override;
132 virtual std::string crc2str() const override;
133 virtual infinint get_size() const override { return size; };
134
135 protected:
136 virtual crc *clone() const override { crc *tmp = new (std::nothrow) crc_n(*this); if(tmp == nullptr) throw Ememory("crc"); return tmp; };
137
138 private:
139
140 U_I size;
141 unsigned char *pointer;
142 unsigned char *cyclic;
143
144 void alloc(U_I width);
145 void copy_from(const crc_n & ref);
146 void copy_data_from(const crc_n & ref);
147 void destroy();
148 };
149
150
152
153} // end of namespace
154
155
156#endif
libdar::Ememory
exception used when memory has been exhausted
Definition erreurs.hpp:127
libdar::crc_i
crc implementation based on infinint
Definition crc.hpp:79
libdar::crc_i::cyclic
storage cyclic
the checksum storage
Definition crc.hpp:105
libdar::crc_i::pointer
storage::iterator pointer
points to the next byte to modify
Definition crc.hpp:104
libdar::crc_i::size
infinint size
size of the checksum
Definition crc.hpp:103
libdar::crc_n
crc implementation based on U_I
Definition crc.hpp:115
libdar::crc_n::cyclic
unsigned char * cyclic
the checksum storage (non infinint mode)
Definition crc.hpp:142
libdar::crc_n::size
U_I size
size of checksum (non infinint mode)
Definition crc.hpp:140
libdar::crc_n::pointer
unsigned char * pointer
points to the next byte to modify (non infinint mode)
Definition crc.hpp:141
libdar::crc
pure virtual class defining interface of a CRC object
Definition crc.hpp:47
libdar::infinint
the arbitrary large positive integer class
Definition real_infinint.hpp:62
libdar::proto_generic_file
ancestor class of generic_file
Definition proto_generic_file.hpp:55
libdar::storage
arbitrary large storage structure
Definition storage.hpp:53
libdar::create_crc_from_file
crc * create_crc_from_file(proto_generic_file &f, bool old=false)
generate a CRC object reading it from file
libdar::create_crc_from_size
crc * create_crc_from_size(infinint width)
generate a CRC object with adhoc width based on a file size
infinint.hpp
switch module to limitint (32 ou 64 bits integers) or infinint
integers.hpp
are defined here basic integer types that tend to be portable
libdar
libdar namespace encapsulate all libdar symbols
Definition archive.hpp:47
proto_generic_file.hpp
precursor class of generic_file used to avoid cyclic dependencies with storage and infinint
storage.hpp
contains a class that permits arbitrary large data storage