C++17 and Ice 3.7project2-1.3.0

Updates all code to work with C++17 and Ice 3.7 and related updates in
used libraries.

14 files changed, 73 insertions, 95 deletions

diff --git a/project2/sql/mockDatasource.cpp b/project2/sql/mockDatasource.cpp
index 9f21e44..8246f9b 100644
--- a/project2/sql/mockDatasource.cpp
+++ b/project2/sql/mockDatasource.cpp
@@ -4,7 +4,7 @@
 
 NAMEDPLUGIN("mock", MockConnectionFactory, DB::ConnectionFactory);
 
-DB::Connection *
+DB::ConnectionPtr
 MockConnectionFactory::create(const std::string & n) const
 {
 	return DB::MockDatabase::openConnectionTo(n);
diff --git a/project2/sql/mockDatasource.h b/project2/sql/mockDatasource.h
index e9a9732..b97af9b 100644
--- a/project2/sql/mockDatasource.h
+++ b/project2/sql/mockDatasource.h
@@ -5,7 +5,7 @@
 
 class MockConnectionFactory : public DB::ConnectionFactory {
 	public:
-		DB::Connection * create(const std::string &) const;
+		DB::ConnectionPtr create(const std::string &) const;
 };
 
 #endif
diff --git a/project2/sql/rdbmsDataSource.cpp b/project2/sql/rdbmsDataSource.cpp
index a3bb6a1..15ae638 100644
--- a/project2/sql/rdbmsDataSource.cpp
+++ b/project2/sql/rdbmsDataSource.cpp
@@ -200,7 +200,7 @@ RdbmsDataSource::connectTo(const ConnectionInfo & dsn)
 	}
 }
 
-RdbmsDataSource::RdbmsConnection::RdbmsConnection(DB::Connection * const con, time_t kat) :
+RdbmsDataSource::RdbmsConnection::RdbmsConnection(DB::ConnectionPtr const con, time_t kat) :
 	connection(con),
 	txOpen(false),
 	lastUsedTime(0),
