BIND 10 trac2144, updated. 01aec1c7f772752e9a0bc9f3885257f7866f0a4c made objects non-copyable or non-assignable by inheritance
BIND 10 source code commits
bind10-changes at lists.isc.org
Sat Aug 18 07:34:55 UTC 2012
The branch, trac2144 has been updated
via 01aec1c7f772752e9a0bc9f3885257f7866f0a4c (commit)
from 802589cc9ba0d647b7cb80b84f951f7f3cc6615a (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 01aec1c7f772752e9a0bc9f3885257f7866f0a4c
Author: Francis Dupont <fdupont at isc.org>
Date: Sat Aug 18 09:34:26 2012 +0200
made objects non-copyable or non-assignable by inheritance
-----------------------------------------------------------------------
Summary of changes:
src/bin/auth/auth_config.h | 10 ++----
src/bin/auth/auth_srv.cc | 7 ++--
src/bin/auth/auth_srv.h | 11 ++----
src/bin/auth/command.cc | 9 ++---
src/bin/auth/query.h | 5 ++-
src/bin/auth/statistics.cc | 5 +--
src/bin/dhcp4/dhcp4_srv.h | 4 +--
src/bin/dhcp6/dhcp6_srv.h | 4 +--
src/bin/resolver/resolver.cc | 7 ++--
src/bin/resolver/resolver.h | 14 +++-----
src/bin/resolver/tests/resolver_config_unittest.cc | 6 ++--
src/lib/acl/acl.h | 5 +--
src/lib/acl/dns.h | 4 ++-
src/lib/acl/dnsname_check.h | 4 ++-
src/lib/acl/loader.h | 4 ++-
src/lib/acl/logic_check.h | 8 +++--
src/lib/asiodns/dns_answer.h | 8 ++---
src/lib/asiodns/dns_lookup.h | 8 ++---
src/lib/asiodns/dns_server.h | 3 +-
src/lib/asiodns/dns_service.cc | 4 ++-
src/lib/asiodns/dns_service.h | 10 ++----
src/lib/asiodns/sync_udp_server.h | 5 ++-
src/lib/asiodns/tcp_server.h | 5 ++-
src/lib/asiodns/udp_server.cc | 4 ++-
src/lib/asiolink/interval_timer.cc | 8 ++---
src/lib/asiolink/interval_timer.h | 9 ++---
src/lib/asiolink/io_asio_socket.h | 5 ---
src/lib/asiolink/io_endpoint.h | 8 ++---
src/lib/asiolink/io_message.h | 10 ++----
src/lib/asiolink/io_service.cc | 6 ++--
src/lib/asiolink/io_service.h | 9 ++---
src/lib/asiolink/io_socket.cc | 3 --
src/lib/asiolink/io_socket.h | 9 ++---
src/lib/asiolink/simple_callback.h | 9 ++---
src/lib/asiolink/tcp_socket.h | 5 ---
src/lib/asiolink/tests/interval_timer_unittest.cc | 9 +++--
src/lib/asiolink/udp_socket.h | 5 ---
src/lib/bench/benchmark.h | 10 ++----
src/lib/bench/example/search_bench.cc | 6 ++--
src/lib/bench/tests/benchmark_unittest.cc | 4 ++-
src/lib/bench/tests/loadquery_unittest.cc | 5 +--
src/lib/cache/message_cache.h | 7 ++--
src/lib/cache/message_entry.h | 8 ++---
src/lib/cache/resolver_cache.h | 3 +-
src/lib/cache/rrset_cache.h | 10 ++----
src/lib/cache/rrset_entry.h | 10 ++----
src/lib/cc/session.h | 16 +++------
src/lib/config/ccsession.cc | 4 +--
src/lib/config/ccsession.h | 4 ++-
src/lib/config/tests/fake_session.h | 4 ---
src/lib/cryptolink/crypto_hmac.h | 5 ++-
src/lib/cryptolink/cryptolink.h | 4 +--
src/lib/datasrc/cache.cc | 19 +++-------
src/lib/datasrc/cache.h | 11 +++---
src/lib/datasrc/client.h | 8 +++--
src/lib/datasrc/client_list.h | 7 ++--
src/lib/datasrc/data_source.cc | 3 +-
src/lib/datasrc/data_source.h | 37 ++++++--------------
src/lib/datasrc/database.cc | 5 +--
src/lib/datasrc/database.h | 11 +++---
src/lib/datasrc/factory.h | 7 ++--
src/lib/datasrc/iterator.h | 4 +--
src/lib/datasrc/memory/domaintree.h | 15 +++-----
src/lib/datasrc/memory/rdata_encoder.h | 5 +--
src/lib/datasrc/memory_datasrc.cc | 7 ++--
src/lib/datasrc/memory_datasrc.h | 4 +--
src/lib/datasrc/query.h | 16 +++------
src/lib/datasrc/rbnode_rrset.h | 9 -----
src/lib/datasrc/rbtree.h | 13 +++----
src/lib/datasrc/sqlite3_accessor.cc | 3 +-
src/lib/datasrc/sqlite3_datasrc.h | 5 ---
src/lib/datasrc/static_datasrc.cc | 4 ++-
src/lib/datasrc/static_datasrc.h | 7 +---
src/lib/datasrc/tests/database_unittest.cc | 3 +-
src/lib/datasrc/tests/test_datasrc.cc | 3 +-
src/lib/datasrc/tests/test_datasrc.h | 7 +---
src/lib/datasrc/zone.h | 8 +++--
src/lib/datasrc/zonetable.h | 12 +++----
src/lib/dhcp/iface_mgr.h | 4 +--
src/lib/dns/benchmarks/message_renderer_bench.cc | 3 +-
src/lib/dns/benchmarks/oldmessagerenderer.cc | 3 +-
src/lib/dns/benchmarks/rdatarender_bench.cc | 3 +-
src/lib/dns/edns.h | 4 ++-
src/lib/dns/labelsequence.cc | 13 +++++++
src/lib/dns/labelsequence.h | 4 +++
src/lib/dns/message.cc | 9 +++--
src/lib/dns/messagerenderer.cc | 3 +-
src/lib/dns/name.h | 2 +-
src/lib/dns/nsec3hash.cc | 5 ++-
src/lib/dns/python/pydnspp_towire.h | 5 +--
src/lib/dns/rdata.h | 10 ++----
src/lib/dns/rdata/any_255/tsig_250.cc | 3 +-
.../dns/rdata/generic/detail/nsec3param_common.h | 3 +-
src/lib/dns/rdata/generic/dnskey_48.cc | 3 +-
src/lib/dns/rdata/generic/nsec3_50.cc | 3 +-
src/lib/dns/rdata/generic/nsec3param_51.cc | 3 +-
src/lib/dns/rdata/generic/rrsig_46.cc | 3 +-
src/lib/dns/rdatafields.cc | 3 +-
src/lib/dns/rrset.h | 23 +++---------
src/lib/dns/rrsetlist.h | 7 ++--
src/lib/dns/rrtype-placeholder.h | 2 +-
src/lib/dns/tests/masterload_unittest.cc | 7 ++--
src/lib/dns/tsig.cc | 2 +-
src/lib/dns/tsig.h | 5 ++-
src/lib/dns/tsigkey.cc | 3 +-
src/lib/dns/tsigkey.h | 3 +-
src/lib/dns/tsigrecord.h | 3 +-
src/lib/exceptions/exceptions.h | 9 ++---
src/lib/log/logger.h | 15 ++------
src/lib/nsas/hash_deleter.h | 7 ++--
src/lib/nsas/zone_entry.cc | 2 +-
src/lib/nsas/zone_entry.h | 4 ++-
.../isc/util/cio/socketsessionreceiver_python.cc | 2 +-
src/lib/resolve/recursive_query.h | 3 +-
src/lib/resolve/resolve.cc | 4 ++-
src/lib/resolve/tests/recursive_query_unittest.cc | 6 ++--
.../resolve/tests/recursive_query_unittest_3.cc | 4 ++-
src/lib/server_common/client.cc | 4 ++-
src/lib/server_common/client.h | 5 ++-
src/lib/server_common/socket_request.h | 4 +--
src/lib/statistics/counter.cc | 5 ++-
src/lib/statistics/counter.h | 4 +--
src/lib/statistics/counter_dict.cc | 4 +--
src/lib/statistics/counter_dict.h | 4 +--
src/lib/testutils/dnsmessage_test.h | 10 ++++--
src/lib/util/encode/base16_from_binary.h | 9 +++--
src/lib/util/encode/base32hex_from_binary.h | 9 +++--
src/lib/util/encode/base_n.cc | 7 ++--
src/lib/util/encode/binary_from_base16.h | 9 +++--
src/lib/util/encode/binary_from_base32hex.h | 9 +++--
src/lib/util/interprocess_sync.h | 6 ++--
src/lib/util/io/socketsession.cc | 8 ++---
src/lib/util/io/socketsession.h | 10 +++---
src/lib/util/lru_list.h | 6 ++--
.../{interprocess_sync_null.cc => nonassignable.h} | 36 +++++++++----------
.../{interprocess_sync_null.cc => noncopyable.h} | 37 ++++++++++----------
src/lib/util/random/qid_gen.h | 4 ++-
src/lib/util/random/random_number_generator.h | 9 ++---
src/lib/util/tests/socketsession_unittest.cc | 4 +--
src/lib/xfr/xfrout_client.h | 12 +++----
tests/tools/perfdhcp/command_options.h | 4 +--
tests/tools/perfdhcp/stats_mgr.h | 4 +--
142 files changed, 437 insertions(+), 568 deletions(-)
copy src/lib/util/{interprocess_sync_null.cc => nonassignable.h} (67%)
copy src/lib/util/{interprocess_sync_null.cc => noncopyable.h} (66%)
-----------------------------------------------------------------------
diff --git a/src/bin/auth/auth_config.h b/src/bin/auth/auth_config.h
index 6f18810..06c5e61 100644
--- a/src/bin/auth/auth_config.h
+++ b/src/bin/auth/auth_config.h
@@ -14,6 +14,8 @@
#include <string>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
#include <cc/data.h>
@@ -65,17 +67,11 @@ public:
/// the destructor doesn't have to do anything special in this regard.
/// This is a key to ensure the strong exception guarantee (see also
/// the description of \c configureAuthServer()).
-class AuthConfigParser {
+class AuthConfigParser : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private to make it explicit that this is a
- /// pure base class.
//@{
-private:
- AuthConfigParser(const AuthConfigParser& source);
- AuthConfigParser& operator=(const AuthConfigParser& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/bin/auth/auth_srv.cc b/src/bin/auth/auth_srv.cc
index 0a17d1b..a2cd9d9 100644
--- a/src/bin/auth/auth_srv.cc
+++ b/src/bin/auth/auth_srv.cc
@@ -15,6 +15,7 @@
#include <config.h>
#include <util/io/socketsession.h>
+#include <util/noncopyable.h>
#include <asiolink/asiolink.h>
#include <asiolink/io_endpoint.h>
@@ -216,11 +217,7 @@ private:
};
}
-class AuthSrvImpl {
-private:
- // prohibit copy
- AuthSrvImpl(const AuthSrvImpl& source);
- AuthSrvImpl& operator=(const AuthSrvImpl& source);
+class AuthSrvImpl : isc::util::noncopyable {
public:
AuthSrvImpl(AbstractXfroutClient& xfrout_client,
BaseSocketSessionForwarder& ddns_forwarder);
diff --git a/src/bin/auth/auth_srv.h b/src/bin/auth/auth_srv.h
index c1835e6..f4f0580 100644
--- a/src/bin/auth/auth_srv.h
+++ b/src/bin/auth/auth_srv.h
@@ -17,6 +17,7 @@
#include <string>
+#include <util/noncopyable.h>
#include <cc/data.h>
#include <config/ccsession.h>
#include <datasrc/factory.h>
@@ -79,16 +80,10 @@ class AuthSrvImpl;
/// The design of this class is still in flux. It's quite likely to change
/// in future versions.
///
-class AuthSrv {
+class AuthSrv : isc::util::noncopyable {
///
- /// \name Constructors, Assignment Operator and Destructor.
- ///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private.
+ /// \name Constructor and Destructor.
//@{
-private:
- AuthSrv(const AuthSrv& source);
- AuthSrv& operator=(const AuthSrv& source);
public:
/// The constructor.
///
diff --git a/src/bin/auth/command.cc b/src/bin/auth/command.cc
index f3cc260..70657b1 100644
--- a/src/bin/auth/command.cc
+++ b/src/bin/auth/command.cc
@@ -16,6 +16,7 @@
#include <auth/auth_log.h>
#include <auth/auth_srv.h>
+#include <util/noncopyable.h>
#include <cc/data.h>
#include <datasrc/client_list.h>
#include <config/ccsession.h>
@@ -67,17 +68,11 @@ public:
/// registering specific derived classes run time outside of this
/// implementation. If and when that happens the definition of the abstract
/// class will be published.
-class AuthCommand {
+class AuthCommand : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private to make it explicit that this is a
- /// pure base class.
//@{
-private:
- AuthCommand(const AuthCommand& source);
- AuthCommand& operator=(const AuthCommand& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/bin/auth/query.h b/src/bin/auth/query.h
index 1dc5ec0..c2af4b1 100644
--- a/src/bin/auth/query.h
+++ b/src/bin/auth/query.h
@@ -17,8 +17,7 @@
#include <exceptions/exceptions.h>
#include <dns/rrset.h>
#include <datasrc/zone.h>
-
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
#include <functional>
#include <vector>
@@ -65,7 +64,7 @@ namespace auth {
/// likely to misuse one of the classes instead of the other
/// accidentally, and since it's considered a temporary development state,
/// we keep this name at the moment.
-class Query : boost::noncopyable {
+class Query : isc::util::noncopyable {
private:
/// \brief Initial reserved size for the vectors in Query
///
diff --git a/src/bin/auth/statistics.cc b/src/bin/auth/statistics.cc
index 427f59e..22a517d 100644
--- a/src/bin/auth/statistics.cc
+++ b/src/bin/auth/statistics.cc
@@ -20,6 +20,8 @@
#include <cc/data.h>
#include <cc/session.h>
+#include <util/noncopyable.h>
+
#include <statistics/counter.h>
#include <statistics/counter_dict.h>
@@ -30,7 +32,6 @@
#include <sstream>
#include <iostream>
-#include <boost/noncopyable.hpp>
using namespace isc::dns;
using namespace isc::auth;
@@ -42,7 +43,7 @@ using namespace isc::statistics;
// TODO: Make use of wrappers like isc::dns::Opcode
// for counter item type.
-class AuthCountersImpl : boost::noncopyable {
+class AuthCountersImpl : isc::util::noncopyable {
public:
AuthCountersImpl();
~AuthCountersImpl();
diff --git a/src/bin/dhcp4/dhcp4_srv.h b/src/bin/dhcp4/dhcp4_srv.h
index dc087ff..f6bd505 100644
--- a/src/bin/dhcp4/dhcp4_srv.h
+++ b/src/bin/dhcp4/dhcp4_srv.h
@@ -15,7 +15,7 @@
#ifndef DHCPV4_SRV_H
#define DHCPV4_SRV_H
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
#include <dhcp/dhcp4.h>
#include <dhcp/pkt4.h>
#include <dhcp/option.h>
@@ -39,7 +39,7 @@ namespace dhcp {
///
/// For detailed explanation or relations between main(), ControlledDhcpv4Srv,
/// Dhcpv4Srv and other classes, see \ref dhcpv4Session.
-class Dhcpv4Srv : public boost::noncopyable {
+class Dhcpv4Srv : public isc::util::noncopyable {
public:
/// @brief Default constructor.
diff --git a/src/bin/dhcp6/dhcp6_srv.h b/src/bin/dhcp6/dhcp6_srv.h
index 9d1bf19..8785e4f 100644
--- a/src/bin/dhcp6/dhcp6_srv.h
+++ b/src/bin/dhcp6/dhcp6_srv.h
@@ -15,7 +15,7 @@
#ifndef DHCPV6_SRV_H
#define DHCPV6_SRV_H
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
#include <dhcp/dhcp6.h>
#include <dhcp/pkt6.h>
#include <dhcp/option.h>
@@ -32,7 +32,7 @@ namespace dhcp {
/// that is going to be used as server-identifier, receives incoming
/// packets, processes them, manages leases assignment and generates
/// appropriate responses.
-class Dhcpv6Srv : public boost::noncopyable {
+class Dhcpv6Srv : public isc::util::noncopyable {
public:
diff --git a/src/bin/resolver/resolver.cc b/src/bin/resolver/resolver.cc
index 9536608..d6920ee 100644
--- a/src/bin/resolver/resolver.cc
+++ b/src/bin/resolver/resolver.cc
@@ -38,6 +38,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <dns/opcode.h>
#include <dns/rcode.h>
@@ -70,11 +71,7 @@ using namespace isc::asiolink;
using namespace isc::server_common;
using namespace isc::server_common::portconfig;
-class ResolverImpl {
-private:
- // prohibit copy
- ResolverImpl(const ResolverImpl& source);
- ResolverImpl& operator=(const ResolverImpl& source);
+class ResolverImpl : isc::util::noncopyable {
public:
ResolverImpl() :
config_session_(NULL),
diff --git a/src/bin/resolver/resolver.h b/src/bin/resolver/resolver.h
index e91192e..e1d3fb5 100644
--- a/src/bin/resolver/resolver.h
+++ b/src/bin/resolver/resolver.h
@@ -21,6 +21,7 @@
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
#include <cc/data.h>
#include <config/ccsession.h>
#include <acl/dns.h>
@@ -51,19 +52,14 @@ class ResolverImpl;
* answer. It doesn't really know about chasing referrals and similar, it
* simply plugs the parts that know into the network handling code.
*/
-class Resolver : public isc::resolve::ResolverInterface {
- ///
- /// \name Constructors, Assignment Operator and Destructor.
- ///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private.
+class Resolver : isc::util::noncopyable,
+ public isc::resolve::ResolverInterface
+{
//@{
-private:
- Resolver(const Resolver& source);
- Resolver& operator=(const Resolver& source);
public:
/// The constructor.
Resolver();
+ /// The destructor.
~Resolver();
//@}
diff --git a/src/bin/resolver/tests/resolver_config_unittest.cc b/src/bin/resolver/tests/resolver_config_unittest.cc
index 369ca5c..687d3ef 100644
--- a/src/bin/resolver/tests/resolver_config_unittest.cc
+++ b/src/bin/resolver/tests/resolver_config_unittest.cc
@@ -24,7 +24,6 @@
#include <string>
#include <boost/scoped_ptr.hpp>
-#include <boost/noncopyable.hpp>
#include <gtest/gtest.h>
@@ -47,6 +46,7 @@
#include <resolver/resolver.h>
#include <dns/tests/unittest_util.h>
+#include <util/noncopyable.h>
#include <testutils/srv_test.h>
#include <testutils/mockups.h>
#include <testutils/portconfig.h>
@@ -185,7 +185,7 @@ TEST_F(ResolverConfig, rootAddressConfig) {
// The following two are helper classes to manage some temporary system
// resources in an RAII manner.
-class ScopedAddrInfo : public boost::noncopyable {
+class ScopedAddrInfo : public isc::util::noncopyable {
public:
ScopedAddrInfo(struct addrinfo* ai) : ai_(ai) {}
~ScopedAddrInfo() { freeaddrinfo(ai_);}
@@ -193,7 +193,7 @@ private:
struct addrinfo* ai_;
};
-struct ScopedSocket : public boost::noncopyable {
+struct ScopedSocket : public isc::util::noncopyable {
public:
ScopedSocket(int fd) : fd_(fd) {}
~ScopedSocket() { close(fd_); }
diff --git a/src/lib/acl/acl.h b/src/lib/acl/acl.h
index 76039c9..dd0ea8d 100644
--- a/src/lib/acl/acl.h
+++ b/src/lib/acl/acl.h
@@ -19,7 +19,8 @@
#include <vector>
#include <boost/shared_ptr.hpp>
-#include <boost/noncopyable.hpp>
+
+#include <util/noncopyable.h>
namespace isc {
namespace acl {
@@ -61,7 +62,7 @@ enum BasicAction {
* is not expected to be subclassed in real applications.
*/
template<typename Context, typename Action = BasicAction> class ACL :
- public boost::noncopyable {
+ public isc::util::noncopyable {
public:
/**
* \brief Constructor.
diff --git a/src/lib/acl/dns.h b/src/lib/acl/dns.h
index d08fcf3..1ea1c41 100644
--- a/src/lib/acl/dns.h
+++ b/src/lib/acl/dns.h
@@ -22,6 +22,8 @@
#include <cc/data.h>
+#include <util/nonassignable.h>
+
#include <acl/ip_check.h>
#include <acl/dnsname_check.h>
#include <acl/loader.h>
@@ -63,7 +65,7 @@ namespace dns {
* are the local (destination) IP address, the remote and local port numbers,
* various fields of the DNS request (e.g. a particular header flag value).
*/
-struct RequestContext {
+struct RequestContext : isc::util::nonassignable {
/// The constructor
///
/// This is a trivial constructor that perform straightforward
diff --git a/src/lib/acl/dnsname_check.h b/src/lib/acl/dnsname_check.h
index 7498d99..dac925e 100644
--- a/src/lib/acl/dnsname_check.h
+++ b/src/lib/acl/dnsname_check.h
@@ -17,6 +17,8 @@
#include <dns/name.h>
+#include <util/nonassignable.h>
+
#include <acl/check.h>
namespace isc {
@@ -38,7 +40,7 @@ namespace dns {
/// matches() method, and a template specialisation for that method must be
/// supplied for the class to be used.
template <typename Context>
-class NameCheck : public Check<Context> {
+class NameCheck : isc::util::nonassignable, public Check<Context> {
public:
/// The constructor
///
diff --git a/src/lib/acl/loader.h b/src/lib/acl/loader.h
index fc69b44..99db72d 100644
--- a/src/lib/acl/loader.h
+++ b/src/lib/acl/loader.h
@@ -15,6 +15,7 @@
#ifndef ACL_LOADER_H
#define ACL_LOADER_H
+#include <util/nonassignable.h>
#include <exceptions/exceptions.h>
#include <acl/acl.h>
#include <cc/data.h>
@@ -143,7 +144,8 @@ BasicAction defaultActionLoader(data::ConstElementPtr action);
* be satisfied, but the another one is satisfied by either parameter1 or
* parameter2.
*/
-template<typename Context, typename Action = BasicAction> class Loader {
+template<typename Context, typename Action = BasicAction>
+class Loader : isc::util::nonassignable {
public:
/**
* \brief Constructor.
diff --git a/src/lib/acl/logic_check.h b/src/lib/acl/logic_check.h
index 92441e8..c519eae 100644
--- a/src/lib/acl/logic_check.h
+++ b/src/lib/acl/logic_check.h
@@ -140,7 +140,8 @@ private:
* it is used to know which operators to create.
*/
template<typename Mode, typename Context, typename Action = BasicAction>
-class LogicCreator : public Loader<Context, Action>::CheckCreator {
+class LogicCreator : isc::util::nonassignable,
+ public Loader<Context, Action>::CheckCreator {
public:
/**
* \brief Constructor.
@@ -206,7 +207,7 @@ private:
* This simply returns the negation of whatever returns the subexpression.
*/
template<typename Context>
-class NotOperator : public CompoundCheck<Context> {
+class NotOperator : isc::util::nonassignable, public CompoundCheck<Context> {
public:
/**
* \brief Constructor
@@ -237,7 +238,8 @@ private:
};
template<typename Context, typename Action = BasicAction>
-class NotCreator : public Loader<Context, Action>::CheckCreator {
+class NotCreator : isc::util::nonassignable,
+ public Loader<Context, Action>::CheckCreator {
public:
/**
* \brief Constructor
diff --git a/src/lib/asiodns/dns_answer.h b/src/lib/asiodns/dns_answer.h
index 3654369..8905282 100644
--- a/src/lib/asiodns/dns_answer.h
+++ b/src/lib/asiodns/dns_answer.h
@@ -17,6 +17,7 @@
#include <asiolink/io_message.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <dns/message.h>
namespace isc {
@@ -35,16 +36,11 @@ namespace asiodns {
/// from a DNS Lookup provider functon and readies it to be sent to the
/// client. After it has run, the OutputBuffer object passed to it should
/// contain the answer to the query rendered into wire format.
-class DNSAnswer {
+class DNSAnswer : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- DNSAnswer(const DNSAnswer& source);
- DNSAnswer& operator=(const DNSAnswer& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/lib/asiodns/dns_lookup.h b/src/lib/asiodns/dns_lookup.h
index 5dc84ac..7e7f175 100644
--- a/src/lib/asiodns/dns_lookup.h
+++ b/src/lib/asiodns/dns_lookup.h
@@ -19,6 +19,7 @@
#include <asiodns/dns_server.h>
#include <dns/message.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
namespace isc {
namespace asiodns {
@@ -36,16 +37,11 @@ namespace asiodns {
/// a DNS query (e.g., from authoritative data source, cache, or upstream
/// query). After it has run, the OutputBuffer object passed to it
/// should contain the answer to the query, in an internal representation.
-class DNSLookup {
+class DNSLookup : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- DNSLookup(const DNSLookup& source);
- DNSLookup& operator=(const DNSLookup& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/lib/asiodns/dns_server.h b/src/lib/asiodns/dns_server.h
index 119aa66..157307d 100644
--- a/src/lib/asiodns/dns_server.h
+++ b/src/lib/asiodns/dns_server.h
@@ -15,6 +15,7 @@
#ifndef __ASIOLINK_DNS_SERVER_H
#define __ASIOLINK_DNS_SERVER_H 1
+#include <util/nonassignable.h>
#include <asiolink/io_message.h>
namespace isc {
@@ -116,7 +117,7 @@ protected:
/// not referenced. This is because, once the calling object yields
/// control to the handler, it falls out of scope and may disappear
template <typename T>
- class AsyncLookup {
+ class AsyncLookup : isc::util::nonassignable {
public:
AsyncLookup(T& caller) : caller_(caller) {}
void operator()() { caller_.asyncLookup(); }
diff --git a/src/lib/asiodns/dns_service.cc b/src/lib/asiodns/dns_service.cc
index 2cfdea5..8b30801 100644
--- a/src/lib/asiodns/dns_service.cc
+++ b/src/lib/asiodns/dns_service.cc
@@ -14,6 +14,8 @@
#include <config.h>
+#include <util/nonassignable.h>
+
#include <exceptions/exceptions.h>
#include <dns_service.h>
@@ -35,7 +37,7 @@ namespace asiodns {
class DNSLookup;
class DNSAnswer;
-class DNSServiceImpl {
+class DNSServiceImpl : isc::util::nonassignable {
public:
DNSServiceImpl(IOService& io_service, SimpleCallback* checkin,
DNSLookup* lookup, DNSAnswer* answer) :
diff --git a/src/lib/asiodns/dns_service.h b/src/lib/asiodns/dns_service.h
index 8f2f6d7..a2a188e 100644
--- a/src/lib/asiodns/dns_service.h
+++ b/src/lib/asiodns/dns_service.h
@@ -17,6 +17,8 @@
#include <resolve/resolver_interface.h>
+#include <util/noncopyable.h>
+
#include <asiolink/io_service.h>
#include <asiolink/simple_callback.h>
@@ -94,18 +96,12 @@ public:
/// logic that is shared between the authoritative and the recursive
/// server implementations. As such, it handles asio, including config
/// updates (through the 'Checkinprovider'), and listening sockets.
-class DNSService : public DNSServiceBase {
+class DNSService : isc::util::noncopyable, public DNSServiceBase {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
private:
- DNSService(const DNSService& source);
- DNSService& operator=(const DNSService& source);
-
-private:
// Bit or'ed all defined \c ServerFlag values. Used internally for
// compatibility check. Note that this doesn't have to be used by
// applications, and doesn't have to be defined in the "base" class.
diff --git a/src/lib/asiodns/sync_udp_server.h b/src/lib/asiodns/sync_udp_server.h
index 9718422..71b0780 100644
--- a/src/lib/asiodns/sync_udp_server.h
+++ b/src/lib/asiodns/sync_udp_server.h
@@ -26,10 +26,9 @@
#include <dns/message.h>
#include <asiolink/simple_callback.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
-#include <boost/noncopyable.hpp>
-
#include <stdint.h>
namespace isc {
@@ -40,7 +39,7 @@ namespace asiodns {
/// That means, the lookup handler must provide the answer right away.
/// This allows for implementation with less overhead, compared with
/// the UDPClass.
-class SyncUDPServer : public DNSServer, public boost::noncopyable {
+class SyncUDPServer : public DNSServer, public isc::util::noncopyable {
public:
/// \brief Constructor
/// \param io_service the asio::io_service to work with
diff --git a/src/lib/asiodns/tcp_server.h b/src/lib/asiodns/tcp_server.h
index 01695e4..d106b17 100644
--- a/src/lib/asiodns/tcp_server.h
+++ b/src/lib/asiodns/tcp_server.h
@@ -28,6 +28,8 @@
#include "dns_lookup.h"
#include "dns_answer.h"
+#include <util/nonassignable.h>
+
namespace isc {
namespace asiodns {
@@ -35,7 +37,8 @@ namespace asiodns {
///
/// This class inherits from both \c DNSServer and from \c coroutine,
/// defined in coroutine.h.
-class TCPServer : public virtual DNSServer, public virtual coroutine {
+class TCPServer : isc::util::nonassignable,
+ public virtual DNSServer, public virtual coroutine {
public:
/// \brief Constructor
/// \param io_service the asio::io_service to work with
diff --git a/src/lib/asiodns/udp_server.cc b/src/lib/asiodns/udp_server.cc
index 0f5456b..a6d913f 100644
--- a/src/lib/asiodns/udp_server.cc
+++ b/src/lib/asiodns/udp_server.cc
@@ -21,6 +21,8 @@
#include <config.h>
+#include <util/nonassignable.h>
+
#include <log/dummylog.h>
#include <asio.hpp>
@@ -52,7 +54,7 @@ namespace asiodns {
* use auto_ptr, as it is more lightweight. In the case of shared
* configuration (eg. the callbacks, socket), we use shared_ptrs.
*/
-struct UDPServer::Data {
+struct UDPServer::Data : isc::util::nonassignable {
/*
* Constructors from parameters passed to UDPServer constructor.
* This instance will not be used to retrieve and answer the actual
diff --git a/src/lib/asiolink/interval_timer.cc b/src/lib/asiolink/interval_timer.cc
index 9873e9b..214ca01 100644
--- a/src/lib/asiolink/interval_timer.cc
+++ b/src/lib/asiolink/interval_timer.cc
@@ -18,6 +18,8 @@
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
#include <asio.hpp>
@@ -34,13 +36,9 @@ namespace asiolink {
/// and no asynchronous operation refers to it.
/// Please follow the link to get an example:
/// http://think-async.com/asio/asio-1.4.8/doc/asio/tutorial/tutdaytime3.html#asio.tutorial.tutdaytime3.the_tcp_connection_class
-class IntervalTimerImpl :
+class IntervalTimerImpl : isc::util::noncopyable,
public boost::enable_shared_from_this<IntervalTimerImpl>
{
-private:
- // prohibit copy
- IntervalTimerImpl(const IntervalTimerImpl& source);
- IntervalTimerImpl& operator=(const IntervalTimerImpl& source);
public:
IntervalTimerImpl(IOService& io_service);
~IntervalTimerImpl();
diff --git a/src/lib/asiolink/interval_timer.h b/src/lib/asiolink/interval_timer.h
index 57ec1c3..aae4289 100644
--- a/src/lib/asiolink/interval_timer.h
+++ b/src/lib/asiolink/interval_timer.h
@@ -18,6 +18,8 @@
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+
#include <asiolink/io_service.h>
namespace isc {
@@ -55,7 +57,7 @@ class IntervalTimerImpl;
/// intervalTimer.setup(function_to_call_back, interval_in_milliseconds);
/// io_service.run();
/// \endcode
-class IntervalTimer {
+class IntervalTimer : isc::util::noncopyable {
public:
/// \name The type of timer callback function
typedef boost::function<void()> Callback;
@@ -63,12 +65,7 @@ public:
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- IntervalTimer(const IntervalTimer& source);
- IntervalTimer& operator=(const IntervalTimer& source);
public:
/// \brief The constructor with \c IOService.
///
diff --git a/src/lib/asiolink/io_asio_socket.h b/src/lib/asiolink/io_asio_socket.h
index aeac63d..8cb8891 100644
--- a/src/lib/asiolink/io_asio_socket.h
+++ b/src/lib/asiolink/io_asio_socket.h
@@ -89,12 +89,7 @@ class IOAsioSocket : public IOSocket {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- IOAsioSocket(const IOAsioSocket<C>& source);
- IOAsioSocket& operator=(const IOAsioSocket<C>& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/lib/asiolink/io_endpoint.h b/src/lib/asiolink/io_endpoint.h
index 973fc8b..07c5337 100644
--- a/src/lib/asiolink/io_endpoint.h
+++ b/src/lib/asiolink/io_endpoint.h
@@ -22,6 +22,7 @@
#include <functional>
#include <string>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
#include <asiolink/io_address.h>
@@ -43,16 +44,11 @@ namespace asiolink {
/// Derived class implementations are completely hidden within the
/// implementation. User applications only get access to concrete
/// \c IOEndpoint objects via the abstract interfaces.
-class IOEndpoint {
+class IOEndpoint : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- IOEndpoint(const IOEndpoint& source);
- IOEndpoint& operator=(const IOEndpoint& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/lib/asiolink/io_message.h b/src/lib/asiolink/io_message.h
index 81f6da1..76741cd 100644
--- a/src/lib/asiolink/io_message.h
+++ b/src/lib/asiolink/io_message.h
@@ -23,6 +23,8 @@
#include <functional>
#include <string>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
#include <asiolink/io_endpoint.h>
@@ -43,17 +45,11 @@ namespace asiolink {
/// It only provides a minimal level of support that is necessary for
/// the current implementation of the authoritative server.
/// A future version of this class will definitely support more.
-class IOMessage {
+class IOMessage : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
-
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- IOMessage(const IOMessage& source);
- IOMessage& operator=(const IOMessage& source);
public:
/// \brief Constructor from message data
///
diff --git a/src/lib/asiolink/io_service.cc b/src/lib/asiolink/io_service.cc
index 15fad0c..b9999da 100644
--- a/src/lib/asiolink/io_service.cc
+++ b/src/lib/asiolink/io_service.cc
@@ -19,15 +19,13 @@
#include <sys/socket.h>
#include <asio.hpp>
+#include <util/noncopyable.h>
#include <asiolink/io_service.h>
namespace isc {
namespace asiolink {
-class IOServiceImpl {
-private:
- IOServiceImpl(const IOService& source);
- IOServiceImpl& operator=(const IOService& source);
+class IOServiceImpl : isc::util::noncopyable {
public:
/// \brief The constructor
IOServiceImpl() :
diff --git a/src/lib/asiolink/io_service.h b/src/lib/asiolink/io_service.h
index 75aaee6..1e85ea6 100644
--- a/src/lib/asiolink/io_service.h
+++ b/src/lib/asiolink/io_service.h
@@ -15,6 +15,8 @@
#ifndef __ASIOLINK_IO_SERVICE_H
#define __ASIOLINK_IO_SERVICE_H 1
+#include <util/noncopyable.h>
+
namespace asio {
class io_service;
}
@@ -27,16 +29,11 @@ class IOServiceImpl;
/// \brief The \c IOService class is a wrapper for the ASIO \c io_service
/// class.
///
-class IOService {
+class IOService : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- IOService(const IOService& source);
- IOService& operator=(const IOService& source);
public:
/// \brief The constructor
IOService();
diff --git a/src/lib/asiolink/io_socket.cc b/src/lib/asiolink/io_socket.cc
index e1498dc..e6b7dde 100644
--- a/src/lib/asiolink/io_socket.cc
+++ b/src/lib/asiolink/io_socket.cc
@@ -26,9 +26,6 @@ namespace asiolink {
/// instantiate an \c IOSocket object without involving system resource
/// allocation such as real network sockets.
class DummySocket : public IOSocket {
-private:
- DummySocket(const DummySocket& source);
- DummySocket& operator=(const DummySocket& source);
public:
/// \brief Constructor from the protocol number.
///
diff --git a/src/lib/asiolink/io_socket.h b/src/lib/asiolink/io_socket.h
index ab6479c..5ff0354 100644
--- a/src/lib/asiolink/io_socket.h
+++ b/src/lib/asiolink/io_socket.h
@@ -23,6 +23,8 @@
#include <functional>
#include <string>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
namespace isc {
@@ -42,16 +44,11 @@ namespace asiolink {
/// modules use it. Also, at that point we may define a separate (visible)
/// derived class for testing purposes rather than providing factory methods
/// (i.e., getDummy variants below).
-class IOSocket {
+class IOSocket : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- IOSocket(const IOSocket& source);
- IOSocket& operator=(const IOSocket& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/lib/asiolink/simple_callback.h b/src/lib/asiolink/simple_callback.h
index a297a1d..df5b054 100644
--- a/src/lib/asiolink/simple_callback.h
+++ b/src/lib/asiolink/simple_callback.h
@@ -15,6 +15,8 @@
#ifndef __ASIOLINK_SIMPLE_CALLBACK_H
#define __ASIOLINK_SIMPLE_CALLBACK_H 1
+#include <util/noncopyable.h>
+
#include <asiolink/io_message.h>
namespace isc {
@@ -34,16 +36,11 @@ namespace asiolink {
/// The \c SimpleCallback is expected to be used for basic, generic
/// tasks such as checking for configuration changes. It may also be
/// used for testing purposes.
-class SimpleCallback {
+class SimpleCallback : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
//@{
-private:
- SimpleCallback(const SimpleCallback& source);
- SimpleCallback& operator=(const SimpleCallback& source);
protected:
/// \brief The default constructor.
///
diff --git a/src/lib/asiolink/tcp_socket.h b/src/lib/asiolink/tcp_socket.h
index 2505d7b..e998ad5 100644
--- a/src/lib/asiolink/tcp_socket.h
+++ b/src/lib/asiolink/tcp_socket.h
@@ -59,11 +59,6 @@ public:
/// \param C Callback type
template <typename C>
class TCPSocket : public IOAsioSocket<C> {
-private:
- /// \brief Class is non-copyable
- TCPSocket(const TCPSocket&);
- TCPSocket& operator=(const TCPSocket&);
-
public:
/// \brief Constructor from an ASIO TCP socket.
diff --git a/src/lib/asiolink/tests/interval_timer_unittest.cc b/src/lib/asiolink/tests/interval_timer_unittest.cc
index 420cb90..5e72ed3 100644
--- a/src/lib/asiolink/tests/interval_timer_unittest.cc
+++ b/src/lib/asiolink/tests/interval_timer_unittest.cc
@@ -17,6 +17,7 @@
#include <asio.hpp>
#include <asiolink/asiolink.h>
+#include <util/nonassignable.h>
#include <boost/date_time/posix_time/posix_time.hpp>
@@ -63,7 +64,8 @@ protected:
private:
IntervalTimerTest* test_obj_;
};
- class TimerCallBackCancelDeleter : public std::unary_function<void, void> {
+ class TimerCallBackCancelDeleter : isc::util::nonassignable,
+ public std::unary_function<void, void> {
public:
TimerCallBackCancelDeleter(IntervalTimerTest* test_obj,
IntervalTimer* timer,
@@ -98,7 +100,7 @@ protected:
int count_;
int prev_counter_;
};
- class TimerCallBackCanceller {
+ class TimerCallBackCanceller : isc::util::nonassignable {
public:
TimerCallBackCanceller(unsigned int& counter, IntervalTimer& itimer) :
counter_(counter), itimer_(itimer)
@@ -111,7 +113,8 @@ protected:
unsigned int& counter_;
IntervalTimer& itimer_;
};
- class TimerCallBackOverwriter : public std::unary_function<void, void> {
+ class TimerCallBackOverwriter : isc::util::nonassignable,
+ public std::unary_function<void, void> {
public:
TimerCallBackOverwriter(IntervalTimerTest* test_obj,
IntervalTimer& timer)
diff --git a/src/lib/asiolink/udp_socket.h b/src/lib/asiolink/udp_socket.h
index c061fba..c5f949f 100644
--- a/src/lib/asiolink/udp_socket.h
+++ b/src/lib/asiolink/udp_socket.h
@@ -42,11 +42,6 @@ namespace asiolink {
/// \param C Callback type
template <typename C>
class UDPSocket : public IOAsioSocket<C> {
-private:
- /// \brief Class is non-copyable
- UDPSocket(const UDPSocket&);
- UDPSocket& operator=(const UDPSocket&);
-
public:
enum {
MIN_SIZE = 4096 // Minimum send and receive size
diff --git a/src/lib/bench/benchmark.h b/src/lib/bench/benchmark.h
index a5c6fd4..97376e0 100644
--- a/src/lib/bench/benchmark.h
+++ b/src/lib/bench/benchmark.h
@@ -21,6 +21,8 @@
#include <iostream>
#include <ios>
+#include <util/noncopyable.h>
+
namespace isc {
namespace bench {
@@ -187,17 +189,11 @@ namespace bench {
/// If and when we implement it, some existing benchmark cases may need to be
/// adjusted.
template <typename T>
-class BenchMark {
+class BenchMark : isc::util::noncopyable {
///
/// \name Constructors
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non-copyable.
- /// We use the default destructor.
//@{
-private:
- BenchMark(const BenchMark& source);
- BenchMark& operator=(const BenchMark& source);
public:
/// \brief Constructor for immediate run.
///
diff --git a/src/lib/bench/example/search_bench.cc b/src/lib/bench/example/search_bench.cc
index 84f95d9..36e21e9 100644
--- a/src/lib/bench/example/search_bench.cc
+++ b/src/lib/bench/example/search_bench.cc
@@ -23,6 +23,8 @@
#include <exceptions/exceptions.h>
+#include <util/nonassignable.h>
+
#include <bench/benchmark.h>
using namespace std;
@@ -30,7 +32,7 @@ using namespace isc::bench;
namespace {
template <bool Sorted>
-class VectorSearchBenchMark {
+class VectorSearchBenchMark : isc::util::nonassignable {
public:
VectorSearchBenchMark(const vector<int>& data,
const vector<int>& keys) :
@@ -55,7 +57,7 @@ private:
const vector<int>& keys_;
};
-class SetSearchBenchMark {
+class SetSearchBenchMark : isc::util::nonassignable {
public:
SetSearchBenchMark(const set<int>& data, const vector<int>& keys) :
data_(data), keys_(keys)
diff --git a/src/lib/bench/tests/benchmark_unittest.cc b/src/lib/bench/tests/benchmark_unittest.cc
index dfe7df9..f55dfd4 100644
--- a/src/lib/bench/tests/benchmark_unittest.cc
+++ b/src/lib/bench/tests/benchmark_unittest.cc
@@ -14,6 +14,8 @@
#include <time.h> // for nanosleep
+#include <util/nonassignable.h>
+
#include <bench/benchmark.h>
#include <gtest/gtest.h>
@@ -24,7 +26,7 @@ using namespace isc::bench;
namespace {
// Our "benchmark" simply sleeps for a short period, and reports a faked
// number of iterations.
-class TestBenchMark {
+class TestBenchMark : isc::util::nonassignable {
public:
TestBenchMark(const int sub_iterations,
const struct timespec& sleep_time) :
diff --git a/src/lib/bench/tests/loadquery_unittest.cc b/src/lib/bench/tests/loadquery_unittest.cc
index 93130d2..df71d29 100644
--- a/src/lib/bench/tests/loadquery_unittest.cc
+++ b/src/lib/bench/tests/loadquery_unittest.cc
@@ -18,6 +18,7 @@
#include <sstream>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/message.h>
#include <dns/name.h>
#include <dns/opcode.h>
@@ -53,7 +54,7 @@ protected:
const char* const LoadQueryTest::DATA_DIR = TEST_DATA_DIR;
-class QueryInserter {
+class QueryInserter : isc::util::nonassignable {
public:
QueryInserter(stringstream& stream) : stream_(stream) {}
void operator()(const QueryParam& query) const {
@@ -63,7 +64,7 @@ private:
stringstream& stream_;
};
-class QueryChecker {
+class QueryChecker : isc::util::nonassignable {
public:
QueryChecker(const vector<QueryParam>* expected, const RRClass& rrclass) :
expected_(expected), rrclass_(rrclass)
diff --git a/src/lib/cache/message_cache.h b/src/lib/cache/message_cache.h
index b418f23..ce6e9f5 100644
--- a/src/lib/cache/message_cache.h
+++ b/src/lib/cache/message_cache.h
@@ -21,6 +21,7 @@
#include "message_entry.h"
#include <nsas/hash_table.h>
#include <util/lru_list.h>
+#include <util/noncopyable.h>
#include "rrset_cache.h"
namespace isc {
@@ -32,11 +33,7 @@ namespace cache {
///
/// \todo The message cache class should provide the interfaces for
/// loading, dumping and resizing.
-class MessageCache {
-// Noncopyable
-private:
- MessageCache(const MessageCache& source);
- MessageCache& operator=(const MessageCache& source);
+class MessageCache : isc::util::noncopyable {
public:
/// \param rrset_cache The cache that stores the RRsets that the
/// message entry will point to
diff --git a/src/lib/cache/message_entry.h b/src/lib/cache/message_entry.h
index 6775ff6..f9529bb 100644
--- a/src/lib/cache/message_entry.h
+++ b/src/lib/cache/message_entry.h
@@ -16,6 +16,7 @@
#define __MESSAGE_ENTRY_H
#include <vector>
+#include <util/noncopyable.h>
#include <dns/message.h>
#include <dns/rrset.h>
#include <nsas/nsas_entry.h>
@@ -33,12 +34,7 @@ class RRsetEntry;
///
/// The object of MessageEntry represents one response message
/// answered to the resolver client.
-class MessageEntry : public NsasEntry<MessageEntry> {
-// Noncopyable
-private:
- MessageEntry(const MessageEntry& source);
- MessageEntry& operator=(const MessageEntry& source);
-
+class MessageEntry : isc::util::noncopyable, public NsasEntry<MessageEntry> {
/// \brief Information to refer an RRset.
///
/// There is no class information here, since the rrsets are cached in
diff --git a/src/lib/cache/resolver_cache.h b/src/lib/cache/resolver_cache.h
index 5630bd7..25aa32e 100644
--- a/src/lib/cache/resolver_cache.h
+++ b/src/lib/cache/resolver_cache.h
@@ -21,6 +21,7 @@
#include <dns/rrclass.h>
#include <dns/message.h>
#include <exceptions/exceptions.h>
+#include <util/nonassignable.h>
#include "message_cache.h"
#include "rrset_cache.h"
#include "local_zone_data.h"
@@ -79,7 +80,7 @@ public:
///
/// \todo The resolver cache class should provide the interfaces for
/// loading, dumping and resizing.
-class ResolverClassCache {
+class ResolverClassCache : isc::util::nonassignable {
public:
/// \brief Default Constructor.
///
diff --git a/src/lib/cache/rrset_cache.h b/src/lib/cache/rrset_cache.h
index a4ea54e..adb4818 100644
--- a/src/lib/cache/rrset_cache.h
+++ b/src/lib/cache/rrset_cache.h
@@ -19,6 +19,7 @@
#include <nsas/hash_table.h>
#include <util/lru_list.h>
+#include <util/noncopyable.h>
using namespace isc::nsas;
@@ -33,16 +34,11 @@ class RRsetEntry;
///
/// \todo The rrset cache class should provide the interfaces for
/// loading, dumping and resizing.
-class RRsetCache{
+class RRsetCache : isc::util::noncopyable {
///
- /// \name Constructors and Destructor
+ /// \name Constructor and Destructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private to make it uncopyable
//@{
-private:
- RRsetCache(const RRsetCache&);
- RRsetCache& operator=(const RRsetCache&);
public:
/// \brief Constructor and Destructor
///
diff --git a/src/lib/cache/rrset_entry.h b/src/lib/cache/rrset_entry.h
index 129300d..26d2776 100644
--- a/src/lib/cache/rrset_entry.h
+++ b/src/lib/cache/rrset_entry.h
@@ -15,6 +15,7 @@
#ifndef __RRSET_ENTRY_H
#define __RRSET_ENTRY_H
+#include <util/noncopyable.h>
#include <dns/rrset.h>
#include <dns/message.h>
#include <dns/rrttl.h>
@@ -60,17 +61,12 @@ enum RRsetTrustLevel {
/// The object of RRsetEntry represents one cached RRset.
/// Each RRset entry may be refered using shared_ptr by several message
/// entries.
-class RRsetEntry : public NsasEntry<RRsetEntry>
+class RRsetEntry : isc::util::noncopyable, public NsasEntry<RRsetEntry>
{
///
- /// \name Constructors and Destructor
+ /// \name Constructor and Destructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private to make it uncopyable
//@{
-private:
- RRsetEntry(const RRsetEntry&);
- RRsetEntry& operator=(const RRsetEntry&);
public:
/// \brief Constructor
/// \param rrset The RRset used to initialize the RRset entry.
diff --git a/src/lib/cc/session.h b/src/lib/cc/session.h
index 9b08232..d045ae2 100644
--- a/src/lib/cc/session.h
+++ b/src/lib/cc/session.h
@@ -19,6 +19,8 @@
#include <boost/function.hpp>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
#include <cc/data.h>
@@ -55,17 +57,11 @@ namespace isc {
/// For simplicity we only define the methods that are necessary for
/// existing test cases that use this base class. Eventually we'll
/// probably have to extend them.
- class AbstractSession {
+ class AbstractSession : isc::util::noncopyable {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private to make it explicit that
- /// this is a pure base class.
//@{
- private:
- AbstractSession(const AbstractSession& source);
- AbstractSession& operator=(const AbstractSession& source);
protected:
/// \brief The default constructor.
///
@@ -112,10 +108,6 @@ namespace isc {
private:
SessionImpl* impl_;
- private:
- Session(const Session& source);
- Session& operator=(const Session& source);
-
public:
Session(asio::io_service& ioservice);
virtual ~Session();
diff --git a/src/lib/config/ccsession.cc b/src/lib/config/ccsession.cc
index d4c6653..d2475cb 100644
--- a/src/lib/config/ccsession.cc
+++ b/src/lib/config/ccsession.cc
@@ -769,7 +769,7 @@ ModuleCCSession::sendStopping() {
session_.group_sendmsg(cmd, "ConfigManager");
}
-class ModuleCCSession::AsyncRecvRequest {
+class ModuleCCSession::AsyncRecvRequest : isc::util::nonassignable {
public: // Everything is public here, as the definition is hidden anyway
AsyncRecvRequest(const AsyncRecvCallback& cb, const string& rcp, int sq,
bool reply) :
@@ -807,7 +807,7 @@ ModuleCCSession::checkAsyncRecv(const ConstElementPtr& envelope,
// We want the request to be still alive at the time we
// call the callback. But we need to remove it on an exception
// too, so we use the class. If just C++ had the finally keyword.
- class RequestDeleter {
+ class RequestDeleter : isc::util::nonassignable {
public:
RequestDeleter(AsyncRecvRequests& requests,
AsyncRecvRequestID& request) :
diff --git a/src/lib/config/ccsession.h b/src/lib/config/ccsession.h
index e96a33d..045d52a 100644
--- a/src/lib/config/ccsession.h
+++ b/src/lib/config/ccsession.h
@@ -15,6 +15,8 @@
#ifndef __CCSESSION_H
#define __CCSESSION_H 1
+#include <util/nonassignable.h>
+
#include <config/config_data.h>
#include <config/module_spec.h>
@@ -151,7 +153,7 @@ public:
/// holds configuration information, and handles messages from
/// the command channel
///
-class ModuleCCSession : public ConfigData {
+class ModuleCCSession : isc::util::nonassignable, public ConfigData {
public:
/**
* Initialize a config/command session
diff --git a/src/lib/config/tests/fake_session.h b/src/lib/config/tests/fake_session.h
index c91b519..dafef89 100644
--- a/src/lib/config/tests/fake_session.h
+++ b/src/lib/config/tests/fake_session.h
@@ -27,10 +27,6 @@
namespace isc {
namespace cc {
class FakeSession : public AbstractSession {
-private:
- FakeSession(const Session& source);
- FakeSession& operator=(const Session& source);
-
public:
// if initial_messages contains a list of messages,
// these are sent when recv_msg or group_recvmsg is called
diff --git a/src/lib/cryptolink/crypto_hmac.h b/src/lib/cryptolink/crypto_hmac.h
index 2eb0d0e..65eb99c 100644
--- a/src/lib/cryptolink/crypto_hmac.h
+++ b/src/lib/cryptolink/crypto_hmac.h
@@ -13,8 +13,7 @@
// PERFORMANCE OF THIS SOFTWARE.
#include <util/buffer.h>
-
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
#include <cryptolink/cryptolink.h>
@@ -32,7 +31,7 @@ class HMACImpl;
/// This class is used to create and verify HMAC signatures. Instances
/// can be created with CryptoLink::createHMAC()
///
-class HMAC : private boost::noncopyable {
+class HMAC : private isc::util::noncopyable {
private:
/// \brief Constructor from a secret and a hash algorithm
///
diff --git a/src/lib/cryptolink/cryptolink.h b/src/lib/cryptolink/cryptolink.h
index d0f7d38..edb627c 100644
--- a/src/lib/cryptolink/cryptolink.h
+++ b/src/lib/cryptolink/cryptolink.h
@@ -17,9 +17,9 @@
#include <string>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
-#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <memory>
@@ -130,7 +130,7 @@ class CryptoLinkImpl;
///
// Internal note: we can use this class later to initialize and manage
// dynamic (PKCS#11) libs
-class CryptoLink : private boost::noncopyable {
+class CryptoLink : private isc::util::noncopyable {
public:
/// \brief Returns a reference to the singleton instance
///
diff --git a/src/lib/datasrc/cache.cc b/src/lib/datasrc/cache.cc
index d88e649..a4c8d72 100644
--- a/src/lib/datasrc/cache.cc
+++ b/src/lib/datasrc/cache.cc
@@ -16,6 +16,8 @@
#include <map>
+#include <util/noncopyable.h>
+
#include <dns/question.h>
#include <dns/rrclass.h>
#include <dns/rrset.h>
@@ -37,13 +39,7 @@ namespace datasrc {
/// the case of a negative cache entry), and a copy of the
/// query-response flags that were returned when the RRset
/// was originally looked up in the low-level data source.
-class CacheEntry {
-private:
- /// The copy constructor and the assignment operator are intentionally
- /// defined as private.
- CacheEntry(const CacheEntry& source);
- CacheEntry& operator=(const CacheEntry& source);
-
+class CacheEntry : isc::util::noncopyable {
public:
CacheEntry(RRsetPtr r, uint32_t f) : rrset(r), flags(f) {};
@@ -57,15 +53,10 @@ typedef boost::shared_ptr<CacheEntry> CacheEntryPtr;
/// contains a pointer to a \c CacheEntry, a reference to the \c Question
/// that we are answering, a lifespan during which this entry remains
/// valid, and pointers to the next and previous entries in the list.
-class CacheNode {
-private:
- /// \name Constructors and Assignment Operator
+class CacheNode : isc::util::noncopyable {
+ /// \name Constructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
- CacheNode(const CacheNode& source);
- CacheNode& operator=(const CacheNode& source);
public:
/// \brief Constructor for positive cache entry.
diff --git a/src/lib/datasrc/cache.h b/src/lib/datasrc/cache.h
index 054912c..8ffaa6b 100644
--- a/src/lib/datasrc/cache.h
+++ b/src/lib/datasrc/cache.h
@@ -19,6 +19,8 @@
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+
#include <dns/rrset.h>
namespace isc {
@@ -80,7 +82,7 @@ class HotCacheImpl;
/// does not currently use threads, but if it ever does (or if libdatasrc
/// is ever used by a threaded application), this will need to be
/// revisited.
-class HotCache {
+class HotCache : isc::util::noncopyable {
private:
/// \name Static definitions
//@{
@@ -91,14 +93,9 @@ private:
static const int SLOTS_ = 1000 * LIFESPAN_;
//@}
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
- HotCache(const HotCache& source);
- HotCache& operator=(const HotCache& source);
-
public:
/// \brief Constructor for HotCache
///
diff --git a/src/lib/datasrc/client.h b/src/lib/datasrc/client.h
index dab081f..c427577 100644
--- a/src/lib/datasrc/client.h
+++ b/src/lib/datasrc/client.h
@@ -17,9 +17,11 @@
#include <utility>
-#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
+
#include <exceptions/exceptions.h>
#include <datasrc/zone.h>
@@ -128,7 +130,7 @@ typedef boost::shared_ptr<ZoneIterator> ZoneIteratorPtr;
///
/// \todo This class is still not complete. It will need more factory methods,
/// e.g. for (re)loading a zone.
-class DataSourceClient : boost::noncopyable {
+class DataSourceClient : isc::util::noncopyable {
public:
/// \brief A helper structure to represent the search result of
/// \c find().
@@ -145,7 +147,7 @@ public:
///
/// See the description of \c find() for the semantics of the member
/// variables.
- struct FindResult {
+ struct FindResult : isc::util::nonassignable {
FindResult(result::Result param_code,
const ZoneFinderPtr param_zone_finder) :
code(param_code), zone_finder(param_zone_finder)
diff --git a/src/lib/datasrc/client_list.h b/src/lib/datasrc/client_list.h
index 0dd522f..09e78cd 100644
--- a/src/lib/datasrc/client_list.h
+++ b/src/lib/datasrc/client_list.h
@@ -19,10 +19,11 @@
#include <dns/rrclass.h>
#include <cc/data.h>
#include <exceptions/exceptions.h>
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
#include <vector>
#include <boost/shared_ptr.hpp>
-#include <boost/noncopyable.hpp>
namespace isc {
namespace datasrc {
@@ -49,7 +50,7 @@ class InMemoryClient;
/// have it to allow easy testing. It is possible to create a mock-up class
/// instead of creating a full-blown configuration. The real implementation
/// is the ConfigurableClientList.
-class ClientList : public boost::noncopyable {
+class ClientList : public isc::util::noncopyable {
protected:
/// \brief Constructor.
///
@@ -64,7 +65,7 @@ public:
/// As this is read-only structure, we don't bother to create accessors.
/// Instead, all the member variables are defined as const and can be
/// accessed directly.
- struct FindResult {
+ struct FindResult : isc::util::nonassignable {
/// \brief Internal class for holding a reference.
///
/// This is used to make sure the data source client isn't released
diff --git a/src/lib/datasrc/data_source.cc b/src/lib/datasrc/data_source.cc
index a713b82..97503c8 100644
--- a/src/lib/datasrc/data_source.cc
+++ b/src/lib/datasrc/data_source.cc
@@ -30,6 +30,7 @@
#include <util/encode/base32hex.h>
#include <util/hash/sha1.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/message.h>
#include <dns/name.h>
@@ -55,7 +56,7 @@ using namespace isc::dns::rdata;
namespace {
-struct MatchRRsetForType {
+struct MatchRRsetForType : isc::util::nonassignable {
MatchRRsetForType(const RRType rrtype) : rrtype_(rrtype) {}
bool operator()(RRsetPtr rrset) {
return (rrset->getType() == rrtype_);
diff --git a/src/lib/datasrc/data_source.h b/src/lib/datasrc/data_source.h
index c35f0d3..f90ed96 100644
--- a/src/lib/datasrc/data_source.h
+++ b/src/lib/datasrc/data_source.h
@@ -21,6 +21,9 @@
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
+
#include <exceptions/exceptions.h>
#include <dns/name.h>
@@ -66,15 +69,10 @@ public:
};
-class AbstractDataSrc {
+class AbstractDataSrc : isc::util::noncopyable {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private to make it explicit that this is a pure base class.
-private:
- AbstractDataSrc(const AbstractDataSrc& source);
- AbstractDataSrc& operator=(const AbstractDataSrc& source);
protected:
/// \brief The default constructor.
///
@@ -174,13 +172,8 @@ public:
// Base class for a DNS Data Source
class DataSrc : public AbstractDataSrc {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
-private:
- DataSrc(const DataSrc& source);
- DataSrc& operator=(const DataSrc& source);
public:
DataSrc() : rrclass(isc::dns::RRClass::IN()) {}
DataSrc(const isc::dns::RRClass& c) : rrclass(c) {}
@@ -240,14 +233,9 @@ private:
class MetaDataSrc : public DataSrc {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
-private:
- MetaDataSrc(const MetaDataSrc& source);
- MetaDataSrc& operator=(const MetaDataSrc& source);
public:
MetaDataSrc() : DataSrc(isc::dns::RRClass::ANY()) {}
MetaDataSrc(const isc::dns::RRClass& c) : DataSrc(c) {}
@@ -323,16 +311,11 @@ private:
/// - There is no matching %data source and name found (which is probably
/// wrong, see below), or the given enclosing name gives a longer match
/// than the currently stored enclosing name against the specified name.
-class DataSrcMatch {
+class DataSrcMatch : isc::util::noncopyable {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private.
//@{
-private:
- DataSrcMatch(const DataSrcMatch& source);
- DataSrcMatch& operator=(const DataSrcMatch& source);
public:
/// \brief The constructor.
///
@@ -409,7 +392,7 @@ private:
const isc::dns::RRClass& rrclass_;
};
-class Nsec3Param {
+class Nsec3Param : isc::util::nonassignable {
public:
Nsec3Param(uint8_t a, uint8_t f, uint16_t i, const std::vector<uint8_t>& s);
std::string getHash(const isc::dns::Name& name) const;
diff --git a/src/lib/datasrc/database.cc b/src/lib/datasrc/database.cc
index 82a5e54..1e38123 100644
--- a/src/lib/datasrc/database.cc
+++ b/src/lib/datasrc/database.cc
@@ -1434,7 +1434,7 @@ DatabaseUpdater::validateAddOrDelete(const char* const op_str,
// (this implicitly assumes copying std::string objects is not very expensive;
// this is often the case in some common implementations that have
// copy-on-write semantics for the string class).
-class RRParameterConverter {
+class RRParameterConverter : isc::util::nonassignable {
public:
RRParameterConverter(const AbstractRRset& rrset) : rrset_(rrset)
{}
@@ -1638,7 +1638,8 @@ DatabaseClient::getUpdater(const isc::dns::Name& name, bool replace,
// Zone journal reader using some database system as the underlying data
// source.
//
-class DatabaseJournalReader : public ZoneJournalReader {
+class DatabaseJournalReader : isc::util::nonassignable,
+ public ZoneJournalReader {
private:
// A shortcut typedef to keep the code concise.
typedef DatabaseAccessor Accessor;
diff --git a/src/lib/datasrc/database.h b/src/lib/datasrc/database.h
index 65ddfcc..02298ec 100644
--- a/src/lib/datasrc/database.h
+++ b/src/lib/datasrc/database.h
@@ -31,6 +31,7 @@
#include <dns/name.h>
#include <exceptions/exceptions.h>
+#include <util/nonassignable.h>
#include <map>
#include <set>
@@ -59,7 +60,7 @@ namespace datasrc {
/// database, having multiple instances of this class. If the database
/// allows having multiple open queries at one connection, the connection
/// class may share it.
-class DatabaseAccessor : boost::noncopyable {
+class DatabaseAccessor : isc::util::noncopyable {
public:
/// \brief Data columns for by IteratorContext::getNext()
///
@@ -189,7 +190,7 @@ public:
/// create a new connection (or, if it is more convenient, the connection
/// itself can inherit both from DatabaseConnection and IteratorContext
/// and just clone itself).
- class IteratorContext : public boost::noncopyable {
+ class IteratorContext : public isc::util::noncopyable {
public:
/// \brief Destructor
///
@@ -839,7 +840,7 @@ public:
/// different handling, so it can be subclassed.
///
/// Methods directly corresponds to the ones in ZoneFinder.
- class Finder : public ZoneFinder {
+ class Finder : isc::util::nonassignable, public ZoneFinder {
public:
/// \brief Constructor
///
@@ -1008,7 +1009,7 @@ public:
/// and make the code more complicated. By encapsulating and unifying
/// the logic in a single separate class, we can keep the main
/// search logic readable.
- class FindDNSSECContext {
+ class FindDNSSECContext : isc::util::nonassignable {
public:
/// \brief Constructor for FindDNSSECContext class.
///
@@ -1124,7 +1125,7 @@ public:
/// derived from that one, but as it is used just once in the code and
/// will never be treated as a \c FindResult, the obscurity involved in
/// deriving it from a parent class was deemed not worthwhile.
- struct DelegationSearchResult {
+ struct DelegationSearchResult : isc::util::nonassignable {
DelegationSearchResult(const ZoneFinder::Result param_code,
const isc::dns::ConstRRsetPtr param_rrset,
const isc::dns::ConstRRsetPtr param_ns,
diff --git a/src/lib/datasrc/factory.h b/src/lib/datasrc/factory.h
index 2731f58..7f22a2c 100644
--- a/src/lib/datasrc/factory.h
+++ b/src/lib/datasrc/factory.h
@@ -20,7 +20,8 @@
#include <cc/data.h>
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
+
#include <boost/shared_ptr.hpp>
namespace isc {
@@ -60,7 +61,7 @@ typedef void ds_destructor(DataSourceClient* instance);
/// in other places than for dynamically loading datasources, then, apart
/// from moving it to another location, we also need to make the
/// exceptions raised more general.
-class LibraryContainer : boost::noncopyable {
+class LibraryContainer : isc::util::noncopyable {
public:
/// \brief Constructor
///
@@ -141,7 +142,7 @@ private:
/// derived classes as well. Currently, the class is actually derived in some
/// of the tests, which is rather unclean (as this class as written is really
/// intended to be used directly).
-class DataSourceClientContainer : boost::noncopyable {
+class DataSourceClientContainer : isc::util::noncopyable {
public:
/// \brief Constructor
///
diff --git a/src/lib/datasrc/iterator.h b/src/lib/datasrc/iterator.h
index 99d3331..6e37c1d 100644
--- a/src/lib/datasrc/iterator.h
+++ b/src/lib/datasrc/iterator.h
@@ -17,7 +17,7 @@
#include <dns/rrset.h>
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
#include <datasrc/zone.h>
@@ -34,7 +34,7 @@ namespace datasrc {
*
* There's no way to start iterating from the beginning again or return.
*/
-class ZoneIterator : public boost::noncopyable {
+class ZoneIterator : public isc::util::noncopyable {
public:
/**
* \brief Destructor
diff --git a/src/lib/datasrc/memory/domaintree.h b/src/lib/datasrc/memory/domaintree.h
index ad8f085..8a304f1 100644
--- a/src/lib/datasrc/memory/domaintree.h
+++ b/src/lib/datasrc/memory/domaintree.h
@@ -26,6 +26,7 @@
#include <exceptions/exceptions.h>
#include <util/memory_segment.h>
+#include <util/noncopyable.h>
#include <dns/name.h>
#include <dns/labelsequence.h>
@@ -80,7 +81,7 @@ class DomainTree;
/// allocated space for the labels data is encoded by borrowing some
/// bits of the "flags" field.
template <typename T, typename DT>
-class DomainTreeNode : public boost::noncopyable {
+class DomainTreeNode : public isc::util::noncopyable {
private:
/// The DomainTreeNode is meant for use from within DomainTree, so
/// it has access to it.
@@ -620,16 +621,13 @@ DomainTreeNode<T, DT>::predecessor() const {
/// This is the reason why manipulation methods such as \c push() and \c pop()
/// are private (and not shown in the doxygen document).
template <typename T, typename DT>
-class DomainTreeNodeChain {
+class DomainTreeNodeChain : isc::util::noncopyable {
/// DomainTreeNodeChain is initialized by DomainTree, only DomainTree has
/// knowledge to manipulate it.
friend class DomainTree<T, DT>;
public:
- /// \name Constructors and Assignment Operator.
+ /// \name Constructor.
///
- /// \note The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non copyable.
- /// This may have to be changed in a future version with newer need.
/// For now we explicitly disable copy to avoid accidental copy happens
/// unintentionally.
//{@
@@ -642,9 +640,6 @@ public:
isc::dns::NameComparisonResult::EQUAL)
{}
-private:
- DomainTreeNodeChain(const DomainTreeNodeChain<T, DT>&);
- DomainTreeNodeChain<T, DT>& operator=(const DomainTreeNodeChain<T, DT>&);
//@}
public:
@@ -853,7 +848,7 @@ private:
* - add remove interface
*/
template <typename T, typename DT>
-class DomainTree : public boost::noncopyable {
+class DomainTree : public isc::util::noncopyable {
friend class DomainTreeNode<T, DT>;
public:
/// \brief The return value for the \c find() and insert() methods
diff --git a/src/lib/datasrc/memory/rdata_encoder.h b/src/lib/datasrc/memory/rdata_encoder.h
index 7524f94..684b131 100644
--- a/src/lib/datasrc/memory/rdata_encoder.h
+++ b/src/lib/datasrc/memory/rdata_encoder.h
@@ -17,13 +17,14 @@
#include <exceptions/exceptions.h>
+#include <util/noncopyable.h>
+
#include <dns/labelsequence.h>
#include <dns/rdata.h>
#include <dns/rrclass.h>
#include <dns/rrtype.h>
#include <boost/function.hpp>
-#include <boost/noncopyable.hpp>
#include <vector>
@@ -149,7 +150,7 @@ enum RdataNameAttributes {
///
/// The caller can reuse the \c RdataEncoder object for another set of RDATA
/// by repeating the session from \c start().
-class RdataEncoder : boost::noncopyable {
+class RdataEncoder : isc::util::noncopyable {
public:
/// \brief Default constructor.
RdataEncoder();
diff --git a/src/lib/datasrc/memory_datasrc.cc b/src/lib/datasrc/memory_datasrc.cc
index c6f15fb..f26cbb3 100644
--- a/src/lib/datasrc/memory_datasrc.cc
+++ b/src/lib/datasrc/memory_datasrc.cc
@@ -14,6 +14,7 @@
#include <exceptions/exceptions.h>
+#include <util/nonassignable.h>
#include <util/memory_segment_local.h>
#include <dns/name.h>
@@ -216,7 +217,7 @@ public:
// constructing the zone.
private:
template <typename NodeType>
- struct FindNodeResultBase {
+ struct FindNodeResultBase : isc::util::nonassignable {
// Bitwise flags to represent supplemental information of the
// search result:
// Search resulted in a wildcard match.
@@ -308,7 +309,7 @@ ZoneData::getClosestNSEC(RBTreeNodeChain<Domain>& node_path,
///
/// It will be passed to \c cutCallback() (see below) and record a possible
/// zone cut node and related RRset (normally NS or DNAME).
-struct FindState {
+struct FindState : isc::util::nonassignable {
FindState(bool glue_ok) :
zonecut_node_(NULL),
dname_node_(NULL),
@@ -744,7 +745,7 @@ prepareRRset(const Name& name, const ConstRBNodeRRsetPtr& rrset, bool rename,
// Specialized version of ZoneFinder::ResultContext, which specifically
// holds rrset in the form of RBNodeRRset.
-struct RBNodeResultContext {
+struct RBNodeResultContext : isc::util::nonassignable {
/// \brief Constructor
///
/// The first three parameters correspond to those of
diff --git a/src/lib/datasrc/memory_datasrc.h b/src/lib/datasrc/memory_datasrc.h
index be545d4..4e133eb 100644
--- a/src/lib/datasrc/memory_datasrc.h
+++ b/src/lib/datasrc/memory_datasrc.h
@@ -17,7 +17,7 @@
#include <string>
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
#include <datasrc/zonetable.h>
#include <datasrc/client.h>
@@ -40,7 +40,7 @@ namespace datasrc {
/// backend). This is why the class has methods like \c load() or \c add().
///
/// This class is non copyable.
-class InMemoryZoneFinder : boost::noncopyable, public ZoneFinder {
+class InMemoryZoneFinder : isc::util::noncopyable, public ZoneFinder {
///
/// \name Constructors and Destructor.
public:
diff --git a/src/lib/datasrc/query.h b/src/lib/datasrc/query.h
index 43b62cc..9e9a348 100644
--- a/src/lib/datasrc/query.h
+++ b/src/lib/datasrc/query.h
@@ -25,6 +25,8 @@
#include <dns/rrtype.h>
#include <dns/rrclass.h>
+#include <util/noncopyable.h>
+
#include <queue>
namespace isc {
@@ -34,12 +36,7 @@ class Query;
typedef boost::shared_ptr<Query> QueryPtr;
// An individual task to be carried out by the query logic
-class QueryTask {
-private:
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
- QueryTask(const QueryTask& source);
- QueryTask& operator=(const QueryTask& source);
+class QueryTask : isc::util::noncopyable {
public:
// XXX: Members are currently public, but should probably be
// moved to private and wrapped in get() functions later.
@@ -158,7 +155,7 @@ typedef boost::shared_ptr<QueryTask> QueryTaskPtr;
typedef std::queue<QueryTaskPtr> QueryTaskQueue;
// Data Source query
-class Query {
+class Query : isc::util::noncopyable {
public:
// The state of a query: pending or answered.
enum Status {
@@ -169,12 +166,7 @@ public:
///
/// \name Constructors, Assignment Operator and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
-private:
- Query(const Query& source);
- Query& operator=(const Query& source);
public:
// Query constructor
Query(isc::dns::Message& m, HotCache& c, bool dnssec);
diff --git a/src/lib/datasrc/rbnode_rrset.h b/src/lib/datasrc/rbnode_rrset.h
index 1c23e05..28b730f 100644
--- a/src/lib/datasrc/rbnode_rrset.h
+++ b/src/lib/datasrc/rbnode_rrset.h
@@ -85,15 +85,6 @@ struct AdditionalNodeInfo;
// Note: non-Doxygen-documented methods are documented in the base class.
class RBNodeRRset : public isc::dns::AbstractRRset {
-
-private:
- // Note: The copy constructor and the assignment operator are intentionally
- // defined as private as we would normally not duplicate a RBNodeRRset.
- // (We use the "private" method instead of inheriting from
- // boost::noncopyable so as to avoid multiple inheritance.)
- RBNodeRRset(const RBNodeRRset& source);
- RBNodeRRset& operator=(const RBNodeRRset& source);
-
public:
/// \brief Usual Constructor
///
diff --git a/src/lib/datasrc/rbtree.h b/src/lib/datasrc/rbtree.h
index 2ec5347..3a509e8 100644
--- a/src/lib/datasrc/rbtree.h
+++ b/src/lib/datasrc/rbtree.h
@@ -25,6 +25,7 @@
#include <exceptions/exceptions.h>
#include <util/memory_segment.h>
+#include <util/noncopyable.h>
#include <dns/name.h>
#include <dns/labelsequence.h>
@@ -76,7 +77,7 @@ class RBTree;
/// of the allocated space for the labels data is encoded by borrowing some
/// bits of the "flags" field.
template <typename T>
-class RBNode : public boost::noncopyable {
+class RBNode : public isc::util::noncopyable {
private:
/// The RBNode is meant for use from within RBTree, so it has access to
/// it.
@@ -625,16 +626,13 @@ RBNode<T>::predecessor() const {
/// This is the reason why manipulation methods such as \c push() and \c pop()
/// are private (and not shown in the doxygen document).
template <typename T>
-class RBTreeNodeChain {
+class RBTreeNodeChain : isc::util::noncopyable {
/// RBTreeNodeChain is initialized by RBTree, only RBTree has
/// knowledge to manipulate it.
friend class RBTree<T>;
public:
/// \name Constructors and Assignment Operator.
///
- /// \note The copy constructor and the assignment operator are
- /// intentionally defined as private, making this class non copyable.
- /// This may have to be changed in a future version with newer need.
/// For now we explicitly disable copy to avoid accidental copy happens
/// unintentionally.
//{@
@@ -647,9 +645,6 @@ public:
isc::dns::NameComparisonResult::EQUAL)
{}
-private:
- RBTreeNodeChain(const RBTreeNodeChain<T>&);
- RBTreeNodeChain<T>& operator=(const RBTreeNodeChain<T>&);
//@}
public:
@@ -848,7 +843,7 @@ private:
* - add remove interface
*/
template <typename T>
-class RBTree : public boost::noncopyable {
+class RBTree : public isc::util::noncopyable {
friend class RBNode<T>;
public:
/// \brief The return value for the \c find() and insert() methods
diff --git a/src/lib/datasrc/sqlite3_accessor.cc b/src/lib/datasrc/sqlite3_accessor.cc
index ba21de8..c046419 100644
--- a/src/lib/datasrc/sqlite3_accessor.cc
+++ b/src/lib/datasrc/sqlite3_accessor.cc
@@ -26,6 +26,7 @@
#include <datasrc/factory.h>
#include <datasrc/database.h>
#include <util/filename.h>
+#include <util/nonassignable.h>
using namespace std;
using namespace isc::data;
@@ -223,7 +224,7 @@ private:
// The bindXXX methods are straightforward wrappers for the corresponding
// sqlite3_bind_xxx functions that make bindings with the given parameters
// on the statement maintained in this class.
-class StatementProcessor {
+class StatementProcessor : isc::util::nonassignable {
public:
// desc will be used on failure in the what() message of the resulting
// DataSourceError exception.
diff --git a/src/lib/datasrc/sqlite3_datasrc.h b/src/lib/datasrc/sqlite3_datasrc.h
index 8ee042f..debf8af 100644
--- a/src/lib/datasrc/sqlite3_datasrc.h
+++ b/src/lib/datasrc/sqlite3_datasrc.h
@@ -51,12 +51,7 @@ class Sqlite3DataSrc : public DataSrc {
///
/// \name Constructors, Assignment Operator and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
-private:
- Sqlite3DataSrc(const Sqlite3DataSrc& source);
- Sqlite3DataSrc& operator=(const Sqlite3DataSrc& source);
public:
Sqlite3DataSrc();
~Sqlite3DataSrc();
diff --git a/src/lib/datasrc/static_datasrc.cc b/src/lib/datasrc/static_datasrc.cc
index 77d7a1d..2f7ef4e 100644
--- a/src/lib/datasrc/static_datasrc.cc
+++ b/src/lib/datasrc/static_datasrc.cc
@@ -16,6 +16,8 @@
#include <cassert>
+#include <util/nonassignable.h>
+
#include <dns/name.h>
#include <dns/rdataclass.h>
#include <dns/rrclass.h>
@@ -48,7 +50,7 @@ namespace datasrc {
// not expected to be performance sensitive, so the overhead due to the pimpl
// should be okay, and it's more beneficial to hide details and minimize
// inter module dependencies in header files.
-struct StaticDataSrcImpl {
+struct StaticDataSrcImpl : isc::util::nonassignable {
public:
StaticDataSrcImpl();
const Name authors_name;
diff --git a/src/lib/datasrc/static_datasrc.h b/src/lib/datasrc/static_datasrc.h
index 4d212fe..84c4883 100644
--- a/src/lib/datasrc/static_datasrc.h
+++ b/src/lib/datasrc/static_datasrc.h
@@ -40,15 +40,10 @@ namespace datasrc {
struct StaticDataSrcImpl;
class StaticDataSrc : public DataSrc {
-private:
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
- StaticDataSrc(const StaticDataSrc& source);
- StaticDataSrc& operator=(const StaticDataSrc& source);
public:
StaticDataSrc();
~StaticDataSrc();
diff --git a/src/lib/datasrc/tests/database_unittest.cc b/src/lib/datasrc/tests/database_unittest.cc
index 5f18283..511a41a 100644
--- a/src/lib/datasrc/tests/database_unittest.cc
+++ b/src/lib/datasrc/tests/database_unittest.cc
@@ -22,6 +22,7 @@
#include <dns/rrset.h>
#include <dns/nsec3hash.h>
#include <exceptions/exceptions.h>
+#include <util/nonassignable.h>
#include <datasrc/database.h>
#include <datasrc/zone.h>
@@ -782,7 +783,7 @@ public:
private:
// Helper predicate class used in deleteRecordInZone().
- struct deleteMatch {
+ struct deleteMatch : isc::util::nonassignable {
deleteMatch(const string& type, const string& rdata) :
type_(type), rdata_(rdata)
{}
diff --git a/src/lib/datasrc/tests/test_datasrc.cc b/src/lib/datasrc/tests/test_datasrc.cc
index d78e7db..6c6f81f 100644
--- a/src/lib/datasrc/tests/test_datasrc.cc
+++ b/src/lib/datasrc/tests/test_datasrc.cc
@@ -24,6 +24,7 @@
#include <datasrc/data_source.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/messagerenderer.h>
#include <dns/name.h>
#include <dns/rdata.h>
@@ -444,7 +445,7 @@ copyRRset(RRsetPtr const source) {
return (rrset);
}
-class TestDataSrc::RRsetMatch {
+class TestDataSrc::RRsetMatch : isc::util::nonassignable {
public:
struct MatchResult {
MatchResult(const bool name_found, const bool has_delegation) :
diff --git a/src/lib/datasrc/tests/test_datasrc.h b/src/lib/datasrc/tests/test_datasrc.h
index d0d67fc..dc9ba4a 100644
--- a/src/lib/datasrc/tests/test_datasrc.h
+++ b/src/lib/datasrc/tests/test_datasrc.h
@@ -33,14 +33,9 @@ class Query;
class TestDataSrc : public DataSrc {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private.
//@{
-private:
- TestDataSrc(const TestDataSrc& source);
- TestDataSrc operator=(const TestDataSrc& source);
public:
TestDataSrc() : initialized(false) {}
~TestDataSrc() {}
diff --git a/src/lib/datasrc/zone.h b/src/lib/datasrc/zone.h
index 094529a..a4ef92e 100644
--- a/src/lib/datasrc/zone.h
+++ b/src/lib/datasrc/zone.h
@@ -19,6 +19,8 @@
#include <dns/rrset.h>
#include <dns/rrtype.h>
+#include <util/nonassignable.h>
+
#include <datasrc/result.h>
#include <utility>
@@ -122,7 +124,7 @@ protected:
/// This helper structure is specifically expected to be used as an input
/// for the construct of the \c Context class object used by derived
/// ZoneFinder implementations. This is therefore defined as protected.
- struct ResultContext {
+ struct ResultContext : isc::util::nonassignable {
ResultContext(Result code_param,
isc::dns::ConstRRsetPtr rrset_param,
FindResultFlags flags_param = RESULT_DEFAULT) :
@@ -167,7 +169,7 @@ public:
/// ZoneFinder that originally performed the \c find() call, and expects
/// the finder is valid throughout the lifetime of this object. It's
/// caller's responsibility to ensure that assumption.
- class Context {
+ class Context : isc::util::nonassignable {
public:
/// \brief The constructor for the normal find call.
///
@@ -532,7 +534,7 @@ public:
/// The idea is similar to that of \c FindContext, but \c findNSEC3() has
/// special interface and semantics, we use a different structure to
/// represent the result.
- struct FindNSEC3Result {
+ struct FindNSEC3Result : isc::util::nonassignable {
FindNSEC3Result(bool param_matched, uint8_t param_closest_labels,
isc::dns::ConstRRsetPtr param_closest_proof,
isc::dns::ConstRRsetPtr param_next_proof) :
diff --git a/src/lib/datasrc/zonetable.h b/src/lib/datasrc/zonetable.h
index 93a021c..45bd0dc 100644
--- a/src/lib/datasrc/zonetable.h
+++ b/src/lib/datasrc/zonetable.h
@@ -15,6 +15,8 @@
#ifndef __ZONETABLE_H
#define __ZONETABLE_H 1
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
#include <util/memory_segment.h>
#include <dns/rrset.h>
@@ -40,9 +42,9 @@ namespace datasrc {
///
/// For more descriptions about its struct and interfaces, please refer to the
/// corresponding struct and interfaces of \c MemoryDataSrc.
-class ZoneTable {
+class ZoneTable : isc::util::noncopyable {
public:
- struct FindResult {
+ struct FindResult : isc::util::nonassignable {
FindResult(result::Result param_code, const ZoneFinderPtr param_zone) :
code(param_code), zone(param_zone)
{}
@@ -53,13 +55,7 @@ public:
/// \name Constructors and Destructor.
///
/// \b Note:
- /// The copy constructor and the assignment operator are intentionally
- /// defined as private, making this class non copyable.
//@{
-private:
- ZoneTable(const ZoneTable& source);
- ZoneTable& operator=(const ZoneTable& source);
-
/// Constructor.
///
/// An object of this class is always expected to be created by the
diff --git a/src/lib/dhcp/iface_mgr.h b/src/lib/dhcp/iface_mgr.h
index 7de6a44..88227ab 100644
--- a/src/lib/dhcp/iface_mgr.h
+++ b/src/lib/dhcp/iface_mgr.h
@@ -18,8 +18,8 @@
#include <list>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_array.hpp>
-#include <boost/noncopyable.hpp>
#include <asiolink/io_address.h>
+#include <util/noncopyable.h>
#include <dhcp/dhcp6.h>
#include <dhcp/dhcp4.h>
#include <dhcp/pkt4.h>
@@ -34,7 +34,7 @@ namespace dhcp {
/// interfaces, configured addresses, link-local addresses, and provides
/// API for using sockets.
///
-class IfaceMgr : public boost::noncopyable {
+class IfaceMgr : public isc::util::noncopyable {
public:
/// type that defines list of addresses
typedef std::vector<isc::asiolink::IOAddress> AddressCollection;
diff --git a/src/lib/dns/benchmarks/message_renderer_bench.cc b/src/lib/dns/benchmarks/message_renderer_bench.cc
index 33cd65b..dac0a3f 100644
--- a/src/lib/dns/benchmarks/message_renderer_bench.cc
+++ b/src/lib/dns/benchmarks/message_renderer_bench.cc
@@ -16,6 +16,7 @@
#include <dns/name.h>
#include <dns/messagerenderer.h>
+#include <util/nonassignable.h>
#include <oldmessagerenderer.h>
#include <cassert>
@@ -32,7 +33,7 @@ namespace {
// performance when we modify the renderer implementation by comparing the
// old and new implementation for the same data.
template <typename T>
-class MessageRendererBenchMark {
+class MessageRendererBenchMark : isc::util::nonassignable {
public:
MessageRendererBenchMark(const vector<Name>& names) :
names_(names)
diff --git a/src/lib/dns/benchmarks/oldmessagerenderer.cc b/src/lib/dns/benchmarks/oldmessagerenderer.cc
index cd5c4e2..515135a 100644
--- a/src/lib/dns/benchmarks/oldmessagerenderer.cc
+++ b/src/lib/dns/benchmarks/oldmessagerenderer.cc
@@ -14,6 +14,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/name.h>
#include <oldmessagerenderer.h>
@@ -34,7 +35,7 @@ namespace { // hide internal-only names from the public namespaces
/// A \c MessageRendererImpl object maintains a set of the \c NameCompressNode
/// objects, and searches the set for the position of the longest match
/// (ancestor) name against each new name to be rendered into the buffer.
-struct NameCompressNode {
+struct NameCompressNode : isc::util::nonassignable {
NameCompressNode(const OldMessageRenderer& renderer,
const OutputBuffer& buffer, const size_t pos,
const size_t len) :
diff --git a/src/lib/dns/benchmarks/rdatarender_bench.cc b/src/lib/dns/benchmarks/rdatarender_bench.cc
index 368ea6a..7f78346 100644
--- a/src/lib/dns/benchmarks/rdatarender_bench.cc
+++ b/src/lib/dns/benchmarks/rdatarender_bench.cc
@@ -22,6 +22,7 @@
#include <bench/benchmark.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/messagerenderer.h>
#include <dns/rdata.h>
#include <dns/rdatafields.h>
@@ -39,7 +40,7 @@ namespace {
// (pointer) objects which should have a "toWire()" method. In its run(),
// it calls toWire() for each element of the vector.
template <typename T>
-class RdataRenderBenchMark {
+class RdataRenderBenchMark : isc::util::nonassignable {
public:
RdataRenderBenchMark(const vector<T>& dataset) :
dataset_(dataset)
diff --git a/src/lib/dns/edns.h b/src/lib/dns/edns.h
index a7bc4c4..2c30303 100644
--- a/src/lib/dns/edns.h
+++ b/src/lib/dns/edns.h
@@ -23,6 +23,8 @@
#include <dns/rdata.h>
+#include <util/nonassignable.h>
+
namespace isc {
namespace util {
class OutputBuffer;
@@ -128,7 +130,7 @@ typedef boost::shared_ptr<const EDNS> ConstEDNSPtr;
/// If a future version of the %EDNS protocol introduces further relationship
/// between the message and the %EDNS, we might reconsider the interface,
/// probably with higher abstraction.
-class EDNS {
+class EDNS : isc::util::nonassignable {
public:
///
/// \name Constructors and Destructor
diff --git a/src/lib/dns/labelsequence.cc b/src/lib/dns/labelsequence.cc
index ba85b91..d9faf80 100644
--- a/src/lib/dns/labelsequence.cc
+++ b/src/lib/dns/labelsequence.cc
@@ -73,6 +73,19 @@ LabelSequence::LabelSequence(const LabelSequence& src,
offsets_ = &buf[Name::MAX_WIRE];
}
+const LabelSequence&
+LabelSequence::operator=(const LabelSequence& ls)
+{
+ if (this == &ls) {
+ return (*this);
+ }
+ if ((this->data_ != ls.data_) || (this->offsets_ != ls.offsets_)) {
+ isc_throw(BadValue, "Illegal LabelSequence assignment");
+ }
+ this->first_label_ = ls.first_label_;
+ this->last_label_ = ls.last_label_;
+ return (*this);
+}
const uint8_t*
LabelSequence::getData(size_t *len) const {
diff --git a/src/lib/dns/labelsequence.h b/src/lib/dns/labelsequence.h
index 186bda6..56787ae 100644
--- a/src/lib/dns/labelsequence.h
+++ b/src/lib/dns/labelsequence.h
@@ -17,6 +17,7 @@
#include <dns/name.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
namespace isc {
namespace dns {
@@ -129,6 +130,9 @@ public:
last_label_(ls.last_label_)
{}
+ /// \brief Assignment operator.
+ const LabelSequence& operator=(const LabelSequence& ls);
+
/// \brief Return the wire-format data for this LabelSequence
///
/// The data is returned as a pointer to (the part of) the original
diff --git a/src/lib/dns/message.cc b/src/lib/dns/message.cc
index 80b0df7..b88b76e 100644
--- a/src/lib/dns/message.cc
+++ b/src/lib/dns/message.cc
@@ -27,6 +27,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/edns.h>
#include <dns/exceptions.h>
@@ -203,7 +204,7 @@ namespace {
// RenderSection object can get the number of rendered RRs via the
// getTotalCount() method.
template <typename T>
-struct RenderSection {
+struct RenderSection : isc::util::nonassignable {
RenderSection(AbstractMessageRenderer& renderer, const bool partial_ok) :
counter_(0), renderer_(renderer), partial_ok_(partial_ok),
truncated_(false)
@@ -681,7 +682,9 @@ MessageImpl::parseQuestion(InputBuffer& buffer) {
}
namespace {
-struct MatchRR : public unary_function<RRsetPtr, bool> {
+struct MatchRR : isc::util::nonassignable,
+ public unary_function<RRsetPtr, bool>
+{
MatchRR(const Name& name, const RRType& rrtype, const RRClass& rrclass) :
name_(name), rrtype_(rrtype), rrclass_(rrclass) {}
bool operator()(const RRsetPtr& rrset) const {
@@ -858,7 +861,7 @@ MessageImpl::addTSIG(Message::Section section, unsigned int count,
namespace {
template <typename T>
-struct SectionFormatter {
+struct SectionFormatter : isc::util::nonassignable {
SectionFormatter(const Message::Section section, string& output) :
section_(section), output_(output) {}
void operator()(const T& entry) {
diff --git a/src/lib/dns/messagerenderer.cc b/src/lib/dns/messagerenderer.cc
index 0cd11ce..28a5e8b 100644
--- a/src/lib/dns/messagerenderer.cc
+++ b/src/lib/dns/messagerenderer.cc
@@ -14,6 +14,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/name.h>
#include <dns/name_internal.h>
#include <dns/labelsequence.h>
@@ -68,7 +69,7 @@ struct OffsetItem {
/// this object, so we separate these using template to avoid unnecessary
/// condition check.
template <bool CASE_SENSITIVE>
-struct NameCompare {
+struct NameCompare : isc::util::nonassignable {
/// \brief Constructor
///
/// \param buffer The buffer for rendering used in the caller renderer
diff --git a/src/lib/dns/name.h b/src/lib/dns/name.h
index 261caee..4f95b45 100644
--- a/src/lib/dns/name.h
+++ b/src/lib/dns/name.h
@@ -281,7 +281,7 @@ public:
///
/// We use the default copy constructor intentionally.
//@}
- /// We use the default copy assignment operator intentionally.
+ /// We use the default assignment operator intentionally.
///
///
diff --git a/src/lib/dns/nsec3hash.cc b/src/lib/dns/nsec3hash.cc
index 159dff3..1754b69 100644
--- a/src/lib/dns/nsec3hash.cc
+++ b/src/lib/dns/nsec3hash.cc
@@ -19,11 +19,10 @@
#include <string>
#include <vector>
-#include <boost/noncopyable.hpp>
-
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <util/encode/base32hex.h>
#include <util/hash/sha1.h>
@@ -50,7 +49,7 @@ namespace {
/// The implementation details are only open within this file, but to avoid
/// an accidental error in this implementation we explicitly make it non
/// copyable.
-class NSEC3HashRFC5155 : boost::noncopyable, public NSEC3Hash {
+class NSEC3HashRFC5155 : isc::util::noncopyable, public NSEC3Hash {
private:
// This is the algorithm number for SHA1/NSEC3 as defined in RFC5155.
static const uint8_t NSEC3_HASH_SHA1 = 1;
diff --git a/src/lib/dns/python/pydnspp_towire.h b/src/lib/dns/python/pydnspp_towire.h
index e987a29..286e433 100644
--- a/src/lib/dns/python/pydnspp_towire.h
+++ b/src/lib/dns/python/pydnspp_towire.h
@@ -22,6 +22,7 @@
#include <dns/messagerenderer.h>
+#include <util/nonassignable.h>
#include <util/buffer.h>
#include <util/python/pycppwrapper_util.h>
@@ -35,7 +36,7 @@ namespace python {
// toWire() template implementation for two types of toWire() methods:
// return an integer or have no return value.
template <typename CPPCLASS>
-struct ToWireCallVoid {
+struct ToWireCallVoid : isc::util::nonassignable {
ToWireCallVoid(CPPCLASS& cppobj) : cppobj_(cppobj) {}
int operator()(AbstractMessageRenderer& renderer) const {
cppobj_.toWire(renderer);
@@ -45,7 +46,7 @@ struct ToWireCallVoid {
};
template <typename CPPCLASS>
-struct ToWireCallInt {
+struct ToWireCallInt : isc::util::nonassignable {
ToWireCallInt(CPPCLASS& cppobj) : cppobj_(cppobj) {}
int operator()(AbstractMessageRenderer& renderer) const {
return (cppobj_.toWire(renderer));
diff --git a/src/lib/dns/rdata.h b/src/lib/dns/rdata.h
index afcf4b3..ac6efc3 100644
--- a/src/lib/dns/rdata.h
+++ b/src/lib/dns/rdata.h
@@ -19,6 +19,8 @@
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
namespace isc {
@@ -124,13 +126,10 @@ const unsigned int MAX_CHARSTRING_LEN = 255;
/// specifically concerned about a particular type.
/// So, this API generally handles \c Rdata in a polymorphic way through
/// a pointer or reference to this base abstract class.
-class Rdata {
+class Rdata : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private. Concrete classes should generally specialize their
- /// own versions of these methods.
//@{
protected:
/// The default constructor.
@@ -141,9 +140,6 @@ protected:
/// either, because an \c Rdata object without concrete data isn't
/// meaningful.
Rdata() {}
-private:
- Rdata(const Rdata& source);
- void operator=(const Rdata& source);
public:
/// The destructor.
virtual ~Rdata() {};
diff --git a/src/lib/dns/rdata/any_255/tsig_250.cc b/src/lib/dns/rdata/any_255/tsig_250.cc
index ff848fa..8cad1b8 100644
--- a/src/lib/dns/rdata/any_255/tsig_250.cc
+++ b/src/lib/dns/rdata/any_255/tsig_250.cc
@@ -18,6 +18,7 @@
#include <boost/lexical_cast.hpp>
+#include <util/nonassignable.h>
#include <util/buffer.h>
#include <util/strutil.h>
#include <util/encode/base64.h>
@@ -38,7 +39,7 @@ using namespace isc::util::str;
// BEGIN_RDATA_NAMESPACE
/// This is a straightforward representation of TSIG RDATA fields.
-struct TSIG::TSIGImpl {
+struct TSIG::TSIGImpl : isc::util::nonassignable {
TSIGImpl(const Name& algorithm, uint64_t time_signed, uint16_t fudge,
vector<uint8_t>& mac, uint16_t original_id, uint16_t error,
vector<uint8_t>& other_data) :
diff --git a/src/lib/dns/rdata/generic/detail/nsec3param_common.h b/src/lib/dns/rdata/generic/detail/nsec3param_common.h
index 515777b..85b1c13 100644
--- a/src/lib/dns/rdata/generic/detail/nsec3param_common.h
+++ b/src/lib/dns/rdata/generic/detail/nsec3param_common.h
@@ -15,6 +15,7 @@
#ifndef __NSEC3PARAM_COMMON_H
#define __NSEC3PARAM_COMMON_H 1
+#include <util/nonassignable.h>
#include <util/buffer.h>
#include <stdint.h>
@@ -46,7 +47,7 @@ namespace nsec3 {
/// flags and iterations field values. This is used as the return value
/// of the utility functions defined in this module so the caller can
/// use it for constructing the corresponding RDATA.
-struct ParseNSEC3ParamResult {
+struct ParseNSEC3ParamResult : isc::util::nonassignable {
ParseNSEC3ParamResult(uint8_t param_algorithm, uint8_t param_flags,
uint16_t param_iterations) :
algorithm(param_algorithm), flags(param_flags),
diff --git a/src/lib/dns/rdata/generic/dnskey_48.cc b/src/lib/dns/rdata/generic/dnskey_48.cc
index 054ac18..2477155 100644
--- a/src/lib/dns/rdata/generic/dnskey_48.cc
+++ b/src/lib/dns/rdata/generic/dnskey_48.cc
@@ -20,6 +20,7 @@
#include <boost/lexical_cast.hpp>
#include <boost/foreach.hpp>
+#include <util/nonassignable.h>
#include <util/encode/base64.h>
#include <util/buffer.h>
#include <dns/messagerenderer.h>
@@ -37,7 +38,7 @@ using namespace isc::util::encode;
// BEGIN_ISC_NAMESPACE
// BEGIN_RDATA_NAMESPACE
-struct DNSKEYImpl {
+struct DNSKEYImpl : isc::util::nonassignable {
// straightforward representation of DNSKEY RDATA fields
DNSKEYImpl(uint16_t flags, uint8_t protocol, uint8_t algorithm,
const vector<uint8_t>& keydata) :
diff --git a/src/lib/dns/rdata/generic/nsec3_50.cc b/src/lib/dns/rdata/generic/nsec3_50.cc
index fb92246..bd4ef4b 100644
--- a/src/lib/dns/rdata/generic/nsec3_50.cc
+++ b/src/lib/dns/rdata/generic/nsec3_50.cc
@@ -21,6 +21,7 @@
#include <boost/lexical_cast.hpp>
+#include <util/nonassignable.h>
#include <util/encode/base32hex.h>
#include <util/encode/hex.h>
#include <util/buffer.h>
@@ -47,7 +48,7 @@ using namespace isc::util;
// BEGIN_ISC_NAMESPACE
// BEGIN_RDATA_NAMESPACE
-struct NSEC3Impl {
+struct NSEC3Impl : isc::util::nonassignable {
// straightforward representation of NSEC3 RDATA fields
NSEC3Impl(uint8_t hashalg, uint8_t flags, uint16_t iterations,
vector<uint8_t>salt, vector<uint8_t>next,
diff --git a/src/lib/dns/rdata/generic/nsec3param_51.cc b/src/lib/dns/rdata/generic/nsec3param_51.cc
index 5686353..657123a 100644
--- a/src/lib/dns/rdata/generic/nsec3param_51.cc
+++ b/src/lib/dns/rdata/generic/nsec3param_51.cc
@@ -12,6 +12,7 @@
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
+#include <util/nonassignable.h>
#include <util/buffer.h>
#include <util/encode/hex.h>
@@ -33,7 +34,7 @@ using namespace isc::util::encode;
// BEGIN_ISC_NAMESPACE
// BEGIN_RDATA_NAMESPACE
-struct NSEC3PARAMImpl {
+struct NSEC3PARAMImpl : isc::util::nonassignable {
// straightforward representation of NSEC3PARAM RDATA fields
NSEC3PARAMImpl(uint8_t hashalg, uint8_t flags, uint16_t iterations,
const vector<uint8_t>& salt) :
diff --git a/src/lib/dns/rdata/generic/rrsig_46.cc b/src/lib/dns/rdata/generic/rrsig_46.cc
index e0137b9..f562319 100644
--- a/src/lib/dns/rdata/generic/rrsig_46.cc
+++ b/src/lib/dns/rdata/generic/rrsig_46.cc
@@ -20,6 +20,7 @@
#include <boost/lexical_cast.hpp>
+#include <util/nonassignable.h>
#include <util/encode/base64.h>
#include <util/buffer.h>
#include <util/time_utilities.h>
@@ -49,7 +50,7 @@ const size_t RRSIG_MINIMUM_LEN = 2 * sizeof(uint8_t) + 2 * sizeof(uint16_t) +
3 * sizeof(uint32_t);
}
-struct RRSIGImpl {
+struct RRSIGImpl : isc::util::nonassignable {
// straightforward representation of RRSIG RDATA fields
RRSIGImpl(const RRType& covered, uint8_t algorithm, uint8_t labels,
uint32_t originalttl, uint32_t timeexpire, uint32_t timeinception,
diff --git a/src/lib/dns/rdatafields.cc b/src/lib/dns/rdatafields.cc
index 94c9dbf..695c5e8 100644
--- a/src/lib/dns/rdatafields.cc
+++ b/src/lib/dns/rdatafields.cc
@@ -20,6 +20,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/messagerenderer.h>
#include <dns/name.h>
#include <dns/rdata.h>
@@ -42,7 +43,7 @@ namespace rdata {
/// To minimize construction overhead in the other case, an instance of
/// this class is instantiated only when necessary - we don't need the vectors
/// when only rendering.
-struct RdataFields::RdataFieldsDetail {
+struct RdataFields::RdataFieldsDetail : isc::util::nonassignable {
RdataFieldsDetail(const vector<FieldSpec>& fields,
const uint8_t* data, size_t data_length) :
allocated_fields_(fields),
diff --git a/src/lib/dns/rrset.h b/src/lib/dns/rrset.h
index 6c73d60..2cf0110 100644
--- a/src/lib/dns/rrset.h
+++ b/src/lib/dns/rrset.h
@@ -20,6 +20,8 @@
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
#include <dns/rdata.h>
@@ -159,16 +161,11 @@ typedef boost::shared_ptr<RdataIterator> RdataIteratorPtr;
/// monolithic.)
/// - Do we need to allow the user to remove specific Rdata?
/// Probably not, according to the current usage of the BIND9 code.
-class AbstractRRset {
+class AbstractRRset : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private to make it explicit that this is a pure base class.
//@{
-private:
- AbstractRRset(const AbstractRRset& source);
- AbstractRRset& operator=(const AbstractRRset& source);
protected:
/// \brief The default constructor.
///
@@ -532,12 +529,10 @@ public:
/// Most applications will simply go through the RDATA objects contained in
/// an RRset, examining (and possibly using) each object, as one path
/// operation.
-class RdataIterator {
+class RdataIterator : isc::util::noncopyable {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private to make it explicit that this is a pure base class.
//@{
protected:
/// \brief The default constructor.
@@ -548,9 +543,6 @@ protected:
public:
/// \brief Destructor
virtual ~RdataIterator() {}
-private:
- RdataIterator(const RdataIterator& source);
- RdataIterator& operator=(const RdataIterator& source);
//@}
public:
@@ -607,14 +599,7 @@ class BasicRRset : public AbstractRRset {
///
/// \name Constructors and Destructor
///
- /// Note: The copy constructor and the assignment operator are intentionally
- /// defined as private. The intended use case wouldn't require copies of
- /// a \c BasicRRset object; once created, it would normally be used
- /// as a \c const object (via references).
//@{
-private:
- BasicRRset(const BasicRRset& source);
- BasicRRset& operator=(const BasicRRset& source);
public:
/// \brief Constructor from (mostly) fixed parameters of the RRset.
///
diff --git a/src/lib/dns/rrsetlist.h b/src/lib/dns/rrsetlist.h
index 0e05b5b..4db3ff2 100644
--- a/src/lib/dns/rrsetlist.h
+++ b/src/lib/dns/rrsetlist.h
@@ -21,6 +21,8 @@
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
+
#include <dns/rrset.h>
#include <dns/rrclass.h>
#include <dns/rrtype.h>
@@ -94,10 +96,7 @@ private:
/// reason and is actually quite specific to a particular need for libdatasrc.
/// If you are tempted to use it, think twice to assess if this class
/// is really what you want. Again, in many cases the answer will be no.
-class RRsetList {
-private:
- RRsetList(const RRsetList& source);
- RRsetList& operator=(const RRsetList& source);
+class RRsetList : isc::util::noncopyable {
public:
RRsetList() {}
void addRRset(RRsetPtr new_rrsetptr);
diff --git a/src/lib/dns/rrtype-placeholder.h b/src/lib/dns/rrtype-placeholder.h
index dad1b2b..95a84c6 100644
--- a/src/lib/dns/rrtype-placeholder.h
+++ b/src/lib/dns/rrtype-placeholder.h
@@ -157,7 +157,7 @@ public:
///
/// We use the default copy constructor intentionally.
//@}
- /// We use the default copy assignment operator intentionally.
+ /// We use the default assignment operator intentionally.
///
///
diff --git a/src/lib/dns/tests/masterload_unittest.cc b/src/lib/dns/tests/masterload_unittest.cc
index 95ce6f3..0b30d27 100644
--- a/src/lib/dns/tests/masterload_unittest.cc
+++ b/src/lib/dns/tests/masterload_unittest.cc
@@ -23,6 +23,7 @@
#include <gtest/gtest.h>
+#include <util/nonassignable.h>
#include <dns/masterload.h>
#include <dns/name.h>
#include <dns/rdata.h>
@@ -34,7 +35,8 @@ using namespace isc::dns;
namespace {
// A callback functor for masterLoad() commonly used for the following tests.
-class TestCallback : public unary_function<ConstRRsetPtr, void> {
+class TestCallback : isc::util::nonassignable,
+ public unary_function<ConstRRsetPtr, void> {
public:
TestCallback(vector<ConstRRsetPtr>& rrsets) : rrsets_(rrsets) {}
void operator()(ConstRRsetPtr rrset) {
@@ -345,7 +347,8 @@ TEST_F(MasterLoadTest, loadBadRRText) {
// This is a helper callback to test the case the input stream becomes bad
// in the middle of processing.
-class StreamInvalidator : public unary_function<ConstRRsetPtr, void> {
+class StreamInvalidator : isc::util::nonassignable,
+ public unary_function<ConstRRsetPtr, void> {
public:
StreamInvalidator(stringstream& ss) : ss_(ss) {}
void operator()(ConstRRsetPtr) {
diff --git a/src/lib/dns/tsig.cc b/src/lib/dns/tsig.cc
index 1bda021..fb9a48d 100644
--- a/src/lib/dns/tsig.cc
+++ b/src/lib/dns/tsig.cc
@@ -57,7 +57,7 @@ getTSIGTime() {
}
}
-struct TSIGContext::TSIGContextImpl {
+struct TSIGContext::TSIGContextImpl : isc::util::nonassignable {
TSIGContextImpl(const TSIGKey& key,
TSIGError error = TSIGError::NOERROR()) :
state_(INIT), key_(key), error_(error),
diff --git a/src/lib/dns/tsig.h b/src/lib/dns/tsig.h
index 028d295..73e7fda 100644
--- a/src/lib/dns/tsig.h
+++ b/src/lib/dns/tsig.h
@@ -15,8 +15,7 @@
#ifndef __TSIG_H
#define __TSIG_H 1
-#include <boost/noncopyable.hpp>
-
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
#include <dns/tsigerror.h>
@@ -172,7 +171,7 @@ public:
/// direct or indirect dependencies. The interface of \c sign() that takes
/// opaque data (instead of, e.g., a \c Message or \c MessageRenderer object)
/// is therefore a deliberate design decision.
-class TSIGContext : boost::noncopyable {
+class TSIGContext : isc::util::noncopyable {
public:
/// Internal state of context
///
diff --git a/src/lib/dns/tsigkey.cc b/src/lib/dns/tsigkey.cc
index d7d60eb..96608aa 100644
--- a/src/lib/dns/tsigkey.cc
+++ b/src/lib/dns/tsigkey.cc
@@ -56,8 +56,7 @@ namespace {
}
}
-struct
-TSIGKey::TSIGKeyImpl {
+struct TSIGKey::TSIGKeyImpl : isc::util::nonassignable {
TSIGKeyImpl(const Name& key_name, const Name& algorithm_name,
isc::cryptolink::HashAlgorithm algorithm,
const void* secret, size_t secret_len) :
diff --git a/src/lib/dns/tsigkey.h b/src/lib/dns/tsigkey.h
index 6081dd3..334330c 100644
--- a/src/lib/dns/tsigkey.h
+++ b/src/lib/dns/tsigkey.h
@@ -15,6 +15,7 @@
#ifndef __TSIGKEY_H
#define __TSIGKEY_H 1
+#include <util/nonassignable.h>
#include <cryptolink/cryptolink.h>
namespace isc {
@@ -258,7 +259,7 @@ public:
///
/// See the description of \c find() for the semantics of the member
/// variables.
- struct FindResult {
+ struct FindResult : isc::util::nonassignable {
FindResult(Result param_code, const TSIGKey* param_key) :
code(param_code), key(param_key)
{}
diff --git a/src/lib/dns/tsigrecord.h b/src/lib/dns/tsigrecord.h
index 03de746..5fb3fa1 100644
--- a/src/lib/dns/tsigrecord.h
+++ b/src/lib/dns/tsigrecord.h
@@ -21,6 +21,7 @@
#include <boost/shared_ptr.hpp>
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <dns/name.h>
#include <dns/rdataclass.h>
@@ -59,7 +60,7 @@ class AbstractMessageRenderer;
/// handle it through a generic interface in a polymorphic way.
/// We therefore chose to define it as a separate class. This is also
/// similar to why \c EDNS is a separate class.
-class TSIGRecord {
+class TSIGRecord : isc::util::nonassignable {
public:
///
/// \name Constructors
diff --git a/src/lib/exceptions/exceptions.h b/src/lib/exceptions/exceptions.h
index 010fd39..3d25869 100644
--- a/src/lib/exceptions/exceptions.h
+++ b/src/lib/exceptions/exceptions.h
@@ -19,6 +19,8 @@
#include <string>
#include <sstream>
+#include <util/nonassignable.h>
+
namespace isc {
///
@@ -28,7 +30,7 @@ namespace isc {
/// exception such as the file name and line number where the exception is
/// triggered.
///
-class Exception : public std::exception {
+class Exception : isc::util::nonassignable, public std::exception {
public:
///
/// \name Constructors and Destructor
@@ -55,11 +57,6 @@ public:
/// The destructor
virtual ~Exception() throw() {}
//@}
-private:
- ///
- /// The assignment operator is intentionally disabled.
- ///
- void operator=(const Exception& src);
public:
///
diff --git a/src/lib/log/logger.h b/src/lib/log/logger.h
index 6405488..85c407b 100644
--- a/src/lib/log/logger.h
+++ b/src/lib/log/logger.h
@@ -20,6 +20,7 @@
#include <string>
#include <cstring>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
#include <log/logger_level.h>
#include <log/message_types.h>
@@ -122,7 +123,7 @@ public:
/// These will avoid the potentially-expensive evaluation of arguments if the
/// severity is such that the message will be suppressed.)
-class Logger {
+class Logger : isc::util::noncopyable {
public:
/// Maximum size of a logger name
static const size_t MAX_LOGGER_NAME_SIZE = 31;
@@ -278,18 +279,6 @@ private:
/// \param message Text of the message to be output.
void output(const Severity& severity, const std::string& message);
- /// \brief Copy Constructor
- ///
- /// Disabled (marked private) as it makes no sense to copy the logger -
- /// just create another one of the same name.
- Logger(const Logger&);
-
- /// \brief Assignment Operator
- ///
- /// Disabled (marked private) as it makes no sense to copy the logger -
- /// just create another one of the same name.
- Logger& operator=(const Logger&);
-
/// \brief Initialize Implementation
///
/// Returns the logger pointer. If not yet set, the implementation class is
diff --git a/src/lib/nsas/hash_deleter.h b/src/lib/nsas/hash_deleter.h
index 27f066e..8b3c2b8 100644
--- a/src/lib/nsas/hash_deleter.h
+++ b/src/lib/nsas/hash_deleter.h
@@ -17,6 +17,7 @@
#include <boost/shared_ptr.hpp>
#include <util/lru_list.h>
+#include <util/nonassignable.h>
#include "hash_table.h"
@@ -32,7 +33,8 @@ namespace nsas {
/// hash table without the need to be declared as "friend" or the need
/// to define accessor methods.
template <typename T>
-class HashDeleter : public isc::util::LruList<T>::Dropped {
+class HashDeleter : isc::util::nonassignable,
+ public isc::util::LruList<T>::Dropped {
public:
/// \brief Constructor
@@ -49,8 +51,7 @@ public:
///
virtual ~HashDeleter(){}
- // The default copy constructor and assignment operator are correct for
- // this object.
+ // The default copy constructor is correct for this object.
/// \brief Deletion Function
///
diff --git a/src/lib/nsas/zone_entry.cc b/src/lib/nsas/zone_entry.cc
index 8a72e5f..722354c 100644
--- a/src/lib/nsas/zone_entry.cc
+++ b/src/lib/nsas/zone_entry.cc
@@ -350,7 +350,7 @@ updateAddressSelector(std::vector<NameserverAddress>& addresses,
* the value gets set to false when we leave the function, so we use
* a Guard object, that sets it when it gets out of scope.
*/
-class ZoneEntry::ProcessGuard {
+class ZoneEntry::ProcessGuard : isc::util::nonassignable {
public:
ProcessGuard(bool& guarded) :
guarded_(guarded)
diff --git a/src/lib/nsas/zone_entry.h b/src/lib/nsas/zone_entry.h
index 482b89f..486357c 100644
--- a/src/lib/nsas/zone_entry.h
+++ b/src/lib/nsas/zone_entry.h
@@ -25,6 +25,7 @@
#include <resolve/resolver_interface.h>
+#include <util/nonassignable.h>
#include <util/locks.h>
#include <util/random/random_number_generator.h>
@@ -52,7 +53,8 @@ class AddressRequestCallback;
///
/// It uses shared_from_this in its methods. It must live inside a shared_ptr.
-class ZoneEntry : public NsasEntry<ZoneEntry>, public Fetchable {
+class ZoneEntry : isc::util::nonassignable,
+ public NsasEntry<ZoneEntry>, public Fetchable {
public:
/**
diff --git a/src/lib/python/isc/util/cio/socketsessionreceiver_python.cc b/src/lib/python/isc/util/cio/socketsessionreceiver_python.cc
index c79f6e0..8efe7bc 100644
--- a/src/lib/python/isc/util/cio/socketsessionreceiver_python.cc
+++ b/src/lib/python/isc/util/cio/socketsessionreceiver_python.cc
@@ -156,7 +156,7 @@ SocketSessionReceiver_destroy(PyObject* po_self) {
}
// A helper struct to automatically close a socket in an RAII manner.
-struct ScopedSocket : boost::noncopyable {
+struct ScopedSocket : isc::util::noncopyable {
ScopedSocket(int fd) : fd_(fd) {}
~ScopedSocket() {
close(fd_);
diff --git a/src/lib/resolve/recursive_query.h b/src/lib/resolve/recursive_query.h
index a819a94..c17c98c 100644
--- a/src/lib/resolve/recursive_query.h
+++ b/src/lib/resolve/recursive_query.h
@@ -16,6 +16,7 @@
#define __RECURSIVE_QUERY_H 1
#include <util/buffer.h>
+#include <util/nonassignable.h>
#include <asiodns/dns_service.h>
#include <asiodns/dns_server.h>
#include <nsas/nameserver_address_store.h>
@@ -58,7 +59,7 @@ private:
/// The \c RecursiveQuery class provides a layer of abstraction around
/// the ASIO code that carries out an upstream query.
-class RecursiveQuery {
+class RecursiveQuery : isc::util::nonassignable {
///
/// \name Constructors
///
diff --git a/src/lib/resolve/resolve.cc b/src/lib/resolve/resolve.cc
index f741121..24cd356 100644
--- a/src/lib/resolve/resolve.cc
+++ b/src/lib/resolve/resolve.cc
@@ -12,6 +12,8 @@
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
+#include <util/nonassignable.h>
+
#include <resolve/resolve.h>
#include <dns/message.h>
@@ -20,7 +22,7 @@
using namespace isc::dns;
namespace {
- class SectionInserter {
+ class SectionInserter : isc::util::nonassignable {
public:
SectionInserter(MessagePtr message, const Message::Section sect) :
message_(message), section_(sect)
diff --git a/src/lib/resolve/tests/recursive_query_unittest.cc b/src/lib/resolve/tests/recursive_query_unittest.cc
index 02721f1..65906c0 100644
--- a/src/lib/resolve/tests/recursive_query_unittest.cc
+++ b/src/lib/resolve/tests/recursive_query_unittest.cc
@@ -20,7 +20,6 @@
#include <cstring>
-#include <boost/noncopyable.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
#include <boost/scoped_ptr.hpp>
@@ -34,6 +33,7 @@
#include <dns/rcode.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <util/unittests/resolver.h>
#include <dns/message.h>
#include <dns/rdataclass.h>
@@ -132,7 +132,7 @@ struct ScopedAddrInfo {
// operation so it can release the ownership of the FD.
// This is made non copyable to avoid making an accidental copy, which could
// result in duplicate close.
-struct ScopedSocket : private boost::noncopyable {
+struct ScopedSocket : private isc::util::noncopyable {
ScopedSocket() : s_(-1) {}
ScopedSocket(int s) : s_(s) {}
~ScopedSocket() {
@@ -369,7 +369,7 @@ protected:
// This is a nonfunctional mockup of a DNSServer object. Its purpose
// is to resume after a recursive query or other asynchronous call
// has completed.
- class MockServer : public DNSServer {
+ class MockServer : isc::util::nonassignable, public DNSServer {
public:
explicit MockServer(IOService& io_service,
SimpleCallback* checkin = NULL,
diff --git a/src/lib/resolve/tests/recursive_query_unittest_3.cc b/src/lib/resolve/tests/recursive_query_unittest_3.cc
index 168ec80..d1a55a4 100644
--- a/src/lib/resolve/tests/recursive_query_unittest_3.cc
+++ b/src/lib/resolve/tests/recursive_query_unittest_3.cc
@@ -26,6 +26,7 @@
#include <util/buffer.h>
#include <util/io_utilities.h>
+#include <util/nonassignable.h>
#include <dns/question.h>
#include <dns/message.h>
@@ -91,7 +92,8 @@ public:
/// \brief Test fixture for the RecursiveQuery Test
-class RecursiveQueryTest3 : public virtual ::testing::Test
+class RecursiveQueryTest3 : isc::util::nonassignable,
+ public virtual ::testing::Test
{
public:
diff --git a/src/lib/server_common/client.cc b/src/lib/server_common/client.cc
index e6383d6..30e0ef6 100644
--- a/src/lib/server_common/client.cc
+++ b/src/lib/server_common/client.cc
@@ -15,6 +15,8 @@
#include <string>
#include <sstream>
+#include <util/nonassignable.h>
+
#include <acl/ip_check.h>
#include <asiolink/io_endpoint.h>
@@ -26,7 +28,7 @@ using namespace isc::acl;
using namespace isc::server_common;
using namespace isc::asiolink;
-struct Client::ClientImpl {
+struct Client::ClientImpl : isc::util::nonassignable {
ClientImpl(const IOMessage& request_message) :
request_(request_message),
request_src_(request_.getRemoteEndpoint().getSockAddr())
diff --git a/src/lib/server_common/client.h b/src/lib/server_common/client.h
index 8cafb1e..ec0e352 100644
--- a/src/lib/server_common/client.h
+++ b/src/lib/server_common/client.h
@@ -18,8 +18,7 @@
#include <string>
#include <ostream>
-#include <boost/noncopyable.hpp>
-
+#include <util/noncopyable.h>
#include <acl/ip_check.h>
namespace isc {
@@ -67,7 +66,7 @@ namespace server_common {
/// We might also want to separate DNS clients for authoritative servers
/// and clients for the resolver, especially because the former could be
/// simpler with performance optimizations.
-class Client : boost::noncopyable {
+class Client : isc::util::noncopyable {
public:
///
/// \name Constructors and Destructor
diff --git a/src/lib/server_common/socket_request.h b/src/lib/server_common/socket_request.h
index aac95d1..f6ed58e 100644
--- a/src/lib/server_common/socket_request.h
+++ b/src/lib/server_common/socket_request.h
@@ -16,8 +16,8 @@
#define __SOCKET_REQUEST_H 1
#include <exceptions/exceptions.h>
+#include <util/noncopyable.h>
-#include <boost/noncopyable.hpp>
#include <utility>
#include <string>
#include <stdint.h>
@@ -43,7 +43,7 @@ namespace server_common {
/// subclass when needed.
///
/// \see socketRequestor function to access the object of this class.
-class SocketRequestor : boost::noncopyable {
+class SocketRequestor : isc::util::noncopyable {
protected:
/// \brief Protected constructor
///
diff --git a/src/lib/statistics/counter.cc b/src/lib/statistics/counter.cc
index 53dc58e..9a781b4 100644
--- a/src/lib/statistics/counter.cc
+++ b/src/lib/statistics/counter.cc
@@ -14,8 +14,7 @@
#include <vector>
-#include <boost/noncopyable.hpp>
-
+#include <util/noncopyable.h>
#include <statistics/counter.h>
namespace {
@@ -25,7 +24,7 @@ const unsigned int InitialValue = 0;
namespace isc {
namespace statistics {
-class CounterImpl : boost::noncopyable {
+class CounterImpl : isc::util::noncopyable {
private:
std::vector<Counter::Value> counters_;
public:
diff --git a/src/lib/statistics/counter.h b/src/lib/statistics/counter.h
index 9e467ce..d276837 100644
--- a/src/lib/statistics/counter.h
+++ b/src/lib/statistics/counter.h
@@ -15,9 +15,9 @@
#ifndef __COUNTER_H
#define __COUNTER_H 1
-#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
namespace isc {
@@ -26,7 +26,7 @@ namespace statistics {
// forward declaration for pImpl idiom
class CounterImpl;
-class Counter : boost::noncopyable {
+class Counter : isc::util::noncopyable {
private:
boost::scoped_ptr<CounterImpl> impl_;
public:
diff --git a/src/lib/statistics/counter_dict.cc b/src/lib/statistics/counter_dict.cc
index 55353b2..c56619b 100644
--- a/src/lib/statistics/counter_dict.cc
+++ b/src/lib/statistics/counter_dict.cc
@@ -16,9 +16,9 @@
#include <stdexcept>
#include <iterator>
#include <map>
-#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
+#include <util/noncopyable.h>
#include <statistics/counter_dict.h>
namespace {
@@ -32,7 +32,7 @@ namespace statistics {
// Implementation detail class for CounterDictionary::ConstIterator
class CounterDictionaryConstIteratorImpl;
-class CounterDictionaryImpl : boost::noncopyable {
+class CounterDictionaryImpl : isc::util::noncopyable {
private:
DictionaryMap dictionary_;
std::vector<std::string> elements_;
diff --git a/src/lib/statistics/counter_dict.h b/src/lib/statistics/counter_dict.h
index e322119..e38a45c 100644
--- a/src/lib/statistics/counter_dict.h
+++ b/src/lib/statistics/counter_dict.h
@@ -18,10 +18,10 @@
#include <string>
#include <vector>
#include <utility>
-#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/iterator/iterator_facade.hpp>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
#include <statistics/counter.h>
@@ -31,7 +31,7 @@ namespace statistics {
class CounterDictionaryImpl;
class CounterDictionaryConstIteratorImpl;
-class CounterDictionary : boost::noncopyable {
+class CounterDictionary : isc::util::noncopyable {
private:
boost::scoped_ptr<CounterDictionaryImpl> impl_;
// Default constructor is forbidden; number of counter items must be
diff --git a/src/lib/testutils/dnsmessage_test.h b/src/lib/testutils/dnsmessage_test.h
index 57cb72c..5b80d2e 100644
--- a/src/lib/testutils/dnsmessage_test.h
+++ b/src/lib/testutils/dnsmessage_test.h
@@ -28,6 +28,8 @@
#include <dns/rrclass.h>
#include <dns/rrset.h>
+#include <util/nonassignable.h>
+
#include <gtest/gtest.h>
namespace isc {
@@ -123,7 +125,9 @@ namespace detail {
// 'type covered' are different. For simplicity, we only compare the types
// of the first RRSIG RDATAs (and only check when they exist); if there's
// further difference in the RDATA, the main comparison checks will detect it.
-struct RRsetMatch : public std::unary_function<isc::dns::ConstRRsetPtr, bool> {
+struct RRsetMatch : isc::util::nonassignable,
+ public std::unary_function<isc::dns::ConstRRsetPtr, bool>
+{
RRsetMatch(isc::dns::ConstRRsetPtr target) : target_(target) {}
bool operator()(isc::dns::ConstRRsetPtr rrset) const {
if (rrset->getType() != target_->getType() ||
@@ -149,7 +153,7 @@ struct RRsetMatch : public std::unary_function<isc::dns::ConstRRsetPtr, bool> {
// Helper callback functor for masterLoad() used in rrsetsCheck (stream
// version)
-class RRsetInserter {
+class RRsetInserter : isc::util::nonassignable {
public:
RRsetInserter(std::vector<isc::dns::ConstRRsetPtr>& rrsets) :
rrsets_(rrsets)
@@ -161,7 +165,7 @@ private:
std::vector<isc::dns::ConstRRsetPtr>& rrsets_;
};
-class RRsetDumper {
+class RRsetDumper : isc::util::nonassignable {
public:
RRsetDumper(std::string& output) :
output_(output)
diff --git a/src/lib/util/encode/base16_from_binary.h b/src/lib/util/encode/base16_from_binary.h
index 8606c61..29b4f59 100644
--- a/src/lib/util/encode/base16_from_binary.h
+++ b/src/lib/util/encode/base16_from_binary.h
@@ -29,6 +29,8 @@ namespace std{
// See base32hex_from_binary.h for why we need base64_from...hpp here.
#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <util/nonassignable.h>
+
namespace boost {
namespace archive {
namespace iterators {
@@ -70,11 +72,8 @@ template<
class Base,
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
>
-class base16_from_binary :
- public transform_iterator<
- detail::from_4_bit<CharType>,
- Base
- >
+class base16_from_binary : isc::util::nonassignable,
+ public transform_iterator<detail::from_4_bit<CharType>, Base>
{
friend class boost::iterator_core_access;
typedef transform_iterator<
diff --git a/src/lib/util/encode/base32hex_from_binary.h b/src/lib/util/encode/base32hex_from_binary.h
index 5d16d04..0d0472a 100644
--- a/src/lib/util/encode/base32hex_from_binary.h
+++ b/src/lib/util/encode/base32hex_from_binary.h
@@ -31,6 +31,8 @@ namespace std{
// simply include the base64 header here.
#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <util/nonassignable.h>
+
namespace boost {
namespace archive {
namespace iterators {
@@ -72,11 +74,8 @@ template<
class Base,
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
>
-class base32hex_from_binary :
- public transform_iterator<
- detail::from_5_bit<CharType>,
- Base
- >
+class base32hex_from_binary : isc::util::nonassignable,
+ public transform_iterator<detail::from_5_bit<CharType>, Base>
{
friend class boost::iterator_core_access;
typedef transform_iterator<
diff --git a/src/lib/util/encode/base_n.cc b/src/lib/util/encode/base_n.cc
index 0026a0b..23aed5b 100644
--- a/src/lib/util/encode/base_n.cc
+++ b/src/lib/util/encode/base_n.cc
@@ -23,6 +23,7 @@
#include <boost/archive/iterators/transform_width.hpp>
#include <boost/math/common_factor.hpp>
+#include <util/nonassignable.h>
#include <util/encode/base32hex_from_binary.h>
#include <util/encode/binary_from_base32hex.h>
#include <util/encode/base16_from_binary.h>
@@ -104,7 +105,8 @@ const uint8_t BINARY_ZERO_CODE = 0;
// Note: this class is intended to be used within this implementation file,
// and assumes "base < base_end" on construction without validating the
// arguments. The behavior is undefined if this assumption doesn't hold.
-class EncodeNormalizer : public iterator<input_iterator_tag, uint8_t> {
+class EncodeNormalizer : isc::util::nonassignable,
+ public iterator<input_iterator_tag, uint8_t> {
public:
EncodeNormalizer(const vector<uint8_t>::const_iterator& base,
const vector<uint8_t>::const_iterator& base_end) :
@@ -151,7 +153,8 @@ private:
// and for simplicity assumes "base < base_beginpad <= base_end" on
// construction without validating the arguments. The behavior is undefined
// if this assumption doesn't hold.
-class DecodeNormalizer : public iterator<input_iterator_tag, char> {
+class DecodeNormalizer : isc::util::nonassignable,
+ public iterator<input_iterator_tag, char> {
public:
DecodeNormalizer(const char base_zero_code,
const string::const_iterator& base,
diff --git a/src/lib/util/encode/binary_from_base16.h b/src/lib/util/encode/binary_from_base16.h
index 50342f1..70d9661 100644
--- a/src/lib/util/encode/binary_from_base16.h
+++ b/src/lib/util/encode/binary_from_base16.h
@@ -21,6 +21,8 @@
// See binary_from_base32hex.h for why we need _from_base64.hpp here.
#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <util/nonassignable.h>
+
#include <exceptions/exceptions.h>
namespace boost {
@@ -79,11 +81,8 @@ template<
class Base,
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
>
-class binary_from_base16 : public
- transform_iterator<
- detail::to_4_bit<CharType>,
- Base
- >
+class binary_from_base16 : isc::util::nonassignable,
+ public transform_iterator<detail::to_4_bit<CharType>, Base>
{
friend class boost::iterator_core_access;
typedef transform_iterator<
diff --git a/src/lib/util/encode/binary_from_base32hex.h b/src/lib/util/encode/binary_from_base32hex.h
index 1d83f54..f2c7edb 100644
--- a/src/lib/util/encode/binary_from_base32hex.h
+++ b/src/lib/util/encode/binary_from_base32hex.h
@@ -23,6 +23,8 @@
// simply include the base64 header here.
#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <util/nonassignable.h>
+
#include <exceptions/exceptions.h>
namespace boost {
@@ -82,11 +84,8 @@ template<
class Base,
class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
>
-class binary_from_base32hex : public
- transform_iterator<
- detail::to_5_bit<CharType>,
- Base
- >
+class binary_from_base32hex : isc::util::nonassignable,
+ public transform_iterator<detail::to_5_bit<CharType>, Base>
{
friend class boost::iterator_core_access;
typedef transform_iterator<
diff --git a/src/lib/util/interprocess_sync.h b/src/lib/util/interprocess_sync.h
index e4fa7af..b07f21b 100644
--- a/src/lib/util/interprocess_sync.h
+++ b/src/lib/util/interprocess_sync.h
@@ -17,6 +17,8 @@
#include <string>
+#include <util/nonassignable.h>
+
namespace isc {
namespace util {
@@ -42,7 +44,7 @@ class InterprocessSyncLocker; // forward declaration
/// NOTE: All implementations of InterprocessSync should keep the
/// is_locked_ member variable updated whenever their
/// lock()/tryLock()/unlock() implementations are called.
-class InterprocessSync {
+class InterprocessSync : isc::util::nonassignable {
// InterprocessSyncLocker is the only code outside this class that
// should be allowed to call the lock(), tryLock() and unlock()
// methods.
@@ -90,7 +92,7 @@ protected:
/// locks that are released automatically when the block is exited
/// (RAII). It is meant to be used along with InterprocessSync objects. See
/// the description of InterprocessSync.
-class InterprocessSyncLocker {
+class InterprocessSyncLocker : isc::util::nonassignable {
public:
/// \brief Constructor
///
diff --git a/src/lib/util/io/socketsession.cc b/src/lib/util/io/socketsession.cc
index 4c50949..d8aa936 100644
--- a/src/lib/util/io/socketsession.cc
+++ b/src/lib/util/io/socketsession.cc
@@ -33,11 +33,11 @@
#include <string>
#include <vector>
-#include <boost/noncopyable.hpp>
-
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
#include "fd_share.h"
#include "socketsession.h"
@@ -276,7 +276,7 @@ SocketSession::SocketSession(int sock, int family, int type, int protocol,
}
}
-struct SocketSessionReceiver::ReceiverImpl {
+struct SocketSessionReceiver::ReceiverImpl : isc::util::nonassignable {
ReceiverImpl(int fd) : fd_(fd),
sa_local_(convertSockAddr(&ss_local_)),
sa_remote_(convertSockAddr(&ss_remote_)),
@@ -326,7 +326,7 @@ readFail(int actual_len, int expected_len) {
// A helper container for a (socket) file descriptor used in
// SocketSessionReceiver::pop that ensures the socket is closed unless it
// can be safely passed to the caller via release().
-struct ScopedSocket : boost::noncopyable {
+struct ScopedSocket : isc::util::noncopyable {
ScopedSocket(int fd) : fd_(fd) {}
~ScopedSocket() {
if (fd_ >= 0) {
diff --git a/src/lib/util/io/socketsession.h b/src/lib/util/io/socketsession.h
index 48b7f19..3516d40 100644
--- a/src/lib/util/io/socketsession.h
+++ b/src/lib/util/io/socketsession.h
@@ -15,8 +15,8 @@
#ifndef __SOCKETSESSION_H_
#define __SOCKETSESSION_H_ 1
-#include <boost/noncopyable.hpp>
-
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
#include <exceptions/exceptions.h>
#include <string>
@@ -195,7 +195,7 @@ public:
///
/// See the description of \ref SocketSessionUtility for other details of how
/// the session forwarding works.
-class SocketSessionForwarder : boost::noncopyable,
+class SocketSessionForwarder : isc::util::noncopyable,
public BaseSocketSessionForwarder
{
public:
@@ -334,7 +334,7 @@ private:
/// (e.g. a class or a function that constructs it) is responsible for validity
/// of the data passed to the object. See the description of
/// \c SocketSessionReceiver::pop() for the specific case of that usage.
-class SocketSession {
+class SocketSession : isc::util::nonassignable {
public:
/// The constructor.
///
@@ -423,7 +423,7 @@ private:
///
/// See the description of \ref SocketSessionUtility for other details of how
/// the session forwarding works.
-class SocketSessionReceiver : boost::noncopyable {
+class SocketSessionReceiver : isc::util::noncopyable {
public:
/// The constructor.
///
diff --git a/src/lib/util/lru_list.h b/src/lib/util/lru_list.h
index 797c3c9..29b05dd 100644
--- a/src/lib/util/lru_list.h
+++ b/src/lib/util/lru_list.h
@@ -18,10 +18,10 @@
#include <list>
#include <string>
-#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <util/locks.h>
+#include <util/noncopyable.h>
namespace isc {
namespace util {
@@ -35,9 +35,9 @@ namespace util {
/// should be done when the element is referenced.
///
/// It is not intended that the class be copied, and the derivation from
-/// boost::noncopyable enforces this.
+/// isc::util::noncopyable enforces this.
template <typename T>
-class LruList : boost::noncopyable {
+class LruList : isc::util::noncopyable {
public:
typedef typename std::list<boost::shared_ptr<T> > lru_list;
typedef typename lru_list::iterator iterator;
diff --git a/src/lib/util/nonassignable.h b/src/lib/util/nonassignable.h
new file mode 100644
index 0000000..c32fd4e
--- /dev/null
+++ b/src/lib/util/nonassignable.h
@@ -0,0 +1,40 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+/// From boost/noncopyable.hpp
+
+#ifndef __NONASSIGNABLE_
+#define __NONASSIGNABLE_
+
+namespace isc {
+namespace util {
+namespace nonassignable_ {
+
+class nonassignable {
+protected:
+ nonassignable() {}
+ ~nonassignable() {}
+private:
+ // emphasize the following member is private
+ const nonassignable& operator=(const nonassignable&);
+};
+
+} // namespace nonassignable_
+
+typedef nonassignable_::nonassignable nonassignable;
+
+} // namespace util
+} // namespace isc
+
+#endif // __NONASSIGNABLE_
diff --git a/src/lib/util/noncopyable.h b/src/lib/util/noncopyable.h
new file mode 100644
index 0000000..f819fc3
--- /dev/null
+++ b/src/lib/util/noncopyable.h
@@ -0,0 +1,41 @@
+// Copyright (C) 2012 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+/// From boost/noncopyable.hpp
+
+#ifndef __NONCOPYABLE_
+#define __NONCOPYABLE_
+
+namespace isc {
+namespace util {
+namespace noncopyable_ {
+
+class noncopyable {
+protected:
+ noncopyable() {}
+ ~noncopyable() {}
+private:
+ // emphasize the following members are private
+ noncopyable(const noncopyable&);
+ const noncopyable& operator=(const noncopyable&);
+};
+
+} // namespace noncopyable_
+
+typedef noncopyable_::noncopyable noncopyable;
+
+} // namespace util
+} // namespace isc
+
+#endif // __NONCOPYABLE_
diff --git a/src/lib/util/random/qid_gen.h b/src/lib/util/random/qid_gen.h
index 1af43c1..ed939e9 100644
--- a/src/lib/util/random/qid_gen.h
+++ b/src/lib/util/random/qid_gen.h
@@ -25,6 +25,8 @@
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>
+#include <util/nonassignable.h>
+
namespace isc {
namespace util {
namespace random {
@@ -36,7 +38,7 @@ namespace random {
///
/// It automatically seeds it with the current time when it is first
/// used.
-class QidGenerator {
+class QidGenerator : isc::util::nonassignable {
public:
/// \brief Returns the singleton instance of the QidGenerator
///
diff --git a/src/lib/util/random/random_number_generator.h b/src/lib/util/random/random_number_generator.h
index 485ea7a..3d2babd 100644
--- a/src/lib/util/random/random_number_generator.h
+++ b/src/lib/util/random/random_number_generator.h
@@ -20,6 +20,8 @@
#include <numeric>
#include <exceptions/exceptions.h>
+#include <util/noncopyable.h>
+#include <util/nonassignable.h>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
@@ -53,7 +55,7 @@ public:
/// \brief Uniform random integer generator
///
/// Generate uniformly distributed integers in range of [min, max]
-class UniformRandomIntegerGenerator{
+class UniformRandomIntegerGenerator : isc::util::noncopyable {
public:
/// \brief Constructor
///
@@ -78,9 +80,8 @@ public:
/// \brief Generate uniformly distributed integer
int operator()() { return generator_(); }
private:
- /// Hide default and copy constructor
+ /// Hide default constructor
UniformRandomIntegerGenerator();///< Default constructor
- UniformRandomIntegerGenerator(const UniformRandomIntegerGenerator&); ///< Copy constructor
int min_; ///< The minimum integer that can generate
int max_; ///< The maximum integer that can generate
@@ -92,7 +93,7 @@ private:
/// \brief Weighted random integer generator
///
/// Generate random integers according different probabilities
-class WeightedRandomIntegerGenerator {
+class WeightedRandomIntegerGenerator : isc::util::nonassignable {
public:
/// \brief Constructor
///
diff --git a/src/lib/util/tests/socketsession_unittest.cc b/src/lib/util/tests/socketsession_unittest.cc
index e83c140..f2d83f5 100644
--- a/src/lib/util/tests/socketsession_unittest.cc
+++ b/src/lib/util/tests/socketsession_unittest.cc
@@ -31,7 +31,6 @@
#include <utility>
#include <vector>
-#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
#include <gtest/gtest.h>
@@ -39,6 +38,7 @@
#include <exceptions/exceptions.h>
#include <util/buffer.h>
+#include <util/noncopyable.h>
#include <util/io/fd_share.h>
#include <util/io/socketsession.h>
#include <util/io/sockaddr_util.h>
@@ -58,7 +58,7 @@ const char TEST_DATA[] = "BIND10 test";
// A simple helper structure to automatically close test sockets on return
// or exception in a RAII manner. non copyable to prevent duplicate close.
-struct ScopedSocket : boost::noncopyable {
+struct ScopedSocket : isc::util::noncopyable {
ScopedSocket() : fd(-1) {}
ScopedSocket(int sock) : fd(sock) {}
~ScopedSocket() {
diff --git a/src/lib/xfr/xfrout_client.h b/src/lib/xfr/xfrout_client.h
index bad963c..fa21a01 100644
--- a/src/lib/xfr/xfrout_client.h
+++ b/src/lib/xfr/xfrout_client.h
@@ -19,6 +19,8 @@
#include <string>
+#include <util/noncopyable.h>
+
#include <exceptions/exceptions.h>
namespace isc {
@@ -37,17 +39,11 @@ public:
///
/// The intended primary usage of abstraction is to allow tests for the
/// user class of XfroutClient without requiring actual communication.
-class AbstractXfroutClient {
+class AbstractXfroutClient : isc::util::noncopyable {
///
- /// \name Constructors, Assignment Operator and Destructor.
+ /// \name Constructor and Destructor.
///
- /// Note: The copy constructor and the assignment operator are
- /// intentionally defined as private to make it explicit that this is a
- /// pure base class.
//@{
-private:
- AbstractXfroutClient(const AbstractXfroutClient& source);
- AbstractXfroutClient& operator=(const AbstractXfroutClient& source);
protected:
/// \brief The default constructor.
///
diff --git a/tests/tools/perfdhcp/command_options.h b/tests/tools/perfdhcp/command_options.h
index 9196857..a001ef4 100644
--- a/tests/tools/perfdhcp/command_options.h
+++ b/tests/tools/perfdhcp/command_options.h
@@ -18,7 +18,7 @@
#include <string>
#include <vector>
-#include <boost/noncopyable.hpp>
+#include <util/noncopyable.h>
namespace isc {
namespace perfdhcp {
@@ -28,7 +28,7 @@ namespace perfdhcp {
/// This class is responsible for parsing the command-line and storing the
/// specified options.
///
-class CommandOptions : public boost::noncopyable {
+class CommandOptions : public isc::util::noncopyable {
public:
/// 2-way (cmd line param -i) or 4-way exchanges
enum ExchangeMode {
diff --git a/tests/tools/perfdhcp/stats_mgr.h b/tests/tools/perfdhcp/stats_mgr.h
index 245c69e..87f530e 100644
--- a/tests/tools/perfdhcp/stats_mgr.h
+++ b/tests/tools/perfdhcp/stats_mgr.h
@@ -18,7 +18,6 @@
#include <iostream>
#include <map>
-#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
@@ -27,6 +26,7 @@
#include <boost/multi_index/mem_fun.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
+#include <util/noncopyable.h>
#include <exceptions/exceptions.h>
namespace isc {
@@ -49,7 +49,7 @@ namespace perfdhcp {
///
/// \tparam T class representing DHCPv4 or DHCPv6 packet.
template <class T>
-class StatsMgr : public boost::noncopyable {
+class StatsMgr : public isc::util::noncopyable {
public:
/// \brief Custom Counter
More information about the bind10-changes
mailing list