| Disk ARchive 2.8.5 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-2026 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::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::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
my_config.h
include macro defined by the configure script and some specific additional ones
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