Noncopyable by default

Author: arahlin

core/include/core/container_pybindings.h

@@ -78,7 +78,7 @@ register_vector(py::module_ &scope, std::string name, Args &&...args)
 {
 	using T = typename V::value_type;
 
-	auto cls = register_class<V, Bases...>(scope, name, std::forward<Args>(args)...);
+	auto cls = register_class_copyable<V, Bases...>(scope, name, std::forward<Args>(args)...);
 
 	cls.def("__init__", py::make_constructor(container_from_object<V>))
 	    .def("__repr__", vec_repr<T>)
@@ -124,7 +124,7 @@ template <typename M, bool proxy=true, typename... Bases, typename... Args>
 auto
 register_map(py::module_ &scope, std::string name, Args &&...args)
 {
-	auto cls = register_class<M, Bases...>(scope, name, std::forward<Args>(args)...);
+	auto cls = register_class_copyable<M, Bases...>(scope, name, std::forward<Args>(args)...);
 
 	cls.def(py::init<const M &>())
 	    .def(py::std_map_indexing_suite<M, proxy>())

core/include/core/pybindings.h

@@ -69,7 +69,7 @@ register_enum(py::module_ &scope, const std::string &name, Args &&... args)
 // Ensure that base classes are registered first to inherit their bound methods.
 template <typename T, typename... Bases, typename... Args>
 auto
-register_class(py::module_ &scope, const std::string &name, Args&&...args)
+register_class_copyable(py::module_ &scope, const std::string &name, Args&&...args)
 {
 	(void) scope;
 
@@ -81,7 +81,7 @@ register_class(py::module_ &scope, const std::string &name, Args&&...args)
 // Ensure that base classes are registered first to inherit their bound methods.
 template <typename T, typename... Bases, typename... Args>
 auto
-register_class_noncopyable(py::module_ &scope, const std::string &name, Args&&...args)
+register_class(py::module_ &scope, const std::string &name, Args&&...args)
 {
 	(void) scope;
 
@@ -94,7 +94,7 @@ template <typename T, typename... Bases, typename... Args>
 auto
 register_g3module(py::module_ &scope, const std::string &name, Args&&...args)
 {
-	auto cls = register_class_noncopyable<T, Bases..., G3Module>(scope, name.c_str(),
+	auto cls = register_class<T, Bases..., G3Module>(scope, name.c_str(),
 	    std::forward<Args>(args)...);
 
 	// mark as a module

core/include/core/serialization.h

@@ -132,7 +132,7 @@ template <typename T, typename... Bases, typename... Args>
 auto
 register_frameobject(py::module_ &scope, const std::string &name, Args&&...args)
 {
-	auto cls = register_class<T, Bases..., G3FrameObject>(scope, name.c_str(),
+	auto cls = register_class_copyable<T, Bases..., G3FrameObject>(scope, name.c_str(),
 	    std::forward<Args>(args)...);
 
 	// copy constructor

core/src/G3Frame.cxx

@@ -505,7 +505,7 @@ static py::object g3frame_hash(py::object obj)
 
 PYBINDINGS("core", scope) {
 	// Internal stuff
-	register_class<G3FrameObject>(scope, "G3FrameObject",
+	register_class_copyable<G3FrameObject>(scope, "G3FrameObject",
 	  "Base class for objects that can be added to a frame. All such "
 	  "must inherit from G3FrameObject in C++. Pickle hooks are overridden "
 	  "to use the fast internal serialization")
@@ -539,7 +539,7 @@ PYBINDINGS("core", scope) {
 	;
 	register_vector_of<G3Frame::FrameType>(scope, "FrameType");
 
-	register_class<G3Frame>(scope, "G3Frame",
+	register_class_copyable<G3Frame>(scope, "G3Frame",
 	  "Frames are the core datatype of the analysis software. They behave "
 	  "like Python dictionaries except that they can only store subclasses "
 	  "of core.G3FrameObject and the dictionary keys must be strings. "

core/src/G3Logging.cxx

@@ -147,7 +147,7 @@ PYBINDINGS("core", scope) {
 	    .value("LOG_FATAL",  G3LOG_FATAL)
 	;
 
-	register_class_noncopyable<G3Logger>(scope, "G3Logger", "C++ logging abstract base class")
+	register_class<G3Logger>(scope, "G3Logger", "C++ logging abstract base class")
 	    .add_static_property("global_logger", &GetRootLogger, &SetRootLogger)
 	    .def("log", &G3Logger::Log)
 	    .def("get_level_for_unit", &G3Logger::LogLevelForUnit)
@@ -156,15 +156,15 @@ PYBINDINGS("core", scope) {
         ;
 	register_vector_of<G3LoggerPtr>(scope, "G3Logger");
 
-	register_class_noncopyable<G3NullLogger, G3Logger>(scope, "G3NullLogger",
+	register_class<G3NullLogger, G3Logger>(scope, "G3NullLogger",
 	    "Logger that does not log. Useful if you don't want log messages");
-	register_class_noncopyable<G3PrintfLogger, G3Logger>(scope, "G3PrintfLogger",
+	register_class<G3PrintfLogger, G3Logger>(scope, "G3PrintfLogger",
 	    "Logger that prints error messages to stderr (in color, if stderr is a tty).")
 	    .def(py::init<G3LogLevel>((py::arg("default_level")=G3DefaultLogLevel)))
 	    .def_readwrite("trim_file_names", &G3PrintfLogger::TrimFileNames)
 	    .def_readwrite("timestamps", &G3PrintfLogger::Timestamps)
 	;
-	register_class_noncopyable<G3MultiLogger, G3Logger>(scope, "G3MultiLogger",
+	register_class<G3MultiLogger, G3Logger>(scope, "G3MultiLogger",
 	    "Log to multiple loggers at once")
 	    .def(py::init<std::vector<G3LoggerPtr> >())
 	;

core/src/G3Pipeline.cxx

@@ -417,7 +417,7 @@ class G3ModuleWrap : public G3Module, public py::wrapper<G3Module>
 };
 
 PYBINDINGS("core", scope) {
-	register_class_noncopyable<G3ModuleWrap>(scope, "G3Module",
+	register_class<G3ModuleWrap>(scope, "G3Module",
 	  "Base class for functors that can be added to a G3Pipeline.")
 	    .def(py::init<>())
 	    .def("__call__", &G3Module_Process)

core/src/G3Quat.cxx

@@ -952,7 +952,7 @@ G3TimestreamQuat_nsamples(const G3TimestreamQuat &r)
 PYBINDINGS("core", scope)
 {
 	py::object q =
-	register_class<Quat>(scope, "Quat",
+	register_class_copyable<Quat>(scope, "Quat",
 	      "Representation of a quaternion. Data in a,b,c,d.")
 	    .def(py::init<>())
 	    .def(py::init<const Quat &>())

dfmux/src/DfMuxBuilder.cxx

@@ -1,14 +1,13 @@
 #include <pybindings.h>
 #include <serialization.h>
+#include <container_pybindings.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <sstream>
 
 #include <dfmux/DfMuxBuilder.h>
-#include <std_map_indexing_suite.hpp>
-#include <cereal/types/map.hpp>
 
 template <class A> void DfMuxBoardSamples::serialize(A &ar, const unsigned v)
 {
@@ -214,11 +213,9 @@ void DfMuxBuilder::ProcessNewData()
 
 PYBINDINGS("dfmux", scope)
 {
-	register_frameobject<DfMuxBoardSamples>(scope, "DfMuxBoardSamples",
+	register_g3map<DfMuxBoardSamples>(scope, "DfMuxBoardSamples",
 	  "Container structure for samples from modules on one board, mapping "
 	  "0-indexed module and block IDs to a dfmux.DfMuxSample.")
-	    .def(py::init<>())
-	    .def(py::std_map_indexing_suite<DfMuxBoardSamples, true>())
 	    .def_readwrite("nmodules", &DfMuxBoardSamples::nmodules,
 	      "Number of modules expected to report from this board")
 	    .def_readwrite("nblocks", &DfMuxBoardSamples::nblocks,
@@ -229,12 +226,10 @@ PYBINDINGS("dfmux", scope)
 	      "True if this structure contains data from all expected modules and blocks")
 	;
 
-	register_frameobject<DfMuxMetaSample>(scope, "DfMuxMetaSample",
+	register_g3map<DfMuxMetaSample>(scope, "DfMuxMetaSample",
 	  "Container structure for coincident samples from all boards. "
 	  "Individual board data, stored in dfmux.DfMuxBoardSamples classes, "
 	  "is contained indexed by board serial number.")
-	    .def(py::init<>())
-	    .def(py::std_map_indexing_suite<DfMuxMetaSample, false>())
 	;
 
 	register_g3module<DfMuxBuilder, G3EventBuilder>(scope, "DfMuxBuilder",

dfmux/src/DfMuxCollector.cxx

@@ -446,7 +446,7 @@ make_dfmux_collector_v2_from_dict(const char *listenaddr,
 
 PYBINDINGS("dfmux", scope)
 {
-	register_class_noncopyable<DfMuxCollector>(scope, "DfMuxCollector",
+	register_class<DfMuxCollector>(scope, "DfMuxCollector",
 	    "Listener object that collects IceBoard packets from a single network "
 	    "interface and decodes and forwards them to a DfMuxBuilder object for "
 	    "insertion into the data stream. Takes the builder object to which the "

dfmux/src/LegacyDfMuxCollector.cxx

@@ -303,7 +303,7 @@ int LegacyDfMuxCollector::BookPacket(struct DfmuxPacket *packet,
 
 PYBINDINGS("dfmux", scope)
 {
-	register_class_noncopyable<LegacyDfMuxCollector>(scope, "LegacyDfMuxCollector",
+	register_class<LegacyDfMuxCollector>(scope, "LegacyDfMuxCollector",
 	    "Listener object that collects legacy network packets and decodes and "
 	    "forwards them to a DfMuxBuilder object for insertion into the data "
 	    "stream. Takes a builder object to which the data should be sent. "