1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121 | // Copyright (C) 2012-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef MASTER_LOADER_CALLBACKS_H
#define MASTER_LOADER_CALLBACKS_H
#include <exceptions/exceptions.h>
#include <boost/shared_ptr.hpp><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <functional><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
#include <string><--- Include file: not found. Please note: Cppcheck does not need standard library headers to get proper results.
namespace isc {
namespace dns {
class Name;
class RRClass;
class RRType;
class RRTTL;
namespace rdata {
class Rdata;
typedef boost::shared_ptr<Rdata> RdataPtr;
}
/// \brief Type of callback to add a RR.
///
/// This type of callback is used by the loader to report another loaded
/// RR. The Rdata is no longer preserved by the loader and is fully
/// owned by the callback.
///
/// \param name The domain name where the RR belongs.
/// \param rrclass The class of the RR.
/// \param rrtype Type of the RR.
/// \param rrttl Time to live of the RR.
/// \param rdata The actual carried data of the RR.
typedef std::function<void(const Name& name, const RRClass& rrclass,
const RRType& rrtype, const RRTTL& rrttl,
const rdata::RdataPtr& rdata)>
AddRRCallback;
/// \brief Set of issue callbacks for a loader.
///
/// This holds a set of callbacks by which a loader (such as MasterLoader)
/// can report loaded RRsets, errors and other unusual conditions.
///
/// All the callbacks must be set.
class MasterLoaderCallbacks {
public:
/// \brief Type of one callback to report problems.
///
/// This is the type of one callback used to report an unusual
/// condition or error.
///
/// \param source_name The name of the source where the problem happened.
/// This is usually a file name.
/// \param source_line Position of the problem, counted in lines from the
/// beginning of the source.
/// \param reason Human readable description of what happened.
typedef std::function<void(const std::string& source_name,
size_t source_line,
const std::string& reason)> IssueCallback;
/// \brief Constructor
///
/// Initializes the callbacks.
///
/// \param error The error callback to use.
/// \param warning The warning callback to use.
/// \throw isc::InvalidParameter if any of the callbacks is empty.
MasterLoaderCallbacks(const IssueCallback& error,
const IssueCallback& warning) :
error_(error),
warning_(warning) {
if (!error_ || !warning_) {
isc_throw(isc::InvalidParameter,
"Empty function passed as callback");
}
}
/// \brief Call callback for serious errors
///
/// This is called whenever there's a serious problem which makes the data
/// being loaded unusable. Further processing may or may not happen after
/// this (for example to detect further errors), but the data should not
/// be used.
///
/// It calls whatever was passed to the error parameter to the constructor.
///
/// If the caller of the loader wants to abort, it is possible to throw
/// from the callback, which aborts the load.
void error(const std::string& source_name, size_t source_line,
const std::string& reason) const {
error_(source_name, source_line, reason);
}
/// \brief Call callback for potential problems
///
/// This is called whenever a minor problem is discovered. This might mean
/// the data is completely OK, it just looks suspicious.
///
/// It calls whatever was passed to the warn parameter to the constructor.
///
/// The loading will continue after the callback. If the caller wants to
/// abort (which is probably not a very good idea, since warnings
/// may be false positives), it is possible to throw from inside the
/// callback.
void warning(const std::string& source_name, size_t source_line,
const std::string& reason) const {
warning_(source_name, source_line, reason);
}
private:
const IssueCallback error_;
const IssueCallback warning_;
};
}
}
#endif // MASTER_LOADER_CALLBACKS_H
|