@@ -212,7 +212,6 @@ RdbmsDataSource::RdbmsConnection::RdbmsConnection(DB::Connection * const con, ti
 RdbmsDataSource::RdbmsConnection::~RdbmsConnection()
 {
 	connection->finish();
-	delete connection;
 }
 
 void
@@ -248,7 +247,7 @@ RdbmsDataSource::ConnectionInfo::ConnectionInfo(ScriptNodePtr node) :
 {
 }
 
-DB::Connection *
+DB::ConnectionPtr
 RdbmsDataSource::ConnectionInfo::connect() const
 {
 	return DB::ConnectionFactory::createNew(typeId, dsn);
@@ -291,7 +290,7 @@ RdbmsDataSource::ConnectionRef::operator=(const RdbmsDataSource::ConnectionRef &
 DB::Connection *
 RdbmsDataSource::ConnectionRef::operator->() const
 {
-	return conn->connection;
+	return conn->connection.get();
 }
 
 DB::Connection &
@@ -303,6 +302,6 @@ RdbmsDataSource::ConnectionRef::operator*() const
 DB::Connection *
 RdbmsDataSource::ConnectionRef::get() const
 {
-	return conn->connection;
+	return conn->connection.get();
 }
 
diff --git a/project2/sql/rdbmsDataSource.h b/project2/sql/rdbmsDataSource.h
index 807ad3f..b1cb74c 100644
--- a/project2/sql/rdbmsDataSource.h
+++ b/project2/sql/rdbmsDataSource.h
@@ -18,14 +18,14 @@ class DLL_PUBLIC RdbmsDataSource : public DataSource {
 
 		class RdbmsConnection {
 			public:
-				RdbmsConnection(DB::Connection * const connection, time_t kat);
+				RdbmsConnection(DB::ConnectionPtr const connection, time_t kat);
 				~RdbmsConnection();
 
 				void touch() const;
 				bool isExpired() const;
-				DB::Connection * const connection;
+				DB::ConnectionPtr const connection;
 				bool txOpen;
-				boost::optional<std::thread::id> threadId;
+				std::optional<std::thread::id> threadId;
 
 			private:
 				friend class ConnectionRef;
@@ -56,7 +56,7 @@ class DLL_PUBLIC RdbmsDataSource : public DataSource {
 			public:
 				ConnectionInfo(ScriptNodePtr);
 
-				DB::Connection * connect() const;
+				DB::ConnectionPtr connect() const;
 
 				bool operator<(const ConnectionInfo & o) const;
 
diff --git a/project2/sql/sqlBulkLoad.cpp b/project2/sql/sqlBulkLoad.cpp
index 96a590e..fc7e7e1 100644
--- a/project2/sql/sqlBulkLoad.cpp
+++ b/project2/sql/sqlBulkLoad.cpp
@@ -15,7 +15,7 @@ class SqlBulkLoad : public Task, SqlBase {
 			targetTable(p, "targettable"),
 			extras(p, "extras")
 		{
-			p->script->loader.addLoadTarget(p, Storer::into<StreamFactory>(&stream));
+			p->script.lock()->loader.addLoadTarget(p, Storer::into<StreamFactory>(&stream));
 		}
 
 		void execute(ExecContext * ec) const
diff --git a/project2/sql/sqlCache.cpp b/project2/sql/sqlCache.cpp
index db05543..79e2e83 100644
--- a/project2/sql/sqlCache.cpp
+++ b/project2/sql/sqlCache.cpp
@@ -16,9 +16,6 @@
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
-typedef boost::shared_ptr<DB::SelectCommand> SelectPtr;
-typedef boost::shared_ptr<DB::ModifyCommand> ModifyPtr;
-
 class SqlCache : public RowSetCache {
 	public:
 		SqlCache(ScriptNodePtr p) :
@@ -56,12 +53,12 @@ class SqlCache : public RowSetCache {
 
 		static void bindKeyValues(DB::Command * cmd, unsigned int * offset, const VariableType & v)
 		{
-			boost::apply_visitor<const SqlVariableBinder, const VariableType>(SqlVariableBinder(cmd, (*offset)++), v);
+			boost::apply_visitor(SqlVariableBinder(cmd, (*offset)++), v);
 		}
 
 		class SqlCacheRowSet : public RowSet {
 			public:
-				SqlCacheRowSet(SelectPtr r) :
+				SqlCacheRowSet(DB::SelectCommandPtr r) :
 					SourceObject(ScriptNodePtr()),
 					RowSet(NULL),
 					s(r) {
@@ -100,7 +97,7 @@ class SqlCache : public RowSetCache {
 									const DB::Column & col = (*s)[c];
 									if (!boost::algorithm::starts_with(col.name, "p2attr_") &&
 											!boost::algorithm::starts_with(col.name, "p2_")) {
-										ss.columns.insert(new Column(colNo++, col.name));
+										ss.columns.insert(std::make_shared<Column>(colNo++, col.name));
 										colCols.push_back(c);
 									}
 								}
@@ -122,7 +119,7 @@ class SqlCache : public RowSetCache {
 					} while (s->fetch());
 				}
 			private:
-				SelectPtr s;
+				DB::SelectCommandPtr s;
 				mutable std::vector<unsigned int> colCols;
 				mutable int64_t cacheId;
 		};
@@ -141,12 +138,12 @@ class SqlCache : public RowSetCache {
 			applyKeys(ec, boost::bind(appendKeyAnds, &sql, _1), ps);
 			sql.appendf(" ORDER BY r.p2_cacheid DESC, r.p2_row");
 			auto con = db->getReadonly();
-			SelectPtr gh(con->newSelectCommand(sql));
+			auto gh = con->select(sql);
 			unsigned int offset = 0;
 			gh->bindParamT(offset++, boost::posix_time::microsec_clock::universal_time() - boost::posix_time::seconds(CacheLife));
 			applyKeys(ec, boost::bind(bindKeyValues, gh.get(), &offset, _2), ps);
 			if (gh->fetch()) {
-				return new SqlCacheRowSet(gh);
+				return std::make_shared<SqlCacheRowSet>(gh);
 			}
 			return NULL;
 		}
@@ -185,14 +182,14 @@ class SqlCache : public RowSetCache {
 					}
 					sql.appendf(")");
 					auto con = db->getWritable();
-					ModifyPtr m(con->newModifyCommand(sql));
+					auto m = con->modify(sql);
 					unsigned int offset = 0;
 					m->bindParamI(offset++, row++);
 					for (const Values::value_type & a : attrs) {
-						boost::apply_visitor<const SqlVariableBinder, const VariableType>(SqlVariableBinder(m.get(), offset++), a.second);
+						boost::apply_visitor(SqlVariableBinder(m.get(), offset++), a.second);
 					}
 					for (const Values::value_type & v : cols) {
-						boost::apply_visitor<const SqlVariableBinder, const VariableType>(SqlVariableBinder(m.get(), offset++), v.second);
+						boost::apply_visitor(SqlVariableBinder(m.get(), offset++), v.second);
 					}
 					m->execute();
 					cols.clear();
@@ -211,12 +208,12 @@ class SqlCache : public RowSetCache {
 			AdHoc::Buffer sp;
 			sp.appendf("SAVEPOINT sp%p", this);
 			auto con = db->getWritable();
-			ModifyPtr s = ModifyPtr(con->newModifyCommand(sp));
+			auto s = con->modify(sp);
 			s->execute();
 			// Header
 			AdHoc::Buffer del;
 			del.appendf("INSERT INTO %s(p2_time) VALUES(?)", HeaderTable.c_str());
-			ModifyPtr h = ModifyPtr(con->newModifyCommand(del));
+			auto h = con->modify(del);
 			h->bindParamT(0, boost::posix_time::microsec_clock::universal_time());
 			h->execute();
 			// Record set header
@@ -228,11 +225,11 @@ class SqlCache : public RowSetCache {
 			offset = 0;
 			applyKeys(ec, boost::bind(appendKeyBinds, &sql, &offset), ps);
 			sql.appendf(")");
-			ModifyPtr m(con->newModifyCommand(sql));
+			auto m = con->modify(sql);
 			offset = 0;
 			applyKeys(ec, boost::bind(bindKeyValues, m.get(), &offset, _2), ps);
 			m->execute();
-			return new SqlCachePresenter(n, f, db);
+			return std::make_shared<SqlCachePresenter>(n, f, db);
 		}
 
 		void save(ExecContext *, const Glib::ustring & , const Glib::ustring & , const IHaveParameters * )
@@ -240,7 +237,7 @@ class SqlCache : public RowSetCache {
 			AdHoc::Buffer sp;
 			sp.appendf("RELEASE SAVEPOINT sp%p", this);
 			auto con = db->getWritable();
-			ModifyPtr s = ModifyPtr(con->newModifyCommand(sp));
+			auto s = con->modify(sp);
 			s->execute();
 		}
 
@@ -249,7 +246,7 @@ class SqlCache : public RowSetCache {
 			AdHoc::Buffer sp;
 			sp.appendf("ROLLBACK TO SAVEPOINT sp%p", this);
 			auto con = db->getWritable();
-			ModifyPtr s = ModifyPtr(con->newModifyCommand(sp));
+			auto s = con->modify(sp);
 			s->execute();
 		}
 
@@ -272,10 +269,10 @@ class CustomSqlCacheFactory : public RowSetCacheFactory::For<SqlCache>, public L
 		{
 			try {
 				if (!SqlCache::DataSource.empty()) {
-					boost::intrusive_ptr<CommonObjects> co = new CommonObjects();
+					std::shared_ptr<CommonObjects> co = std::make_shared<CommonObjects>();
 					RdbmsDataSource * db = co->dataSource<RdbmsDataSource>(SqlCache::DataSource);
 					auto con = db->getWritable();
-					ModifyPtr m(con->newModifyCommand(stringbf("DELETE FROM %s WHERE p2_time < ?", SqlCache::HeaderTable)));
+					auto m = con->modify(stringbf("DELETE FROM %s WHERE p2_time < ?", SqlCache::HeaderTable));
 					m->bindParamT(0, boost::posix_time::microsec_clock::universal_time() - boost::posix_time::seconds(SqlCache::CacheLife));
 					m->execute();
 					db->commit();
diff --git a/project2/sql/sqlMergeTask.cpp b/project2/sql/sqlMergeTask.cpp
index 6b1bb75..f78862f 100644
--- a/project2/sql/sqlMergeTask.cpp
+++ b/project2/sql/sqlMergeTask.cpp
@@ -15,12 +15,12 @@
 #include <boost/bind.hpp>
 
 bool SqlMergeTask::defaultUseTempTable = true;
-static void attach(boost::intrusive_ptr<IHaveSubTasks> i, DB::ModifyCommand * insert);
+static void attach(std::shared_ptr<IHaveSubTasks> i, DB::ModifyCommandPtr insert);
 
 #define foreach(_type, _con, _it) for (_type _it = ((_con).begin()); _it != ((_con).end()); _it++)
 
 class SqlMergeInsert;
-typedef boost::intrusive_ptr<SqlMergeInsert> SqlMergeInsertPtr;
+typedef std::shared_ptr<SqlMergeInsert> SqlMergeInsertPtr;
 /// Project2 component insert custom constructed records during an SQL Merge task
 class SqlMergeInsert : IHaveParameters, public Task {
 	public:
@@ -33,13 +33,13 @@ class SqlMergeInsert : IHaveParameters, public Task {
 		void execute(ExecContext * ec) const {
 			unsigned int col = 0;
 			for (const Parameters::value_type & v : parameters) {
-				boost::apply_visitor<const SqlVariableBinder, const VariableType>(SqlVariableBinder(insert, col++), v.second(ec));
+				boost::apply_visitor(SqlVariableBinder(insert.get(), col++), v.second(ec));
 			}
 			insert->execute();
 		}
 	private:
-		friend void attach(SqlMergeInsertPtr i, DB::ModifyCommand * insert);
-		DB::ModifyCommand * insert;
+		friend void attach(SqlMergeInsertPtr i, DB::ModifyCommandPtr insert);
+		DB::ModifyCommandPtr insert;
 };
 
 NAMEDFACTORY("sqlmerge", SqlMergeTask, TaskFactory);
@@ -87,7 +87,7 @@ SqlMergeTask::SqlMergeTask(ScriptNodePtr p) :
 	dtable(p->value("targettable", NULL).as<std::string>()),
 	dtablet(stringf("tmp_%s_%d", dtable.c_str(), getpid()))
 {
-	p->script->loader.addLoadTarget(p, Storer::into<TaskFactory>(&sources));
+	p->script.lock()->loader.addLoadTarget(p, Storer::into<TaskFactory>(&sources));
 
 	if (!sources.empty() && useView(NULL)) {
 		throw NotSupported("useview not supported with iterate fillers");
@@ -115,7 +115,6 @@ SqlMergeTask::SqlMergeTask(ScriptNodePtr p) :
 
 SqlMergeTask::~SqlMergeTask()
 {
-	delete insCmd;
 	delete sqlCommand;
 }
 
@@ -194,20 +193,18 @@ SqlMergeTask::createTempTable() const
 		destdb->modify(b)->execute();
 	}
 	else {
-		DB::ModifyCommand * ctt = destdb->newModifyCommand(stringf(
+		auto ctt = destdb->modify(stringf(
 					"CREATE TEMPORARY TABLE %s AS SELECT * FROM %s WHERE 0=1",
 					dtablet.c_str(),
 					dtable.c_str()));
 		ctt->execute();
-		delete ctt;
 		for (Columns::value_type c : cols) {
 			if (!c->maptable.empty()) {
-				DB::ModifyCommand * at = destdb->newModifyCommand(stringf(
+				auto at = destdb->modify(stringf(
 							"ALTER TABLE %s ADD COLUMN %s VARCHAR(1000)",
 							dtablet.c_str(),
 							c->mapcolumn.c_str()));
 				at->execute();
-				delete at;
 			}
 		}
 	}
@@ -217,15 +214,14 @@ void
 SqlMergeTask::dropTempTable() const
 {
 	if (tempTableCreated) {
-		DB::ModifyCommand * d;
+		DB::ModifyCommandPtr d;
 		if (useView(NULL)) {
-			 d = destdb->newModifyCommand("DROP VIEW " + dtablet);
+			 d = destdb->modify("DROP VIEW " + dtablet);
 		}
 		else {
-			 d = destdb->newModifyCommand("DROP TABLE " + dtablet);
+			 d = destdb->modify("DROP TABLE " + dtablet);
 		}
 		d->execute();
-		delete d;
 	}
 }
 void
@@ -237,21 +233,19 @@ SqlMergeTask::createTempKey() const
 	idx.appendf("ALTER TABLE %s ADD CONSTRAINT pk_%s PRIMARY KEY(%s)",
 			dtablet.c_str(), dtablet.c_str(),
 			boost::algorithm::join(keys, ", ").c_str());
-	DB::ModifyCommand * at = destdb->newModifyCommand(idx);
+	DB::ModifyCommandPtr at = destdb->modify(idx);
 	at->execute();
-	delete at;
 	/* Indexes */
 	int n = 0;
 	for (const Keys::value_type & i : indexes) {
-		DB::ModifyCommand * ci = destdb->newModifyCommand(stringf(
+		DB::ModifyCommandPtr ci = destdb->modify(stringf(
 					"CREATE INDEX idx_%s_%d ON %s(%s)",
 					dtablet.c_str(), n, dtablet.c_str(), i.c_str()));
 		ci->execute();
-		delete ci;
 		n += 1;
 	}
 }
-DB::ModifyCommand *
+DB::ModifyCommandPtr
 SqlMergeTask::insertCommand() const
 {
 	AdHoc::Buffer ins;
@@ -272,12 +266,12 @@ SqlMergeTask::insertCommand() const
 		}
 	}
 	ins.append(")");
-	return destdb->newModifyCommand(ins);
+	return destdb->modify(ins);
 }
 
 class Populate : public Task {
 	public:
-		Populate(DB::ModifyCommand * c) :
+		Populate(DB::ModifyCommandPtr c) :
 			SourceObject(__FUNCTION__),
 			Task(__FUNCTION__),
 			cmd(c)
@@ -292,14 +286,14 @@ class Populate : public Task {
 	private:
 		void bind(unsigned int & idx, const VariableType & value) const
 		{
-			boost::apply_visitor<const SqlVariableBinder, const VariableType>(SqlVariableBinder(cmd, idx++), value);
+			boost::apply_visitor(SqlVariableBinder(cmd.get(), idx++), value);
 		}
-		DB::ModifyCommand * cmd;
+		DB::ModifyCommandPtr cmd;
 };
-typedef boost::intrusive_ptr<Populate> PopulatePtr;
+typedef std::shared_ptr<Populate> PopulatePtr;
 
 void
-attach(SqlMergeInsertPtr i, DB::ModifyCommand * insert)
+attach(SqlMergeInsertPtr i, DB::ModifyCommandPtr insert)
 {
 	if (i) {
 		i->insert = insert;
@@ -307,18 +301,18 @@ attach(SqlMergeInsertPtr i, DB::ModifyCommand * insert)
 }
 
 static void
-attach(boost::intrusive_ptr<IHaveSubTasks> i, DB::ModifyCommand * insert)
+attach(std::shared_ptr<IHaveSubTasks> i, DB::ModifyCommandPtr insert)
 {
 	if (!i) {
 		return;
 	}
 	if (i->normal.empty()) {
-		i->normal.push_back(new Populate(insert));
+		i->normal.push_back(std::make_shared<Populate>(insert));
 	}
 	else {
 		for (const IHaveSubTasks::Tasks::value_type & n : i->normal) {
-			attach(boost::dynamic_pointer_cast<IHaveSubTasks>(n), insert);
-			attach(boost::dynamic_pointer_cast<SqlMergeInsert>(n), insert);
+			attach(std::dynamic_pointer_cast<IHaveSubTasks>(n), insert);
+			attach(std::dynamic_pointer_cast<SqlMergeInsert>(n), insert);
 		}
 	}
 }
@@ -352,15 +346,14 @@ SqlMergeTask::copyToTempTable(ExecContext * ec) const
 		sqlCommand->setFilter(Glib::ustring());
 		sqlCommand->writeSql(ins);
 		ins.appendf(") tmp_src");
-		DB::ModifyCommand * cttt = destdb->newModifyCommand(ins);
+		auto cttt = destdb->modify(ins);
 		unsigned int off = 0;
-		sqlCommand->bindParams(ec, cttt, off);
+		sqlCommand->bindParams(ec, cttt.get(), off);
 		cttt->execute();
-		delete cttt;
 	}
 	for (Columns::value_type c : cols) {
 		if (!c->maptable.empty()) {
-			DB::ModifyCommand * utt = destdb->newModifyCommand(
+			auto utt = destdb->modify(
 					stringf(
 						"UPDATE %s d SET %s = (SELECT m.%s FROM %s m WHERE m.%s = d.%s) WHERE %s IS NULL",
 						dtablet.c_str(),
@@ -371,7 +364,6 @@ SqlMergeTask::copyToTempTable(ExecContext * ec) const
 						c->mapcolumn.c_str(),
 						c->column.c_str()));
 			utt->execute();
-			delete utt;
 		}
 	}
 }
diff --git a/project2/sql/sqlMergeTask.h b/project2/sql/sqlMergeTask.h
index 60b5952..f2a825a 100644
--- a/project2/sql/sqlMergeTask.h
+++ b/project2/sql/sqlMergeTask.h
@@ -22,8 +22,8 @@ class DLL_PUBLIC SqlMergeTask : public Task {
 		typedef std::string Table;
 		typedef std::string Column;
 		class TargetColumn;
-		typedef boost::intrusive_ptr<TargetColumn> TargetColumnPtr;
-		class TargetColumn : public virtual IntrusivePtrBase {
+		typedef std::shared_ptr<TargetColumn> TargetColumnPtr;
+		class TargetColumn {
 			public:
 				class Sort {
 					public:
@@ -69,8 +69,8 @@ class DLL_PUBLIC SqlMergeTask : public Task {
 		typedef ANONSTORAGEOF(IHaveSubTasks) Sources;
 		DynamicSql::SqlCommand * sqlCommand;
 	protected:
-		DB::ModifyCommand * insertCommand() const;
-		DB::ModifyCommand * insCmd;
+		DB::ModifyCommandPtr insertCommand() const;
+		DB::ModifyCommandPtr insCmd;
 
 	public:
 		Sources sources;
diff --git a/project2/sql/sqlRows.cpp b/project2/sql/sqlRows.cpp
index 5bc231b..3a65c9b 100644
--- a/project2/sql/sqlRows.cpp
+++ b/project2/sql/sqlRows.cpp
@@ -24,13 +24,13 @@ SqlRows::~SqlRows()
 {
 }
 
-SqlRows::SqlState::SqlState(SelectPtr s) :
+SqlRows::SqlState::SqlState(DB::SelectCommandPtr s) :
 	query(s)
 {
 	query->execute();
 	fields.resize(query->columnCount());
 	for (unsigned int c = 0; c < query->columnCount(); c++) {
-		columns.insert(new Column(c, (*query)[c].name));
+		columns.insert(std::make_shared<Column>(c, (*query)[c].name));
 	}
 }
 
diff --git a/project2/sql/sqlRows.h b/project2/sql/sqlRows.h
index 30abb08..25f63f8 100644
--- a/project2/sql/sqlRows.h
+++ b/project2/sql/sqlRows.h
@@ -21,12 +21,11 @@ class DLL_PUBLIC SqlRows : public RowSet, SqlBase {
 
 	private:
 		const DynamicSql::SqlCommand sqlCommand;
-		typedef boost::shared_ptr<DB::SelectCommand> SelectPtr;
 		class SqlState : public RowState {
 			public:
-				SqlState(SelectPtr query);
+				SqlState(DB::SelectCommandPtr query);
 				const Columns & getColumns() const;
-				SelectPtr query;
+				DB::SelectCommandPtr query;
 				Columns columns;
 				friend class SqlRows;
 		};
diff --git a/project2/sql/sqlTask.cpp b/project2/sql/sqlTask.cpp
index 71ccf62..d62d150 100644
--- a/project2/sql/sqlTask.cpp
+++ b/project2/sql/sqlTask.cpp
@@ -16,8 +16,8 @@ SqlTask::SqlTask(ScriptNodePtr p) :
 	filter(p, "filter", ""),
 	sqlCommand(p->child("sql"))
 {
-	p->script->loader.addLoadTargetSub(p, "changes", false, Storer::into<TaskFactory>(&changesTasks));
-	p->script->loader.addLoadTargetSub(p, "nochanges", false, Storer::into<TaskFactory>(&noChangesTasks));
+	p->script.lock()->loader.addLoadTargetSub(p, "changes", false, Storer::into<TaskFactory>(&changesTasks));
+	p->script.lock()->loader.addLoadTargetSub(p, "nochanges", false, Storer::into<TaskFactory>(&noChangesTasks));
 }
 
 SqlTask::~SqlTask()
diff --git a/project2/sql/sqlWriters.cpp b/project2/sql/sqlWriters.cpp
index bdc42cd..88e0fc6 100644
--- a/project2/sql/sqlWriters.cpp
+++ b/project2/sql/sqlWriters.cpp
@@ -16,7 +16,7 @@ static
 void
 appendNew(DynamicSql::Writers * w, const Cons & cons)
 {
-	w->push_back(new Type(cons));
+	w->push_back(std::make_shared<Type>(cons));
 }
 
 static
@@ -24,10 +24,10 @@ void
 appendNewFromNode(DynamicSql::Writers * w, ScriptNodePtr p)
 {
 	if (p->get_name() == "filter") {
-		w->push_back(new DynamicSql::SqlFilter(p));
+		w->push_back(std::make_shared<DynamicSql::SqlFilter>(p));
 	}
 	else if (p->get_name() == "param") {
-		w->push_back(new DynamicSql::SqlParameter(p));
+		w->push_back(std::make_shared<DynamicSql::SqlParameter>(p));
 	}
 }
 
@@ -142,7 +142,7 @@ DynamicSql::SqlText::bindParams(ExecContext *, DB::Command *, unsigned int &) co
 
 namespace DynamicSql {
 	template <>
-	boost::shared_ptr<DB::SelectCommand>
+	std::shared_ptr<DB::SelectCommand>
 	SqlWriterWrapper::getCommandFor<DB::SelectCommand>(DB::Connection * db, const Glib::ustring & f) const
 	{
 		AdHoc::Buffer sql;
@@ -155,7 +155,7 @@ namespace DynamicSql {
 	}
 
 	template <>
-	boost::shared_ptr<DB::ModifyCommand>
+	std::shared_ptr<DB::ModifyCommand>
 	SqlWriterWrapper::getCommandFor<DB::ModifyCommand>(DB::Connection * db, const Glib::ustring & f) const
 	{
 		AdHoc::Buffer sql;
diff --git a/project2/sql/sqlWriters.h b/project2/sql/sqlWriters.h
index a16412d..0ef7115 100644
--- a/project2/sql/sqlWriters.h
+++ b/project2/sql/sqlWriters.h
@@ -14,10 +14,10 @@
 
 namespace DynamicSql {
 	class SqlWriter;
-	typedef boost::intrusive_ptr<SqlWriter> SqlWriterPtr;
+	typedef std::shared_ptr<SqlWriter> SqlWriterPtr;
 	typedef std::list<SqlWriterPtr> Writers;
 
-	class DLL_PUBLIC SqlWriter : public IntrusivePtrBase {
+	class DLL_PUBLIC SqlWriter {
 		public:
 			virtual ~SqlWriter() = default;
 			virtual void writeSql(AdHoc::Buffer & sql) const = 0;
@@ -74,7 +74,7 @@ namespace DynamicSql {
 			virtual void writeSql(AdHoc::Buffer & sql) override;
 			virtual void bindParams(DB::Command *, unsigned int & offset) override;
 
-			template <typename CommandType> boost::shared_ptr<CommandType> getCommandFor(DB::Connection *, const Glib::ustring & f) const;
+			template <typename CommandType> std::shared_ptr<CommandType> getCommandFor(DB::Connection *, const Glib::ustring & f) const;
 
 		private:
 			ExecContext * ec;
diff --git a/project2/sql/unittests/Jamfile.jam b/project2/sql/unittests/Jamfile.jam
deleted file mode 100644
index 7b45800..0000000
--- a/project2/sql/unittests/Jamfile.jam
+++ /dev/null
@@ -1,9 +0,0 @@
-import testing ;
-
-lib boost_system ;
-lib boost_filesystem ;
-lib IceUtil ;
-lib Ice ;
-
-path-constant me : . ;
-