class LookButDontTouch
{
public:
- LookButDontTouch()
- {
- }
+ LookButDontTouch() = default;
LookButDontTouch(shared_ptr<T>&& records) :
d_records(std::move(records))
{
return false;
}
- ~GeoIPInterfaceDAT() {}
+ ~GeoIPInterfaceDAT() = default;
private:
unsigned int d_db_type;
boost::optional<int>& alt, boost::optional<int>& prec)
= 0;
- virtual ~GeoIPInterface() {}
+ virtual ~GeoIPInterface() = default;
static unique_ptr<GeoIPInterface> makeInterface(const string& dbStr);
class LdapAuthenticator
{
public:
- virtual ~LdapAuthenticator() {}
+ virtual ~LdapAuthenticator() = default;
virtual bool authenticate(LDAP* connection) = 0;
virtual std::string getError() const = 0;
};
class LMDBResourceRecord : public DNSResourceRecord
{
public:
- LMDBResourceRecord() {}
+ LMDBResourceRecord() = default;
LMDBResourceRecord(const DNSResourceRecord& rr) :
DNSResourceRecord(rr), ordername(false) {}
class CoRemote
{
public:
- virtual ~CoRemote() {}
+ virtual ~CoRemote() = default;
virtual void sendReceive(const string& send, string& receive) = 0;
virtual void receive(string& rcv) = 0;
virtual void send(const string& send) = 0;
// I think
}
-CoWrapper::~CoWrapper()
-{
-}
+CoWrapper::~CoWrapper() = default;
void CoWrapper::launch()
{
struct QuestionIdentifier
{
- QuestionIdentifier()
- {}
+ QuestionIdentifier() = default;
bool operator<(const QuestionIdentifier& rhs) const
{
struct MapCombo
{
- MapCombo() {
- }
- ~MapCombo() {
- }
+ MapCombo() = default;
+ ~MapCombo() = default;
MapCombo(const MapCombo&) = delete;
MapCombo& operator=(const MapCombo&) = delete;
struct MapCombo
{
- MapCombo() {
- }
- ~MapCombo() {
- }
+ MapCombo() = default;
+ ~MapCombo() = default;
MapCombo(const MapCombo &) = delete;
MapCombo & operator=(const MapCombo &) = delete;
map<uint32_t, Answer> d_freshness;
- SecondarySenderReceiver()
- {
- }
-
void deliverTimeout(const Identifier& /* i */)
{
}
struct MapCombo
{
- MapCombo() {}
- ~MapCombo() {}
+ MapCombo() = default;
+ ~MapCombo() = default;
MapCombo(const MapCombo&) = delete;
MapCombo& operator=(const MapCombo&) = delete;
comment.content = std::move(row[5]);
}
-SSqlStatement::~SSqlStatement() {
// make sure vtable won't break
-}
+SSqlStatement::~SSqlStatement() = default;
{
public:
Comment() : modified_at(0), domain_id(0) {};
- ~Comment() {};
+ ~Comment() = default;
// data
DNSName qname; //!< the name of the associated RRset, for example: www.powerdns.com
*/
virtual bool list(const DNSName &target, int domain_id, bool include_disabled=false)=0;
- virtual ~DNSBackend(){};
+ virtual ~DNSBackend() = default;
//! fills the soadata struct with the SOA details. Returns false if there is no SOA.
virtual bool getSOA(const DNSName &name, SOAData &soadata);
{
public:
BackendFactory(const string &name) : d_name(name) {}
- virtual ~BackendFactory(){}
+ virtual ~BackendFactory() = default;
virtual DNSBackend *make(const string &suffix)=0;
virtual DNSBackend *makeMetadataOnly(const string &suffix)
{
public:
static const size_t s_maxDNSNameLength = 255;
- DNSName() {} //!< Constructs an *empty* DNSName, NOT the root!
+ DNSName() = default; //!< Constructs an *empty* DNSName, NOT the root!
// Work around assertion in some boost versions that do not like self-assignment of boost::container::string
DNSName& operator=(const DNSName& rhs)
{
struct SuffixMatchNode
{
public:
- SuffixMatchNode()
- {}
+ SuffixMatchNode() = default;
SuffixMatchTree<bool> d_tree;
void add(const DNSName& dnsname)
static string upgradeContent(const DNSName& qname, const QType& qtype, const string& content);
virtual std::string getZoneRepresentation(bool noDot=false) const = 0;
- virtual ~DNSRecordContent() {}
+ virtual ~DNSRecordContent() = default;
virtual void toPacket(DNSPacketWriter& pw) const = 0;
// returns the wire format of the content, possibly including compressed pointers pointing to the owner name (unless canonic or lowerCase are set)
string serialize(const DNSName& qname, bool canonic=false, bool lowerCase=false) const
conv.xfrHexBlob(d_cert, true);
)
-DSRecordContent::DSRecordContent() {}
+DSRecordContent::DSRecordContent() = default;
boilerplate_conv(DS,
conv.xfr16BitInt(d_tag);
conv.xfr8BitInt(d_algorithm);
conv.xfrHexBlob(d_digest, true); // keep reading across spaces
)
-CDSRecordContent::CDSRecordContent() {}
+CDSRecordContent::CDSRecordContent() = default;
boilerplate_conv(CDS,
conv.xfr16BitInt(d_tag);
conv.xfr8BitInt(d_algorithm);
conv.xfrHexBlob(d_digest, true); // keep reading across spaces
)
-DLVRecordContent::DLVRecordContent() {}
+DLVRecordContent::DLVRecordContent() = default;
boilerplate_conv(DLV,
conv.xfr16BitInt(d_tag);
conv.xfr8BitInt(d_algorithm);
conv.xfrBlob(d_signature);
)
-RRSIGRecordContent::RRSIGRecordContent() {}
+RRSIGRecordContent::RRSIGRecordContent() = default;
boilerplate_conv(DNSKEY,
conv.xfr16BitInt(d_flags);
conv.xfr8BitInt(d_algorithm);
conv.xfrBlob(d_key);
)
-DNSKEYRecordContent::DNSKEYRecordContent() {}
+DNSKEYRecordContent::DNSKEYRecordContent() = default;
boilerplate_conv(CDNSKEY,
conv.xfr16BitInt(d_flags);
conv.xfr8BitInt(d_algorithm);
conv.xfrBlob(d_key);
)
-CDNSKEYRecordContent::CDNSKEYRecordContent() {}
+CDNSKEYRecordContent::CDNSKEYRecordContent() = default;
boilerplate_conv(RKEY,
conv.xfr16BitInt(d_flags);
conv.xfr8BitInt(d_algorithm);
conv.xfrBlob(d_key);
)
-RKEYRecordContent::RKEYRecordContent() {}
+RKEYRecordContent::RKEYRecordContent() = default;
boilerplate_conv(NID,
conv.xfr16BitInt(d_preference);
{
public:
includeboilerplate(TSIG)
- TSIGRecordContent() {}
+ TSIGRecordContent() = default;
uint16_t d_origID{0};
uint16_t d_fudge{0};
class OPTRecordContent : public DNSRecordContent
{
public:
- OPTRecordContent(){}
+ OPTRecordContent() = default;
includeboilerplate(OPT)
void getData(vector<pair<uint16_t, string> > &opts) const;
private:
{
public:
static void report(void);
- NSECRecordContent()
- {}
+ NSECRecordContent() = default;
NSECRecordContent(const string& content, const DNSName& zone=DNSName());
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
{
public:
static void report(void);
- NSEC3RecordContent()
- {}
+ NSEC3RecordContent() = default;
NSEC3RecordContent(const string& content, const DNSName& zone=DNSName());
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
{
public:
static void report(void);
- CSYNCRecordContent()
- {}
+ CSYNCRecordContent() = default;
CSYNCRecordContent(const string& content, const DNSName& zone=DNSName());
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
{
public:
static void report(void);
- NSEC3PARAMRecordContent()
- {}
+ NSEC3PARAMRecordContent() = default;
NSEC3PARAMRecordContent(const string& content, const DNSName& zone=DNSName());
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
{
public:
static void report(void);
- LOCRecordContent()
- {}
+ LOCRecordContent() = default;
LOCRecordContent(const string& content, const string& zone="");
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
class EUI48RecordContent : public DNSRecordContent
{
public:
- EUI48RecordContent() {};
+ EUI48RecordContent() = default;
static void report(void);
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
static std::shared_ptr<DNSRecordContent> make(const string& zone); // FIXME400: DNSName& zone?
class EUI64RecordContent : public DNSRecordContent
{
public:
- EUI64RecordContent() {};
+ EUI64RecordContent() = default;
static void report(void);
static std::shared_ptr<DNSRecordContent> make(const DNSRecord &dr, PacketReader& pr);
static std::shared_ptr<DNSRecordContent> make(const string& zone); // FIXME400: DNSName& zone?
class APLRecordContent : public DNSRecordContent
{
public:
- APLRecordContent() {};
+ APLRecordContent() = default;
includeboilerplate(APL)
private:
std::vector<APLRDataElement> aplrdata;
{
public:
explicit DNSCryptoKeyEngine(unsigned int algorithm) : d_algorithm(algorithm) {}
- virtual ~DNSCryptoKeyEngine() {};
+ virtual ~DNSCryptoKeyEngine() = default;
[[nodiscard]] virtual string getName() const = 0;
using stormap_t = std::map<std::string, std::string>;
class IPObfuscator
{
public:
- virtual ~IPObfuscator()
- {
- }
+ virtual ~IPObfuscator() = default;
virtual uint32_t obf4(uint32_t orig)=0;
virtual struct in6_addr obf6(const struct in6_addr& orig)=0;
};
{
}
- ~IPSeqObfuscator()
- {}
-
static std::unique_ptr<IPObfuscator> make()
{
return std::make_unique<IPSeqObfuscator>();
}
}
- ~IPCipherObfuscator()
- {}
static std::unique_ptr<IPObfuscator> make(std::string key, bool decrypt)
{
return std::make_unique<IPCipherObfuscator>(key, decrypt);
static const size_t EDNSCookieSecretSize = 32;
static const size_t EDNSCookieOptSize = 24;
- EDNSCookiesOpt(){};
+ EDNSCookiesOpt() = default;
EDNSCookiesOpt(const std::string& option);
EDNSCookiesOpt(const char* option, unsigned int len);
struct AtomicBucket
{
// We need the constructors in this case, since atomics have a disabled copy constructor.
- AtomicBucket() {}
+ AtomicBucket() = default;
AtomicBucket(std::string name, uint64_t boundary, uint64_t val) :
d_name(std::move(name)), d_boundary(boundary), d_count(val) {}
AtomicBucket(const AtomicBucket& rhs) :
class NetmaskGroup
{
public:
- NetmaskGroup() noexcept {
- }
+ NetmaskGroup() noexcept = default;
//! If this IP address is matched by any of the classes within
d_ticketKeys.write_lock()->set_capacity(capacity);
}
-OpenSSLTLSTicketKeysRing::~OpenSSLTLSTicketKeysRing()
-{
-}
+OpenSSLTLSTicketKeysRing::~OpenSSLTLSTicketKeysRing() = default;
void OpenSSLTLSTicketKeysRing::addKey(std::shared_ptr<OpenSSLTLSTicketKey>&& newKey)
{
class ReadWriteLock
{
public:
- ReadWriteLock()
- {
- }
+ ReadWriteLock() = default;
ReadWriteLock(const ReadWriteLock& rhs) = delete;
ReadWriteLock(ReadWriteLock&& rhs) = delete;
{
}
- explicit LockGuarded()
- {
- }
+ explicit LockGuarded() = default;
LockGuardedTryHolder<T> try_lock()
{
{
}
- explicit SharedLockGuarded()
- {
- }
+ explicit SharedLockGuarded() = default;
SharedLockGuardedTryHolder<T> try_write_lock()
{
return nullptr;
}
-AuthLua4::~AuthLua4() { }
+AuthLua4::~AuthLua4() = default;
#include "ext/luawrapper/include/LuaContext.hpp"
#include "dns_random.hh"
-BaseLua4::BaseLua4() {
-}
+BaseLua4::BaseLua4() = default;
void BaseLua4::loadFile(const std::string& fname)
{
postLoad();
}
-BaseLua4::~BaseLua4() { }
+BaseLua4::~BaseLua4() = default;
{
d_checkerThreadStarted.clear();
}
- ~IsUpOracle()
- {
- }
+ ~IsUpOracle() = default;
bool isUp(const ComboAddress& remote, const opts_t& opts);
bool isUp(const ComboAddress& remote, const std::string& url, const opts_t& opts);
bool isUp(const CheckDesc& cd);
template<typename T> bool rfc1982LessThan(T a, T b)
{
- static_assert(std::is_unsigned<T>::value, "rfc1982LessThan only works for unsigned types");
- typedef typename std::make_signed<T>::type signed_t;
- return static_cast<signed_t>(a - b) < 0;
+ static_assert(std::is_unsigned_v<T>, "rfc1982LessThan only works for unsigned types");
+ return std::make_signed_t<T>(a - b) < 0;
}
// fills container with ranges, so {posbegin,posend}
// I'm not very OCD, but I appreciate loglines like "processing 1 delta", "processing 2 deltas" :-)
template <typename Integer,
-typename std::enable_if_t<std::is_integral<Integer>::value, bool> = true>
+typename std::enable_if_t<std::is_integral_v<Integer>, bool> = true>
const char* addS(Integer siz, const char* singular = "", const char *plural = "s")
{
if (siz == 1) {
}
template <typename C,
-typename std::enable_if_t<std::is_class<C>::value, bool> = true>
+typename std::enable_if_t<std::is_class_v<C>, bool> = true>
const char* addS(const C& c, const char* singular = "", const char *plural = "s")
{
return addS(c.size(), singular, plural);
FDMultiplexer() :
d_inrun(false)
{}
- virtual ~FDMultiplexer()
- {}
+ virtual ~FDMultiplexer() = default;
// The maximum number of events processed in a single run, not the maximum of watched descriptors
static constexpr unsigned int s_maxevents = 1024;
if (this->d_slot->lock()->LoggedIn()) LoadAttributes();
}
-Pkcs11Token::~Pkcs11Token() {
-}
+Pkcs11Token::~Pkcs11Token() = default;
bool PKCS11ModuleSlotLogin(const std::string& module, const string& tokenId, const std::string& pin)
{
}
PKCS11DNSCryptoKeyEngine::PKCS11DNSCryptoKeyEngine(unsigned int algorithm): DNSCryptoKeyEngine(algorithm) {}
-PKCS11DNSCryptoKeyEngine::~PKCS11DNSCryptoKeyEngine() {}
+PKCS11DNSCryptoKeyEngine::~PKCS11DNSCryptoKeyEngine() = default;
PKCS11DNSCryptoKeyEngine::PKCS11DNSCryptoKeyEngine(const PKCS11DNSCryptoKeyEngine& orig) : DNSCryptoKeyEngine(orig.d_algorithm) {}
void PKCS11DNSCryptoKeyEngine::create(unsigned int bits) {
public:
PollFDMultiplexer(unsigned int /* maxEventsHint */)
{}
- ~PollFDMultiplexer()
- {
- }
int run(struct timeval* tv, int timeout = 500) override;
void getAvailableFDs(std::vector<int>& fds, int timeout) override;
}
}
- ~SHADigest()
- {
- // No free of md needed and mdctx is cleaned up by unique_ptr
- }
+ // No free of md needed and mdctx is cleaned up by unique_ptr
+ ~SHADigest() = default;
void process(const std::string& msg)
{
}
private:
- typename std::aligned_storage<sizeof(base_t), CPU_LEVEL1_DCACHE_LINESIZE>::type counter;
+ typename std::aligned_storage_t<sizeof(base_t), CPU_LEVEL1_DCACHE_LINESIZE> counter;
};
typedef stat_t_trait<uint64_t> stat_t;
return d_stats[key].get();
}
-StatBag::~StatBag()
-{
-}
+StatBag::~StatBag() = default;
template<typename T, typename Comp>
StatRing<T,Comp>::StatRing(unsigned int size)
struct Stat
{
- Stat()
- {
- }
-
+ Stat() {};
uint64_t queries{0};
uint64_t noerrors{0};
uint64_t nxdomains{0};
{
}
- virtual ~OpenSSLSession()
- {
- }
-
std::unique_ptr<SSL_SESSION, void(*)(SSL_SESSION*)> getNative()
{
return std::move(d_sess);
class TLSSession
{
public:
- virtual ~TLSSession()
- {
- }
+ virtual ~TLSSession() = default;
};
class TLSConnection
{
public:
- virtual ~TLSConnection() { }
+ virtual ~TLSConnection() = default;
virtual void doHandshake() = 0;
virtual IOState tryConnect(bool fastOpen, const ComboAddress& remote) = 0;
virtual void connect(bool fastOpen, const ComboAddress& remote, const struct timeval& timeout) = 0;
{
d_rotatingTicketsKey.clear();
}
- virtual ~TLSCtx() {}
+ virtual ~TLSCtx() = default;
virtual std::unique_ptr<TLSConnection> getConnection(int socket, const struct timeval& timeout, time_t now) = 0;
virtual std::unique_ptr<TLSConnection> getClientConnection(const std::string& host, bool hostIsAddr, int socket, const struct timeval& timeout) = 0;
virtual void rotateTicketsKey(time_t now) = 0;
return doAXFR(q->qdomain, q, outsock);
}
-TCPNameserver::~TCPNameserver()
-{
-}
-
+TCPNameserver::~TCPNameserver() = default;
TCPNameserver::TCPNameserver()
{
d_maxTransactionsPerConn = ::arg().asNum("max-tcp-transactions-per-conn");
d_server_socket.bind(d_local);
d_server_socket.listen();
}
- virtual ~Server() { };
+ virtual ~Server() = default;
ComboAddress d_local;
{
public:
WebServer(string listenaddress, int port);
- virtual ~WebServer() { };
+ virtual ~WebServer() = default;
#ifdef RECURSOR
void setSLog(Logr::log_t log)
projects / thirdparty / pdns.git / commitdiff
