C++17 and Ice 3.7p2pvr-0.3.0

Updates all components to be C++17 and Ice 3.7

32 files changed, 337 insertions, 273 deletions

diff --git a/p2pvr/daemon/Jamfile.jam b/p2pvr/daemon/Jamfile.jam
index f276437..df1e310 100644
--- a/p2pvr/daemon/Jamfile.jam
+++ b/p2pvr/daemon/Jamfile.jam
@@ -1,7 +1,7 @@
 import icetray ;
 
 lib slicer : : <name>slicer : : <include>/usr/include/slicer ;
-lib slicer-db : : <name>slicer-db : : <include>/usr/include/slicer ;
+lib slicer-db : : <name>slicer-db : : <include>/usr/include/slicer/slicer ;
 lib boost_program_options ;
 lib dbppcore ;
 
diff --git a/p2pvr/daemon/daemon.cpp b/p2pvr/daemon/daemon.cpp
index fbaa380..902b18f 100644
--- a/p2pvr/daemon/daemon.cpp
+++ b/p2pvr/daemon/daemon.cpp
@@ -6,6 +6,7 @@
 #include "recorder.h"
 #include "recordings.h"
 #include <Ice/ObjectAdapter.h>
+#include <Ice/Initialize.h>
 #include <tmdb-proxy.h>
 #include <icetrayService.h>
 
@@ -36,20 +37,21 @@ class P2PvrDaemon : public IceTray::Service {
 
 			IceUtil::TimerPtr timer = new IceUtil::Timer();
 			auto db = getConnectionPool(ic, "postgresql", "p2pvr");
-			auto devices = add<Tuners>(ic, adapter, new DevicesI(), "Devices");
-			auto maintenance = add<Maintenance>(ic, adapter, new MaintenanceI(db, adapter, timer), "Maintenance");
-			auto si = add<SI>(ic, adapter, new SII(db), "SI");
-			auto schedules = add<Schedules>(ic, adapter, new SchedulesI(db), "Schedules");
-			auto storage = add<Storage>(ic, adapter, new StorageI(db), "Storage");
-			auto recorder = add<Recorder>(ic, adapter, new RecorderI(adapter, timer), "Recorder");
-			auto recordings = add<Recordings>(ic, adapter, new RecordingsI(db), "Recordings");
-			auto tmdb = add<TMDb::Proxy>(ic, adapter, new TMDb::Proxy(tmdbOpts->baseUrl, tmdbOpts->apikey), "TMDb");
+			auto devices = add<DevicesI>(adapter, "Devices");
+			auto maintenance = add<MaintenanceI>(adapter, "Maintenance", db, adapter, timer);
+			auto si = add<SII>(adapter, "SI", db);
+			auto schedules = add<SchedulesI>(adapter, "Schedules", db);
+			auto storage = add<StorageI>(adapter, "Storage", db);
+			auto recorder = add<RecorderI>(adapter, "Recorder", adapter, timer);
+			auto recordings = add<RecordingsI>(adapter, "Recordings", db);
+			auto tmdb = add<TMDb::Proxy>(adapter, "TMDb", tmdbOpts->baseUrl, tmdbOpts->apikey);
 		}
 
-		template<typename Object>
-		typename Object::ProxyType add(const Ice::CommunicatorPtr & ic, const Ice::ObjectAdapterPtr & adapter, const IceUtil::Handle<Object> & object, const std::string & name) const
+		template<typename Object, typename ... Params>
+		std::shared_ptr<typename Object::ProxyType> add(const Ice::ObjectAdapterPtr & adapter,
+				const std::string & name, const Params & ... ps) const
 		{
-			return Object::ProxyType::uncheckedCast(adapter->add(object, ic->stringToIdentity(name)));
+			return Ice::uncheckedCast<typename Object::ProxyType>(adapter->add(std::make_shared<Object>(ps...), Ice::stringToIdentity(name)));
 		}
 };
 
diff --git a/p2pvr/daemon/icetraySupport.cpp b/p2pvr/daemon/icetraySupport.cpp
index 8f81ec4..646896f 100644
--- a/p2pvr/daemon/icetraySupport.cpp
+++ b/p2pvr/daemon/icetraySupport.cpp
@@ -1,9 +1,9 @@
 #include "icetraySupport.h"
-#include "commonHelpers.h"
+#include "chronoHelpers.h"
 
 template<>
 void
-IceTray::AbstractDatabaseClient::bind1<Common::DateTime>(int x, DB::Command * cmd, const Common::DateTime & dt)
+IceTray::AbstractDatabaseClient::bind1<Chrono::DateTime>(int x, DB::Command * cmd, const Chrono::DateTime & dt)
 {
 	cmd->bindParamT(x, *dt);
 }
diff --git a/p2pvr/daemon/icetraySupport.h b/p2pvr/daemon/icetraySupport.h
index 4174665..c9b633b 100644
--- a/p2pvr/daemon/icetraySupport.h
+++ b/p2pvr/daemon/icetraySupport.h
@@ -2,12 +2,23 @@
 #define P2PVR_ICETRAY_SUPPORT_H
 
 #include <abstractDatabaseClient.h>
-#include <common.h>
+#include <chrono.h>
 
 namespace IceTray {
 	template<>
 	void
-	AbstractDatabaseClient::bind1<Common::DateTime>(int x, DB::Command * cmd, const Common::DateTime &);
+	AbstractDatabaseClient::bind1<Chrono::DateTime>(int x, DB::Command * cmd, const Chrono::DateTime &);
+}
+
+namespace std {
+	template<typename X>
+	ostream & operator<<(ostream & s, const Ice::optional<X> & x)
+	{
+		if (x) {
+			s << *x;
+		}
+		return s;
+	}
 }
 
 #endif
diff --git a/p2pvr/daemon/maintenance.cpp b/p2pvr/daemon/maintenance.cpp
index 6abad00..58d9dc2 100644
--- a/p2pvr/daemon/maintenance.cpp
+++ b/p2pvr/daemon/maintenance.cpp
@@ -6,8 +6,10 @@
 #include <linux/dvb/frontend.h>
 #include <cxxabi.h>
 #include <scopeExit.h>
+#include <boost/bind.hpp>
 
 namespace po = boost::program_options;
+using namespace IceTray::Logging;
 
 namespace P2PVR {
 MaintenanceI::Options::Options() : IceTray::Options("P2PVR Maintenance options") { }
@@ -24,11 +26,11 @@ ICETRAY_OPTIONS(MaintenanceI::Options,
 
 IceTray::Logging::LoggerPtr MaintenanceI::logger(LOGMANAGER()->getLogger<MaintenanceI>());
 
-MaintenanceI::MaintenanceI(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
+MaintenanceI::MaintenanceI(DB::ConnectionPoolPtr db, Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
 	IceTray::AbstractDatabaseClient(db),
 	adapter(a),
 	timer(t),
-	clientCheck(new BindTimerTask(boost::bind(&MaintenanceI::ScheduledUpdate, this))),
+	clientCheck(std::make_shared<BindTimerTask>(boost::bind(&MaintenanceI::ScheduledUpdate, this))),
 	lastUpdateNetwork(0),
 	lastUpdateServices(0),
 	lastUpdateEvents(0),
@@ -62,7 +64,7 @@ MaintenanceI::UpdateAll(short type, const Ice::Current & ice)
 void
 MaintenanceI::ScheduledUpdate()
 {
-	logger->messagebf(LOG::DEBUG, "%s: triggered", __PRETTY_FUNCTION__);
+	logger->messagebf(LogLevel::DEBUG, "%s: triggered", __PRETTY_FUNCTION__);
 	if (!updateRunning) {
 		std::thread update([this] {
 			try {
@@ -70,29 +72,29 @@ MaintenanceI::ScheduledUpdate()
 				updateRunning = true;
 				time_t now = time(NULL);
 				if (lastUpdateNetwork < now - options->periodUpdateNetwork) {
-					logger->messagebf(LOG::INFO, "%s: updating network", __PRETTY_FUNCTION__);
+					logger->messagebf(LogLevel::INFO, "%s: updating network", __PRETTY_FUNCTION__);
 					this->UpdateNetwork(FE_OFDM, Ice::Current());
 					time(&lastUpdateNetwork);
 				}
 				if (lastUpdateServices < now - options->periodUpdateServices) {
-					logger->messagebf(LOG::INFO, "%s: updating services", __PRETTY_FUNCTION__);
+					logger->messagebf(LogLevel::INFO, "%s: updating services", __PRETTY_FUNCTION__);
 					this->UpdateServices(Ice::Current());
 					time(&lastUpdateServices);
 				}
 				if (lastUpdateEvents < now - options->periodUpdateEvents) {
-					logger->messagebf(LOG::INFO, "%s: updating events", __PRETTY_FUNCTION__);
+					logger->messagebf(LogLevel::INFO, "%s: updating events", __PRETTY_FUNCTION__);
 					this->UpdateEvents(Ice::Current());
 					time(&lastUpdateEvents);
 				}
-				logger->messagebf(LOG::DEBUG, "%s: completed", __PRETTY_FUNCTION__);
+				logger->messagebf(LogLevel::DEBUG, "%s: completed", __PRETTY_FUNCTION__);
 			}
 			catch (const std::exception & ex) {
 				char * buf = __cxxabiv1::__cxa_demangle(typeid(ex).name(), NULL, NULL, NULL);
-				logger->messagebf(LOG::ERR, "%s: failed %s: %s", __PRETTY_FUNCTION__, buf, ex.what());
+				logger->messagebf(LogLevel::ERR, "%s: failed %s: %s", __PRETTY_FUNCTION__, buf, ex.what());
 				free(buf);
 			}
 			catch (...) {
-				logger->messagebf(LOG::ERR, "%s: failed (unknown exception)", __PRETTY_FUNCTION__);
+				logger->messagebf(LogLevel::ERR, "%s: failed (unknown exception)", __PRETTY_FUNCTION__);
 			}
 		});
 		update.detach();
diff --git a/p2pvr/daemon/maintenance.h b/p2pvr/daemon/maintenance.h
index ff53ca6..ccbafca 100644
--- a/p2pvr/daemon/maintenance.h
+++ b/p2pvr/daemon/maintenance.h
@@ -20,7 +20,7 @@ class MaintenanceI : public Maintenance, public IceTray::AbstractDatabaseClient
 				bool scanOnStart;
 		};
 
-		MaintenanceI(IceTray::DatabasePoolPtr db, Ice::ObjectAdapterPtr, IceUtil::TimerPtr);
+		MaintenanceI(DB::ConnectionPoolPtr db, Ice::ObjectAdapterPtr, IceUtil::TimerPtr);
 
 		void UpdateAll(const Ice::Current &);
 		void UpdateAll(short type, const Ice::Current &);
diff --git a/p2pvr/daemon/maintenance/events.cpp b/p2pvr/daemon/maintenance/events.cpp
index 30e0a83..18538a4 100644
--- a/p2pvr/daemon/maintenance/events.cpp
+++ b/p2pvr/daemon/maintenance/events.cpp
@@ -1,8 +1,9 @@
 #include "../maintenance.h"
 #include <siParsers/event.h>
 #include <Ice/Communicator.h>
+#include <Ice/Initialize.h>
 #include <temporaryIceAdapterObject.h>
-#include <commonHelpers.h>
+#include <chronoHelpers.h>
 #include <db/sqlTablePatchSerializer.h>
 #include <tablepatch.h>
 #include <sqlWriter.h>
@@ -10,6 +11,8 @@
 #include "sql/maintenance/pruneEvents.sql.h"
 #include "sql/si/serviceIdsWithEit.sql.h"
 
+using namespace IceTray::Logging;
+
 namespace P2PVR {
 class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 	private:
@@ -24,7 +27,7 @@ class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 
 				bool HandleTable(const ::DVBSI::EventPtr & e) override
 				{
-					logger->messagebf(LOG::DEBUG, "Service Id: %d Program Id: %d Title: %s Time: %s - %s",
+					logger->messagebf(LogLevel::DEBUG, "Service Id: %d Program Id: %d Title: %s Time: %s - %s",
 							e->ServiceId, e->EventId, e->Title, e->StartTime, e->StopTime);
 					consumer(e);
 					return false;
@@ -33,7 +36,7 @@ class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 				static RequiredContentIds getIds(DB::Connection * db)
 				{
 					auto sel = sql::si::serviceIdsWithEit.select(db);
-					auto ids = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, std::vector<Ice::Int>>(*sel);
+					auto ids = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, std::vector<Ice::Int>>(sel.get());
 					return {ids.begin(), ids.end()};
 				}
 
@@ -53,8 +56,8 @@ class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 		void Produce(const Consumer & ch) override
 		{
 			auto ic = ice.adapter->getCommunicator();
-			auto devs = TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
-			auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
+			auto devs = Ice::checkedCast<TunersPrx>(ice.adapter->createProxy(Ice::stringToIdentity("Devices")));
+			auto si = Ice::checkedCast<SIPrx>(ice.adapter->createProxy(Ice::stringToIdentity("SI")));
 			if (!devs || !si) {
 				throw std::runtime_error("bad proxy(s)");
 			}
@@ -63,9 +66,9 @@ class SiEventsStream : public Slicer::Stream<::DVBSI::EventPtr> {
 			if (!delivery) {
 				throw std::runtime_error("no delivery methods");
 			}
-			logger->messagebf(LOG::DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__);
-			logger->messagebf(LOG::DEBUG, "%s: Fetching events", __PRETTY_FUNCTION__);
-			TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, new SiEventsHandler(ch, db, logger));
+			logger->messagebf(LogLevel::DEBUG, "%s: Getting a tuner", __PRETTY_FUNCTION__);
+			logger->messagebf(LogLevel::DEBUG, "%s: Fetching events", __PRETTY_FUNCTION__);
+			TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, std::make_shared<SiEventsHandler>(ch, db, logger));
 
 			devs->SendEventInformation(delivery, parser);
 		}
@@ -84,19 +87,19 @@ MaintenanceI::UpdateEvents(const Ice::Current & ice)
 
 	SiEventsStream stream(ice, dbc.get(), logger);
 
-	auto tx = std::make_unique<DB::TransactionScope>(dbc.get());
-	DB::TablePatch tp;
-	tp.dest = "events";
-	tp.insteadOfDelete = new DB::StaticSqlWriter("current = false");
-	tp.where = new DB::StaticSqlWriter("a.current");
-	Slicer::SerializeAny<Slicer::SqlTablePatchSerializer>(stream, dbc.get(), tp);
-
+	{
+		DB::TransactionScope tx(*dbc.get());
+		DB::TablePatch tp;
+		tp.dest = "events";
+		tp.insteadOfDelete = new DB::StaticSqlWriter("current = false");
+		tp.where = new DB::StaticSqlWriter("a.current");
+		Slicer::SerializeAny<Slicer::SqlTablePatchSerializer>(stream, dbc.get(), tp);
 
-	sql::maintenance::pruneEvents.modify(dbc.get())->execute();
-	tx = nullptr;
-	logger->messagebf(LOG::INFO, "%s: Updated events", __PRETTY_FUNCTION__);
+		sql::maintenance::pruneEvents.modify(dbc.get())->execute();
+		logger->messagebf(LogLevel::INFO, "%s: Updated events", __PRETTY_FUNCTION__);
+	}
 
-	auto sch = SchedulesPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Schedules")));
+	auto sch = Ice::checkedCast<SchedulesPrx>(ice.adapter->createProxy(Ice::stringToIdentity("Schedules")));
 	sch->DoReschedule();
 }
 }
diff --git a/p2pvr/daemon/maintenance/network.cpp b/p2pvr/daemon/maintenance/network.cpp
index 2f74050..f128eb8 100644
--- a/p2pvr/daemon/maintenance/network.cpp
+++ b/p2pvr/daemon/maintenance/network.cpp
@@ -1,11 +1,14 @@
 #include "../maintenance.h"
 #include <siParsers/network.h>
 #include <Ice/Communicator.h>
+#include <Ice/Initialize.h>
 #include <temporaryIceAdapterObject.h>
 #include <tablepatch.h>
 #include <db/sqlInsertSerializer.h>
 #include <db/sqlTablePatchSerializer.h>
 
+using namespace IceTray::Logging;
+
 namespace P2PVR {
 class SiNetworkInformationMerger : public DVBSI::SiNetworkInformationParser {
 	public:
@@ -17,14 +20,14 @@ class SiNetworkInformationMerger : public DVBSI::SiNetworkInformationParser {
 
 		bool HandleTable(const ::DVBSI::NetworkPtr & n)
 		{
-			logger->messagebf(LOG::DEBUG, "Network Id: %d Name: %s", n->NetworkId, *n->Name);
+			logger->messagebf(LogLevel::DEBUG, "Network Id: %d Name: %s", n->NetworkId, *n->Name);
 			for (const auto & ts : n->TransportStreams) {
-				logger->messagebf(LOG::DEBUG, "\tTransport Stream Id: %d Original Network Id: %d", ts->TransportStreamId, ts->OriginalNetworkId);
+				logger->messagebf(LogLevel::DEBUG, "\tTransport Stream Id: %d Original Network Id: %d", ts->TransportStreamId, ts->OriginalNetworkId);
 				for (const auto & s : ts->Services) {
-					logger->messagebf(LOG::DEBUG, "\t\tService Id: %d Service Type: %d", s.ServiceId, s.Type);
+					logger->messagebf(LogLevel::DEBUG, "\t\tService Id: %d Service Type: %d", s.ServiceId, s.Type);
 				}
 				if (ts->Terrestrial) {
-					logger->messagebf(LOG::DEBUG, "\t\tDVB-T: Frequency: %d", ts->Terrestrial->Frequency);
+					logger->messagebf(LogLevel::DEBUG, "\t\tDVB-T: Frequency: %d", ts->Terrestrial->Frequency);
 				}
 			}
 
@@ -80,16 +83,16 @@ MaintenanceI::UpdateNetwork(short, const Ice::Current & ice)
 {
 	auto dbc = db->get();
 	auto ic = ice.adapter->getCommunicator();
-	auto devs = TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
-	auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
-	auto siparser = new SiNetworkInformationMerger(dbc.get(), logger);
+	auto devs = Ice::checkedCast<TunersPrx>(ice.adapter->createProxy(Ice::stringToIdentity("Devices")));
+	auto si = Ice::checkedCast<SIPrx>(ice.adapter->createProxy(Ice::stringToIdentity("SI")));
+	auto siparser = std::make_shared<SiNetworkInformationMerger>(dbc.get(), logger);
 	TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, siparser);
 
 	if (!devs) {
 		throw std::runtime_error("bad proxy(s)");
 	}
 
-	DB::TransactionScope tx(dbc.get());
+	DB::TransactionScope tx(*dbc.get());
 
 	auto transport = si->GetDeliveryForSi();
 	if (transport) {
diff --git a/p2pvr/daemon/maintenance/services.cpp b/p2pvr/daemon/maintenance/services.cpp
index 288dd99..8a0ef52 100644
--- a/p2pvr/daemon/maintenance/services.cpp
+++ b/p2pvr/daemon/maintenance/services.cpp
@@ -2,12 +2,15 @@
 #include <siParsers/service.h>
 #include <tablepatch.h>
 #include <Ice/Communicator.h>
+#include <Ice/Initialize.h>
 #include <temporaryIceAdapterObject.h>
 #include <slicer/slicer.h>
 #include <db/sqlTablePatchSerializer.h>
 #include <tablepatch.h>
 #include <sql/si/allDeliveriesTransportStreamId.sql.h>
 
+using namespace IceTray::Logging;
+
 namespace P2PVR {
 class SiServicesMerger : public DVBSI::SiServicesParser {
 	public:
@@ -20,9 +23,9 @@ class SiServicesMerger : public DVBSI::SiServicesParser {
 
 		bool HandleTable(const ::DVBSI::TransportStreamPtr & ts)
 		{
-			logger->messagebf(LOG::DEBUG, "Transport Stream Id: %d Original Network Id: %s", ts->TransportStreamId, ts->OriginalNetworkId);
+			logger->messagebf(LogLevel::DEBUG, "Transport Stream Id: %d Original Network Id: %s", ts->TransportStreamId, ts->OriginalNetworkId);
 			for (const auto & s : ts->Services) {
-				logger->messagebf(LOG::DEBUG, "\tService Id: %d Name: %s Type: %d, Provider: %s, DefaultAuthority: %s, RunningStatus %d FreeCaMode %d",
+				logger->messagebf(LogLevel::DEBUG, "\tService Id: %d Name: %s Type: %d, Provider: %s, DefaultAuthority: %s, RunningStatus %d FreeCaMode %d",
 						s->ServiceId, (s->Name ? *s->Name : "?"), (s->Type ? *s->Type : -1),
 						(s->ProviderName ? *s->ProviderName : "?"), (s->DefaultAuthority ? *s->DefaultAuthority : "?"),
 						s->RunningStatus, s->FreeCaMode);
@@ -39,7 +42,7 @@ class SiServicesMerger : public DVBSI::SiServicesParser {
 		static RequiredContentIds getIds(DB::Connection * db)
 		{
 			auto sel = sql::si::allDeliveriesTransportStreamId.select(db);
-			auto ids = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, std::vector<Ice::Int>>(*sel);
+			auto ids = Slicer::DeserializeAny<Slicer::SqlSelectDeserializer, std::vector<Ice::Int>>(sel.get());
 			return {ids.begin(), ids.end()};
 		}
 
@@ -52,15 +55,15 @@ void
 MaintenanceI::UpdateServices(const Ice::Current & ice)
 {
 	auto ic = ice.adapter->getCommunicator();
-	auto devs = TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
-	auto si = SIPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("SI")));
+	auto devs = Ice::checkedCast<TunersPrx>(ice.adapter->createProxy(Ice::stringToIdentity("Devices")));
+	auto si = Ice::checkedCast<SIPrx>(ice.adapter->createProxy(Ice::stringToIdentity("SI")));
 
 	if (!devs || !si) {
 		throw std::runtime_error("bad proxy(s)");
 	}
 
 	auto dbc = db->get();
-	auto siparser = new SiServicesMerger(logger, dbc.get());
+	auto siparser = std::make_shared<SiServicesMerger>(logger, dbc.get());
 	TemporaryIceAdapterObject<RawDataClient> parser(ice.adapter, siparser);
 
 	auto delivery = si->GetDeliveryForSi();
@@ -68,10 +71,10 @@ MaintenanceI::UpdateServices(const Ice::Current & ice)
 		throw std::runtime_error("no delivery methods");
 	}
 
-	DB::TransactionScope tx(dbc.get());
-	logger->messagebf(LOG::DEBUG, "%s: Fetching service list", __PRETTY_FUNCTION__);
+	DB::TransactionScope tx(*dbc.get());
+	logger->messagebf(LogLevel::DEBUG, "%s: Fetching service list", __PRETTY_FUNCTION__);
 	devs->SendServiceDescriptions(delivery, parser);
-	logger->messagebf(LOG::INFO, "%s: Updated service list", __PRETTY_FUNCTION__);
+	logger->messagebf(LogLevel::INFO, "%s: Updated service list", __PRETTY_FUNCTION__);
 }
 }
 
diff --git a/p2pvr/daemon/p2pvr-int.ice b/p2pvr/daemon/p2pvr-int.ice
index 9a99239..8a6ae62 100644
--- a/p2pvr/daemon/p2pvr-int.ice
+++ b/p2pvr/daemon/p2pvr-int.ice
@@ -1,4 +1,4 @@
-#include <common.ice>
+#include <chrono.ice>
 #include <dvbsi.ice>
 
 module P2PVR {
@@ -6,8 +6,8 @@ module P2PVR {
 		string What;
 		int EventUid;
 		int TransportStreamId;
-		Common::DateTime StartTime;
-		Common::DateTime StopTime;
+		Chrono::DateTime StartTime;
+		Chrono::DateTime StopTime;
 		int Priority;
 		int ScheduleId;
 	};
diff --git a/p2pvr/daemon/recorder.cpp b/p2pvr/daemon/recorder.cpp
index f32eb73..25709c8 100644
--- a/p2pvr/daemon/recorder.cpp
+++ b/p2pvr/daemon/recorder.cpp
@@ -2,14 +2,16 @@
 #include "bindTimerTask.h"
 #include <boost/bind.hpp>
 #include <logger.h>
-#include <commonHelpers.h>
+#include <chronoHelpers.h>
 #include <scopeExit.h>
 #include "serviceStreamer.h"
 #include "storage.h"
 #include "muxer.h"
 #include <boost/lexical_cast.hpp>
+#include <Ice/Initialize.h>
 
 namespace po = boost::program_options;
+using namespace IceTray::Logging;
 
 namespace P2PVR {
 IceTray::Logging::LoggerPtr RecorderI::logger(LOGMANAGER()->getLogger<RecorderI>());
@@ -18,10 +20,21 @@ RecorderI::RecorderI(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr t) :
 	adapter(a),
 	timer(t)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	RefreshSchedules(Ice::Current());
 }
 
+RecorderI::Current::Current(RawDataClientPrxPtr str, ServiceStreamerPtr strm,
+		SchedulePtr sch, ::DVBSI::ServicePtr srv, EventPtr e, IceUtil::TimerTaskPtr st) :
+	store(str),
+	stream(strm),
+	schedule(sch),
+	service(srv),
+	event(e),
+	stopTimer(st)
+{
+}
+
 void
 RecorderI::RefreshSchedules(const Ice::Current &)
 {
@@ -30,8 +43,8 @@ RecorderI::RefreshSchedules(const Ice::Current &)
 		timer->cancel(t);
 	}
 	pendingRecordings.clear();
-	auto schedules = SchedulesPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Schedules")));
-	auto si = SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
+	auto schedules = Ice::checkedCast<SchedulesPrx>(adapter->createProxy(Ice::stringToIdentity("Schedules")));
+	auto si = Ice::checkedCast<SIPrx>(adapter->createProxy(Ice::stringToIdentity("SI")));
 	for (const auto & s : schedules->GetScheduledToRecord()) {
 		if (std::find_if(currentRecordings.begin(), currentRecordings.end(), [&s](const CurrentPtr & c) {
 					return s->ScheduleId == c->schedule->ScheduleId && s->EventUid == c->event->EventUid;
@@ -43,10 +56,10 @@ RecorderI::RefreshSchedules(const Ice::Current &)
 		auto service = si->GetService(event->ServiceId);
 
 		auto startIn = std::max<time_t>((*event->StartTime - *schedule->Early - boost::posix_time::second_clock::universal_time()).total_seconds(), 0);
-		IceUtil::TimerTaskPtr startTimer = new BindTimerTask(boost::bind(&RecorderI::StartRecording, this, schedule, service, event));
+		IceUtil::TimerTaskPtr startTimer = std::make_shared<BindTimerTask>(boost::bind(&RecorderI::StartRecording, this, schedule, service, event));
 		timer->schedule(startTimer, IceUtil::Time::seconds(startIn));
 		pendingRecordings.push_back(startTimer);
-		logger->messagebf(LOG::DEBUG, "Recording %s scheduled for %s seconds", event->Title, startIn);
+		logger->messagebf(LogLevel::DEBUG, "Recording %s scheduled for %s seconds", event->Title, startIn);
 	}
 }
 
@@ -54,39 +67,39 @@ void
 RecorderI::StartRecording(SchedulePtr schedule, ::DVBSI::ServicePtr service, EventPtr event)
 {
 	std::lock_guard<std::mutex> g(lock);
-	auto storage = StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
-	auto recordings = RecordingsPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Recordings")));
-	auto devices = TunersPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Devices")));
-	auto si = SIPrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("SI")));
+	auto storage = Ice::checkedCast<StoragePrx>(adapter->createProxy(Ice::stringToIdentity("Storage")));
+	auto recordings = Ice::checkedCast<RecordingsPrx>(adapter->createProxy(Ice::stringToIdentity("Recordings")));
+	auto devices = Ice::checkedCast<TunersPrx>(adapter->createProxy(Ice::stringToIdentity("Devices")));
+	auto si = Ice::checkedCast<SIPrx>(adapter->createProxy(Ice::stringToIdentity("SI")));
 
-	auto recordingId = recordings->NewRecording(new Recording(0, schedule->ScheduleId, event->EventUid));
+	auto recordingId = recordings->NewRecording(std::make_shared<Recording>(0, schedule->ScheduleId, event->EventUid));
 	auto target = storage->OpenForWrite(recordingId);
-	auto ss = ServiceStreamerPtr(new ServiceStreamer(service->ServiceId, target, devices, si, adapter));
+	auto ss = ServiceStreamerPtr(std::make_shared<ServiceStreamer>(service->ServiceId, target, devices, si, adapter));
 
 	ss->Start();
-	logger->messagebf(LOG::INFO, "Started recording %s (%s - %s) on %s (%d)",
+	logger->messagebf(LogLevel::INFO, "Started recording %s (%s - %s) on %s (%d)",
 			event->Title, event->StartTime, event->StopTime,
 			service->Name ? *service->Name : "<no name>", service->ServiceId);
 
-	auto newCurrent = CurrentPtr(new Current({target, ss, schedule, service, event, IceUtil::TimerTaskPtr()}));
+	auto newCurrent = std::make_shared<Current>(target, ss, schedule, service, event, IceUtil::TimerTaskPtr());
 	currentRecordings.insert(newCurrent);
 
 	auto stopIn = (*event->StopTime + *schedule->Late - boost::posix_time::second_clock::universal_time()).total_seconds();
-	newCurrent->stopTimer = new BindTimerTask(boost::bind(&RecorderI::StopRecording, this, newCurrent));
+	newCurrent->stopTimer = std::make_shared<BindTimerTask>(boost::bind(&RecorderI::StopRecording, this, newCurrent));
 	timer->schedule(newCurrent->stopTimer, IceUtil::Time::seconds(stopIn));
-	logger->messagebf(LOG::DEBUG, "Recording %s scheduled stop in %s seconds", event->Title, stopIn);
+	logger->messagebf(LogLevel::DEBUG, "Recording %s scheduled stop in %s seconds", event->Title, stopIn);
 }
 
 void
 RecorderI::StopRecording(CurrentPtr c)
 {
 	std::lock_guard<std::mutex> g(lock);
-	logger->messagebf(LOG::DEBUG, "Stopping %s", c->event->Title);
+	logger->messagebf(LogLevel::DEBUG, "Stopping %s", c->event->Title);
 	c->stream->Stop();
 	currentRecordings.erase(c);
-	auto storage = StoragePrx::checkedCast(adapter->createProxy(adapter->getCommunicator()->stringToIdentity("Storage")));
+	auto storage = Ice::checkedCast<StoragePrx>(adapter->createProxy(Ice::stringToIdentity("Storage")));
 	storage->Close(c->store);
-	logger->messagebf(LOG::DEBUG, "Stopped %s", c->event->Title);
+	logger->messagebf(LogLevel::DEBUG, "Stopped %s", c->event->Title);
 }
 }
 
diff --git a/p2pvr/daemon/recorder.h b/p2pvr/daemon/recorder.h
index b2d581c..8a4fd77 100644
--- a/p2pvr/daemon/recorder.h
+++ b/p2pvr/daemon/recorder.h
@@ -15,14 +15,20 @@ class RecorderI : public Recorder {
 
 		class Current {
 			public:
-				RawDataClientPrx store;
+				Current(RawDataClientPrxPtr store,
+						ServiceStreamerPtr stream,
+						SchedulePtr schedule,
+						::DVBSI::ServicePtr service,
+						EventPtr event,
+						IceUtil::TimerTaskPtr stopTimer);
+				RawDataClientPrxPtr store;
 				ServiceStreamerPtr stream;
 				SchedulePtr schedule;
 				::DVBSI::ServicePtr service;
 				EventPtr event;
 				IceUtil::TimerTaskPtr stopTimer;
 		};
-		typedef boost::shared_ptr<Current> CurrentPtr;
+		typedef std::shared_ptr<Current> CurrentPtr;
 		typedef std::set<CurrentPtr> Currents;
 
 		RecorderI(Ice::ObjectAdapterPtr a, IceUtil::TimerPtr);
diff --git a/p2pvr/daemon/recordings.cpp b/p2pvr/daemon/recordings.cpp
index 0ab2e46..5bb0fd0 100644
--- a/p2pvr/daemon/recordings.cpp
+++ b/p2pvr/daemon/recordings.cpp
@@ -6,23 +6,26 @@
 #include <slicer/db/sqlInsertSerializer.h>
 #include <sql/recordings/deleteById.sql.h>
 #include <sql/recordings/getAll.sql.h>
+#include <modifycommand.h>
+
+using namespace IceTray::Logging;
 
 namespace P2PVR {
 IceTray::Logging::LoggerPtr RecordingsI::logger(LOGMANAGER()->getLogger<RecordingsI>());
 
-RecordingsI::RecordingsI(IceTray::DatabasePoolPtr db) :
+RecordingsI::RecordingsI(DB::ConnectionPoolPtr db) :
 	IceTray::AbstractDatabaseClient(db)
 {
 }
 
 Ice::Int
-RecordingsI::NewRecording(const RecordingPtr & r, const Ice::Current &)
+RecordingsI::NewRecording(const RecordingPtr r, const Ice::Current &)
 {
 	auto dbc = db->get();
-	logger->messagebf(LOG::INFO, "%s: Creating new recording for %d (EventUid %d)", __PRETTY_FUNCTION__, r->RecordingId, r->EventUid);
-	DB::TransactionScope tx(dbc.get());
+	logger->messagebf(LogLevel::INFO, "%s: Creating new recording for %d (EventUid %d)", __PRETTY_FUNCTION__, r->RecordingId, r->EventUid);
+	DB::TransactionScope tx(*dbc.get());
 	Slicer::SerializeAny<Slicer::SqlFetchIdInsertSerializer>(r, dbc.get(), "recordings");
-	logger->messagebf(LOG::INFO, "%s: Created recording Id: %d", __PRETTY_FUNCTION__, r->RecordingId);
+	logger->messagebf(LogLevel::INFO, "%s: Created recording Id: %d", __PRETTY_FUNCTION__, r->RecordingId);
 	return r->RecordingId;
 }
 
@@ -30,7 +33,7 @@ void
 RecordingsI::DeleteRecording(int id, const Ice::Current &)
 {
 	auto dbc = db->get();
-	logger->messagebf(LOG::INFO, "%s: Deleting recording Id: %d", __PRETTY_FUNCTION__, id);
+	logger->messagebf(LogLevel::INFO, "%s: Deleting recording Id: %d", __PRETTY_FUNCTION__, id);
 	auto del = sql::recordings::deleteById.modify(dbc.get());
 	del->bindParamI(0, id);
 	del->execute();
@@ -39,7 +42,7 @@ RecordingsI::DeleteRecording(int id, const Ice::Current &)
 RecordingList
 RecordingsI::GetRecordings(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<RecordingList>(sql::recordings::getAll);
 }
 }
diff --git a/p2pvr/daemon/recordings.h b/p2pvr/daemon/recordings.h
index e705e43..2246f03 100644
--- a/p2pvr/daemon/recordings.h
+++ b/p2pvr/daemon/recordings.h
@@ -9,11 +9,11 @@
 namespace P2PVR {
 class RecordingsI : public Recordings, public IceTray::AbstractDatabaseClient {
 	public:
-		RecordingsI(IceTray::DatabasePoolPtr db);
+		RecordingsI(DB::ConnectionPoolPtr db);
 
-		Ice::Int NewRecording(const RecordingPtr & rec, const Ice::Current &);
-		void DeleteRecording(int recordingId, const Ice::Current &);
-		RecordingList GetRecordings(const Ice::Current &);
+		Ice::Int NewRecording(const RecordingPtr rec, const Ice::Current &) override;
+		void DeleteRecording(int recordingId, const Ice::Current &) override;
+		RecordingList GetRecordings(const Ice::Current &) override;
 
 	private:
 		static IceTray::Logging::LoggerPtr logger;
diff --git a/p2pvr/daemon/schedules.cpp b/p2pvr/daemon/schedules.cpp
index d948603..273aa38 100644
--- a/p2pvr/daemon/schedules.cpp
+++ b/p2pvr/daemon/schedules.cpp
@@ -1,7 +1,7 @@
 #include "schedules.h"
 #include <logger.h>
 #include <Ice/Ice.h>
-#include "commonHelpers.h"
+#include "chronoHelpers.h"
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <factory.impl.h>
 #include <slicer/db/sqlSelectDeserializer.h>
@@ -18,6 +18,7 @@
 #include "sql/schedules/scheduledToRecord.sql.h"
 
 namespace po = boost::program_options;
+using namespace IceTray::Logging;
 
 namespace P2PVR {
 IceTray::Logging::LoggerPtr SchedulesI::logger(LOGMANAGER()->getLogger<SchedulesI>());
@@ -164,7 +165,7 @@ EpisodeGroup::SuggestWithFeedback(const Showings & showings)
 	}
 }
 
-SchedulesI::SchedulesI(IceTray::DatabasePoolPtr db) :
+SchedulesI::SchedulesI(DB::ConnectionPoolPtr db) :
 	IceTray::AbstractDatabaseClient(db)
 {
 }
@@ -178,7 +179,7 @@ SchedulesI::GetEpisodeIntersects(Episodes & all, Episodes & grouped)
 			for (const auto & gs : ge->showings) {
 				for (const auto & as : ae->showings) {
 					if (gs->period.intersects(as->period)) {
-						logger->messagebf(LOG::DEBUG, "	added %s", ae->what);
+						logger->messagebf(LogLevel::DEBUG, "	added %s", ae->what);
 						grouped.push_back(ae);
 						all.erase(aei);
 						GetEpisodeIntersects(all, grouped);
@@ -194,7 +195,7 @@ void
 SchedulesI::DoReschedule(const Ice::Current & ice)
 {
 	auto ic = ice.adapter->getCommunicator();
-	auto devs = P2PVR::TunersPrx::checkedCast(ice.adapter->createProxy(ic->stringToIdentity("Devices")));
+	auto devs = Ice::checkedCast<P2PVR::TunersPrx>(ice.adapter->createProxy(Ice::stringToIdentity("Devices")));
 	unsigned int tunerCount = devs->TunerCount();
 
 	// Load list from database
@@ -206,18 +207,18 @@ SchedulesI::DoReschedule(const Ice::Current & ice)
 	int minPriority = 0;
 	for (const auto & c : episodes) {
 		if (!cur || cur->what != c->What) {
-			cur = new Episode(c->What);
+			cur = std::make_shared<Episode>(c->What);
 			scheduleList.push_back(cur);
 		}
-		ShowingPtr s = new Showing(c->EventUid, c->TransportStreamId, c->ScheduleId,
+		ShowingPtr s = std::make_shared<Showing>(c->EventUid, c->TransportStreamId, c->ScheduleId,
 				*c->StartTime, *c->StopTime, c->Priority, cur.get());
 		minPriority = std::min(minPriority, s->priority);
 		cur->showings.push_back(s);
 		allShowings.push_back(s);
 	}
-	logger->messagebf(LOG::DEBUG, "%d episodes created, %s showings", scheduleList.size(), allShowings.size());
+	logger->messagebf(LogLevel::DEBUG, "%d episodes created, %s showings", scheduleList.size(), allShowings.size());
 	for (const auto & e : scheduleList) {
-		logger->messagebf(LOG::DEBUG, "	%s", e->what);
+		logger->messagebf(LogLevel::DEBUG, "	%s", e->what);
 		for (const auto & s : e->showings) {
 			s->priority += 1 - minPriority;
 			e->priority += s->priority;
@@ -229,7 +230,7 @@ SchedulesI::DoReschedule(const Ice::Current & ice)
 	// Solve
 	while (!scheduleList.empty()) {
 		auto work = scheduleList.begin();
-		logger->messagebf(LOG::DEBUG, "start %s", (*work)->what);
+		logger->messagebf(LogLevel::DEBUG, "start %s", (*work)->what);
 		Episodes group;
 		group.push_back(*work);
 		scheduleList.erase(work);
@@ -240,15 +241,15 @@ SchedulesI::DoReschedule(const Ice::Current & ice)
 				return a->what < b->what;
 			});
 
-		logger->messagebf(LOG::DEBUG, "group created with %d episodes", group.size());
+		logger->messagebf(LogLevel::DEBUG, "group created with %d episodes", group.size());
 		double total = 1;
 		// Measure and add the optional to not record
 		for (const auto & e : group) {
-			logger->messagebf(LOG::DEBUG, "	%d * %d:%s", e->showings.size(), e->priority, e->what);
+			logger->messagebf(LogLevel::DEBUG, "	%d * %d:%s", e->showings.size(), e->priority, e->what);
 			e->showings.push_back(NULL);
 			total *= e->showings.size();
 		}
-		logger->messagebf(LOG::DEBUG, "group complexity of %d options", total);
+		logger->messagebf(LogLevel::DEBUG, "group complexity of %d options", total);
 
 		EpisodeGroupPtr sched = EpisodeGroupPtr(EpisodeGroupFactory::createNew(options->SchedulerAlgorithm, group));
 		sched->tuners = tunerCount;
@@ -258,17 +259,17 @@ SchedulesI::DoReschedule(const Ice::Current & ice)
 		}
 
 		for (const auto & c : group) {
-			logger->messagebf(LOG::DEBUG, "Episode %s, %d options", c->what, c->showings.size());
+			logger->messagebf(LogLevel::DEBUG, "Episode %s, %d options", c->what, c->showings.size());
 			for (const auto & i : c->showings) {
 				if (selected.find(i) != selected.end()) {
-					logger->messagebf(LOG::DEBUG, "	%s - %s (%d) <-", i->startTime, i->stopTime, i->transportStreamId);
+					logger->messagebf(LogLevel::DEBUG, "	%s - %s (%d) <-", i->startTime, i->stopTime, i->transportStreamId);
 				}
 				else if (i) {
-					logger->messagebf(LOG::DEBUG, "	%s - %s (%d)", i->startTime, i->stopTime, i->transportStreamId);
+					logger->messagebf(LogLevel::DEBUG, "	%s - %s (%d)", i->startTime, i->stopTime, i->transportStreamId);
 				}
 			}
 		}
-		logger->message(LOG::DEBUG, "----------");
+		logger->message(LogLevel::DEBUG, "----------");
 		for (const auto & c : group) {
 			bool found = false;
 			for (const auto & i : c->showings) {
@@ -279,22 +280,22 @@ SchedulesI::DoReschedule(const Ice::Current & ice)
 			}
 			for (const auto & i : c->showings) {
 				if (i) {
-					records.push_back(new P2PVR::ScheduledToRecord(i->eventUid,
+					records.push_back(std::make_shared<P2PVR::ScheduledToRecord>(i->eventUid,
 									found ?
-									selected.find(i) != selected.end() ? P2PVR::WillRecordThisShowing : P2PVR::WillRecordOtherShowing :
-									P2PVR::CannotRecordAnyShowing, i->scheduleId));
+									selected.find(i) != selected.end() ? RecordStatuses::WillRecordThisShowing : RecordStatuses::WillRecordOtherShowing :
+									RecordStatuses::CannotRecordAnyShowing, i->scheduleId));
 				}
 			}
 		}
 	}
 
 	auto dbc = db->get();
-	DB::TransactionScope tx(dbc.get());
+	DB::TransactionScope tx(*dbc.get());
 	DB::TablePatch mergeRecords;
 	mergeRecords.dest = "record";
 	Slicer::SerializeAny<Slicer::SqlTablePatchSerializer>(records, dbc.get(), mergeRecords);
 
-	auto recorder = P2PVR::RecorderPrx::checkedCast(ice.adapter->createProxy(ice.adapter->getCommunicator()->stringToIdentity("Recorder")));
+	auto recorder = Ice::checkedCast<RecorderPrx>(ice.adapter->createProxy(Ice::stringToIdentity("Recorder")));
 	recorder->RefreshSchedules();
 }
 
@@ -311,14 +312,14 @@ SchedulesI::DeleteSchedule(int id, const Ice::Current & ice)
 P2PVR::ScheduleList
 SchedulesI::GetSchedules(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<P2PVR::ScheduleList>(P2PVR::sql::schedules::selectAll);
 }
 
 P2PVR::SchedulePtr
 SchedulesI::GetSchedule(int id, const Ice::Current &)
 {
-	logger->messagebf(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
+	logger->messagebf(LogLevel::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
 	auto schedules = fetch<P2PVR::ScheduleList>(P2PVR::sql::schedules::selectById, id);
 	if (schedules.empty()) throw P2PVR::NotFound();
 	return schedules.front();
@@ -327,12 +328,12 @@ SchedulesI::GetSchedule(int id, const Ice::Current &)
 P2PVR::ScheduledToRecordList
 SchedulesI::GetScheduledToRecord(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<P2PVR::ScheduledToRecordList>(P2PVR::sql::schedules::scheduledToRecord);
 }
 
 Ice::Int
-SchedulesI::NewSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
+SchedulesI::NewSchedule(const P2PVR::SchedulePtr s, const Ice::Current & ice)
 {
 	auto dbc = db->get();
 	Slicer::SerializeAny<Slicer::SqlFetchIdInsertSerializer>(s, dbc.get(), "schedules");
@@ -341,7 +342,7 @@ SchedulesI::NewSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
 }
 
 void
-SchedulesI::UpdateSchedule(const P2PVR::SchedulePtr & s, const Ice::Current & ice)
+SchedulesI::UpdateSchedule(const P2PVR::SchedulePtr s, const Ice::Current & ice)
 {
 	auto dbc = db->get();
 	Slicer::SerializeAny<Slicer::SqlUpdateSerializer>(s, dbc.get(), "schedules");
diff --git a/p2pvr/daemon/schedules.h b/p2pvr/daemon/schedules.h
index f1fcde2..7b235a9 100644
--- a/p2pvr/daemon/schedules.h
+++ b/p2pvr/daemon/schedules.h
@@ -5,14 +5,13 @@
 #include <options.h>
 #include <abstractDatabaseClient.h>
 #include <factory.h>
-#include <intrusivePtrBase.h>
 #include <logger.h>
 
 namespace P2PVR {
 typedef boost::posix_time::ptime datetime;
 class Episode;
 
-class Showing : public IntrusivePtrBase {
+class Showing {
 	public:
 		Showing(unsigned int e, unsigned int t, unsigned int sc, datetime start, datetime stop, int p, const Episode * ep);
 		// Record what?
@@ -26,18 +25,18 @@ class Showing : public IntrusivePtrBase {
 		const datetime stopTime;
 		const boost::posix_time::time_period period;
 };
-typedef boost::intrusive_ptr<Showing> ShowingPtr;
+typedef std::shared_ptr<Showing> ShowingPtr;
 typedef std::vector<ShowingPtr> Showings;
 typedef Showings::const_iterator ShowingsIter;
 
-class Episode : public IntrusivePtrBase {
+class Episode {
 	public:
 		Episode(const std::string & w);
 		int priority;
 		const std::string what;
 		Showings showings;
 };
-typedef boost::intrusive_ptr<Episode> EpisodePtr;
+typedef std::shared_ptr<Episode> EpisodePtr;
 typedef std::vector<EpisodePtr> Episodes;
 typedef Episodes::const_iterator EpisodesIter;
 
@@ -75,15 +74,15 @@ class SchedulesI : public Schedules, public IceTray::AbstractDatabaseClient {
 				std::string SchedulerAlgorithm;
 		};
 
-		SchedulesI(IceTray::DatabasePoolPtr);
+		SchedulesI(DB::ConnectionPoolPtr);
 
-		void DeleteSchedule(int id, const Ice::Current &);
-		SchedulePtr GetSchedule(int id, const Ice::Current &);
-		ScheduleList GetSchedules(const Ice::Current &);
-		ScheduledToRecordList GetScheduledToRecord(const Ice::Current &);
-		Ice::Int NewSchedule(const SchedulePtr &, const Ice::Current &);
-		void UpdateSchedule(const SchedulePtr &, const Ice::Current &);
-		void DoReschedule(const Ice::Current &);
+		void DeleteSchedule(int id, const Ice::Current &) override;
+		SchedulePtr GetSchedule(int id, const Ice::Current &) override;
+		ScheduleList GetSchedules(const Ice::Current &) override;
+		ScheduledToRecordList GetScheduledToRecord(const Ice::Current &) override;
+		Ice::Int NewSchedule(const SchedulePtr, const Ice::Current &) override;
+		void UpdateSchedule(const SchedulePtr, const Ice::Current &) override;
+		void DoReschedule(const Ice::Current &) override;
 
 	protected:
 		static void GetEpisodeIntersects(Episodes &, Episodes &);
@@ -94,7 +93,7 @@ class SchedulesI : public Schedules, public IceTray::AbstractDatabaseClient {
 };
 
 typedef AdHoc::Factory<EpisodeGroup, const Episodes &> EpisodeGroupFactory;
-typedef boost::shared_ptr<EpisodeGroup> EpisodeGroupPtr;
+typedef std::shared_ptr<EpisodeGroup> EpisodeGroupPtr;
 }
 
 #endif
diff --git a/p2pvr/daemon/si.cpp b/p2pvr/daemon/si.cpp
index f8a49be..b87c127 100644
--- a/p2pvr/daemon/si.cpp
+++ b/p2pvr/daemon/si.cpp
@@ -2,7 +2,8 @@
 #include <slicer/db/sqlSelectDeserializer.h>
 #include <slicer/common.h>
 #include <slicer/db/sqlExceptions.h>
-#include "commonHelpers.h"
+#include "chronoHelpers.h"
+#include "icetraySupport.h"
 #include <slicer/slicer.h>
 #include <logger.h>
 
@@ -21,10 +22,13 @@
 #include "sql/si/eventsInRange.sql.h"
 #include "sql/si/eventSearch.sql.h"
 
+using namespace std::literals;
+using namespace IceTray::Logging;
+
 namespace P2PVR {
 IceTray::Logging::LoggerPtr SII::logger(LOGMANAGER()->getLogger<SII>());
 
-SII::SII(IceTray::DatabasePoolPtr db) :
+SII::SII(DB::ConnectionPoolPtr db) :
 	IceTray::AbstractDatabaseClient(db)
 {
 }
@@ -32,16 +36,16 @@ SII::SII(IceTray::DatabasePoolPtr db) :
 DVBSI::Networks
 SII::GetNetworks(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<DVBSI::Networks>(sql::si::allNetworks);
 }
 
 Deliveries
 SII::GetAllDeliveries(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
-	auto rtn = fetch<Deliveries>("delivery_type", sql::si::allDeliveries);
-	logger->messagebf(LOG::DEBUG, "%s: Found %d delivery methods", __PRETTY_FUNCTION__, rtn.size());
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
+	auto rtn = fetch<Deliveries>("delivery_type"s, sql::si::allDeliveries);
+	logger->messagebf(LogLevel::DEBUG, "%s: Found %d delivery methods", __PRETTY_FUNCTION__, rtn.size());
 	return rtn;
 }
 
@@ -49,8 +53,8 @@ DVBSI::DeliveryPtr
 SII::GetDeliveryForTransport(int id, const Ice::Current&)
 {
 	try {
-		logger->messagef(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
-		return fetch<DVBSI::DeliveryPtr>("delivery_type", sql::si::deliveryForTransport, id);
+		logger->messagef(LogLevel::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
+		return fetch<DVBSI::DeliveryPtr>("delivery_type"s, sql::si::deliveryForTransport, id);
 	}
 	catch (const Slicer::NoRowsReturned &) {
 		throw NotFound();
@@ -61,8 +65,8 @@ DVBSI::DeliveryPtr
 SII::GetDeliveryForSi(const Ice::Current&)
 {
 	try {
-		logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
-		return fetch<DVBSI::DeliveryPtr>("delivery_type", sql::si::serviceNextUsed);
+		logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
+		return fetch<DVBSI::DeliveryPtr>("delivery_type"s, sql::si::serviceNextUsed);
 	}
 	catch (const Slicer::NoRowsReturned &) {
 		return NULL;
@@ -73,8 +77,8 @@ DVBSI::DeliveryPtr
 SII::GetDeliveryForService(int id, const Ice::Current&)
 {
 	try {
-		logger->messagef(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
-		return fetch<DVBSI::DeliveryPtr>("delivery_type", sql::si::deliveryForService, id);
+		logger->messagef(LogLevel::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
+		return fetch<DVBSI::DeliveryPtr>("delivery_type"s, sql::si::deliveryForService, id);
 	}
 	catch (const Slicer::NoRowsReturned &) {
 		throw NotFound();
@@ -84,23 +88,23 @@ SII::GetDeliveryForService(int id, const Ice::Current&)
 DVBSI::ServiceList
 SII::GetServices(const Ice::Current&)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<DVBSI::ServiceList>(sql::si::servicesSelectAll);
 }
 
 DVBSI::ServicePtr
 SII::GetService(int id, const Ice::Current&)
 {
-	logger->messagef(LOG::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
+	logger->messagef(LogLevel::DEBUG, "%s(%d)", __PRETTY_FUNCTION__, id);
 	auto rtn = fetch<DVBSI::ServiceList>(sql::si::servicesSelectById, id);
 	if (rtn.empty()) throw NotFound();
 	return rtn.front();
 }
 
 Events
-SII::GetEvents(const IntSequence & eventUids, const Ice::Current &)
+SII::GetEvents(const IntSequence eventUids, const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	Events rtn;
 	for (const auto & uid : eventUids) {
 		auto list = fetch<Events>(sql::si::eventByUid, uid);
@@ -113,7 +117,7 @@ SII::GetEvents(const IntSequence & eventUids, const Ice::Current &)
 EventPtr
 SII::GetEvent(int serviceId, int eventId, const Ice::Current &)
 {
-	logger->messagef(LOG::DEBUG, "%s(s=%d, e=%d)", __PRETTY_FUNCTION__, serviceId, eventId);
+	logger->messagef(LogLevel::DEBUG, "%s(s=%d, e=%d)", __PRETTY_FUNCTION__, serviceId, eventId);
 	auto rtn = fetch<Events>(sql::si::eventById, serviceId, eventId);
 	if (rtn.empty()) throw NotFound();
 	return rtn.front();
@@ -122,21 +126,21 @@ SII::GetEvent(int serviceId, int eventId, const Ice::Current &)
 Events
 SII::EventsOnNow(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<Events>(sql::si::eventsOnNow);
 }
 
 Events
-SII::EventsInRange(const Common::DateTime & from, const Common::DateTime & to, const Ice::Current &)
+SII::EventsInRange(const Chrono::DateTime from, const Chrono::DateTime to, const Ice::Current &)
 {
-	logger->messagebf(LOG::DEBUG, "%s([%s]-[%s])", from, to, __PRETTY_FUNCTION__);
+	logger->messagebf(LogLevel::DEBUG, "%s([%s]-[%s])", from, to, __PRETTY_FUNCTION__);
 	return fetch<Events>(sql::si::eventsInRange, from, to);
 }
 
 Events
-SII::EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil::Optional<Ice::Int> & serviceId, const IceUtil::Optional<Common::DateTime> & from, const IceUtil::Optional<Common::DateTime> & to, const Ice::Current &)
+SII::EventSearch(const IceUtil::Optional<std::string> keywords, const IceUtil::Optional<Ice::Int> serviceId, const IceUtil::Optional<Chrono::DateTime> from, const IceUtil::Optional<Chrono::DateTime> to, const Ice::Current &)
 {
-	logger->messagebf(LOG::DEBUG, "%s(keywords=%s,serviceId=%s,from=%s,to=%s)",
+	logger->messagebf(LogLevel::DEBUG, "%s(keywords=%s,serviceId=%s,from=%s,to=%s)",
 			keywords, serviceId, from, to, __PRETTY_FUNCTION__);
 	return fetch<Events>(sql::si::eventSearch, from, to, serviceId, serviceId, keywords, keywords, keywords, keywords);
 }
@@ -144,14 +148,14 @@ SII::EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil:
 Events
 SII::EventsInSchedules(const Ice::Current &)
 {
-	logger->message(LOG::DEBUG, __PRETTY_FUNCTION__);
+	logger->message(LogLevel::DEBUG, __PRETTY_FUNCTION__);
 	return fetch<Events>(sql::si::eventsInSchedules);
 }
 
 Events
 SII::EventsInSchedule(int scheduleId, const Ice::Current &)
 {
-	logger->messagebf(LOG::DEBUG, "%s(%d)", scheduleId, __PRETTY_FUNCTION__);
+	logger->messagebf(LogLevel::DEBUG, "%s(%d)", scheduleId, __PRETTY_FUNCTION__);
 	return fetch<Events>(sql::si::eventsInSchedule, scheduleId);
 }
 }
diff --git a/p2pvr/daemon/si.h b/p2pvr/daemon/si.h
index 820118d..e184779 100644
--- a/p2pvr/daemon/si.h
+++ b/p2pvr/daemon/si.h
@@ -8,24 +8,24 @@
 namespace P2PVR {
 class SII : public SI, public IceTray::AbstractDatabaseClient {
 	public:
-		SII(IceTray::DatabasePoolPtr);
-
-		DVBSI::Networks GetNetworks(const Ice::Current &);
-		Deliveries GetAllDeliveries(const Ice::Current &);
-		DVBSI::DeliveryPtr GetDeliveryForService(int id, const Ice::Current &);
-		DVBSI::DeliveryPtr GetDeliveryForTransport(int id, const Ice::Current &);
-		DVBSI::DeliveryPtr GetDeliveryForSi(const Ice::Current &);
-
-		DVBSI::ServiceList GetServices(const Ice::Current &);
-		DVBSI::ServicePtr GetService(int id, const Ice::Current &);
-
-		Events GetEvents(const IntSequence & eventUids, const Ice::Current &);
-		EventPtr GetEvent(int serviceId, int eventId, const Ice::Current &);
-		Events EventsOnNow(const Ice::Current &);
-		Events EventsInSchedules(const Ice::Current &);
-		Events EventsInSchedule(int scheduleId, const Ice::Current &);
-		Events EventsInRange(const Common::DateTime &, const Common::DateTime &, const Ice::Current &);
-		Events EventSearch(const IceUtil::Optional<std::string> & keywords, const IceUtil::Optional<Ice::Int> & serviceId, const IceUtil::Optional<Common::DateTime> & from, const IceUtil::Optional<Common::DateTime> & to, const Ice::Current &);
+		SII(DB::ConnectionPoolPtr);
+
+		DVBSI::Networks GetNetworks(const Ice::Current &) override;
+		Deliveries GetAllDeliveries(const Ice::Current &) override;
+		DVBSI::DeliveryPtr GetDeliveryForService(int id, const Ice::Current &) override;
+		DVBSI::DeliveryPtr GetDeliveryForTransport(int id, const Ice::Current &) override;
+		DVBSI::DeliveryPtr GetDeliveryForSi(const Ice::Current &) override;
+
+		DVBSI::ServiceList GetServices(const Ice::Current &) override;
+		DVBSI::ServicePtr GetService(int id, const Ice::Current &) override;
+
+		Events GetEvents(const IntSequence eventUids, const Ice::Current &) override;
+		EventPtr GetEvent(int serviceId, int eventId, const Ice::Current &) override;
+		Events EventsOnNow(const Ice::Current &) override;
+		Events EventsInSchedules(const Ice::Current &) override;
+		Events EventsInSchedule(int scheduleId, const Ice::Current &) override;
+		Events EventsInRange(const Chrono::DateTime, const Chrono::DateTime, const Ice::Current &) override;
+		Events EventSearch(const IceUtil::Optional<std::string> keywords, const IceUtil::Optional<Ice::Int> serviceId, const IceUtil::Optional<Chrono::DateTime> from, const IceUtil::Optional<Chrono::DateTime> to, const Ice::Current &) override;
 
 		static IceTray::Logging::LoggerPtr logger;
 };
diff --git a/p2pvr/daemon/storage.cpp b/p2pvr/daemon/storage.cpp
index ba5d931..d53adf1 100644
--- a/p2pvr/daemon/storage.cpp
+++ b/p2pvr/daemon/storage.cpp
@@ -1,6 +1,7 @@
 #include "storage.h"
 #include "muxer.h"
 #include <logger.h>
+#include <modifycommand.h>
 #include <sql/storage/getVideoStats.sql.h>
 #include <sql/storage/writeBlock.sql.h>
 
@@ -28,7 +29,7 @@ class RecordingSink : public RawDataClient {
 			ins->bindParamI(0, recordingId);
 		}
 
-		bool NewData(const Data & data, const Ice::Current &) override
+		bool NewData(const Data data, const Ice::Current &) override
 		{
 			if (!data.empty()) {
 				ins->bindParamBLOB(1, data);
@@ -42,25 +43,25 @@ class RecordingSink : public RawDataClient {
 		DB::ModifyCommandPtr ins;
 };
 
-StorageI::StorageI(IceTray::DatabasePoolPtr db) :
+StorageI::StorageI(DB::ConnectionPoolPtr db) :
 	IceTray::AbstractDatabaseClient(db)
 {
 }
 
-RawDataClientPrx
+RawDataClientPrxPtr
 StorageI::OpenForWrite(Ice::Int recordingId, const Ice::Current & ice)
 {
-	auto target = RawDataClientPrx::uncheckedCast(ice.adapter->addWithUUID(new RecordingSink(db->get(), recordingId)));
+	auto target = Ice::uncheckedCast<RawDataClientPrx>(ice.adapter->addWithUUID(std::make_shared<RecordingSink>(db->get(), recordingId)));
 	if (!options->muxerCommand.empty()) {
 		auto storageId = target->ice_getIdentity();
-		target = RawDataClientPrx::uncheckedCast(ice.adapter->addWithUUID(new Muxer(target, options->muxerCommand)));
+		target = Ice::uncheckedCast<RawDataClientPrx>(ice.adapter->addWithUUID(std::make_shared<Muxer>(target, options->muxerCommand)));
 		muxerStorageLink.insert({ target->ice_getIdentity(), storageId });
 	}
 	return target;
 }
 
 void
-StorageI::Close(const RawDataClientPrx & file, const Ice::Current & ice)
+StorageI::Close(const RawDataClientPrxPtr file, const Ice::Current & ice)
 {
 	ice.adapter->remove(file->ice_getIdentity());
 	auto storageIdItr = muxerStorageLink.find(file->ice_getIdentity());
diff --git a/p2pvr/daemon/storage.h b/p2pvr/daemon/storage.h
index 3dae5d4..c9c984d 100644
--- a/p2pvr/daemon/storage.h
+++ b/p2pvr/daemon/storage.h
@@ -23,10 +23,10 @@ class StorageI : public Storage, IceTray::AbstractDatabaseClient {
 				std::string muxerCommand;
 		};
 
-		StorageI(IceTray::DatabasePoolPtr db);
+		StorageI(DB::ConnectionPoolPtr db);
 
-		RawDataClientPrx OpenForWrite(Ice::Int recordingId, const Ice::Current &) override;
-		void Close(const RawDataClientPrx &, const Ice::Current &) override;
+		RawDataClientPrxPtr OpenForWrite(Ice::Int recordingId, const Ice::Current &) override;
+		void Close(const RawDataClientPrxPtr, const Ice::Current &) override;
 		VideoStats GetVideoStats(Ice::Int recordingId, const Ice::Current &) override;
 
 	protected:
diff --git a/p2pvr/daemon/unittests/Jamfile.jam b/p2pvr/daemon/unittests/Jamfile.jam
index 4426646..8c25c07 100644
--- a/p2pvr/daemon/unittests/Jamfile.jam
+++ b/p2pvr/daemon/unittests/Jamfile.jam
@@ -2,9 +2,8 @@ import testing ;
 
 lib boost_system ;
 lib boost_filesystem ;
-lib IceUtil ;
-lib Ice ;
-lib IceBox ;
+lib Ice : : <name>Ice++11 ;
+lib IceBox : : <name>IceBox++11 ;
 lib dbppcore : : : : <include>/usr/include/dbpp ;
 lib dbpp-postgresql : : : : <include>/usr/include/dbpp-postgresql ;
 lib dryice : : : : <include>/usr/include/icetray ;
@@ -36,7 +35,6 @@ lib testCommon :
 	<library>dryice
 	<library>icetray
 	<library>Ice
-	<library>IceUtil
 	<library>IceBox
 	<library>dbppcore
 	<library>dbpp-postgresql
@@ -56,7 +54,6 @@ lib testCommon :
 	<library>dbpp-postgresql
 	<library>Ice
 	<library>IceBox
-	<library>IceUtil
 	<library>boost_system
 	<library>boost_filesystem
 	<library>../..//boost_utf
diff --git a/p2pvr/daemon/unittests/mockDefs.cpp b/p2pvr/daemon/unittests/mockDefs.cpp
index 6d180e5..adf2608 100644
--- a/p2pvr/daemon/unittests/mockDefs.cpp
+++ b/p2pvr/daemon/unittests/mockDefs.cpp
@@ -4,25 +4,28 @@
 namespace P2PVR {
 namespace Testing {
 SchemaOnlyMockDatabase::SchemaOnlyMockDatabase(const Ice::StringSeq & opts) :
-	PQ::Mock("user=postgres dbname=postgres", "p2pvr", {
-			rootDir.parent_path().parent_path() / "datasources" / "schema.sql" }),
+	DB::PluginMock<PQ::Mock>("p2pvr", {
+			rootDir.parent_path().parent_path() / "datasources" / "schema.sql" },
+			"user=postgres dbname=postgres"),
 	IceTray::DryIce(opts)
 {
 }
 
 StandardMockDatabase::StandardMockDatabase(const Ice::StringSeq & opts) :
-	PQ::Mock("user=postgres dbname=postgres", "p2pvr", {
+	DB::PluginMock<PQ::Mock>("p2pvr", {
 			rootDir.parent_path().parent_path() / "datasources/schema.sql",
-			rootDir / "datasources" / "data.sql" }),
+			rootDir / "datasources" / "data.sql" },
+			"user=postgres dbname=postgres"),
 	IceTray::DryIce(opts)
 {
 }
 
 StandardMockDatabasePlusOffset::StandardMockDatabasePlusOffset(const Ice::StringSeq & opts) :
-	PQ::Mock("user=postgres dbname=postgres", "p2pvr", {
+	DB::PluginMock<PQ::Mock>("p2pvr", {
 			rootDir.parent_path().parent_path() / "datasources" / "schema.sql",
 			rootDir / "datasources" / "data.sql",
-			rootDir / "datasources" / "eventOffset.sql" }),
+			rootDir / "datasources" / "eventOffset.sql" },
+			"user=postgres dbname=postgres"),
 	IceTray::DryIce(opts)
 {
 }
diff --git a/p2pvr/daemon/unittests/mockDefs.h b/p2pvr/daemon/unittests/mockDefs.h
index 1589440..c226a42 100644
--- a/p2pvr/daemon/unittests/mockDefs.h
+++ b/p2pvr/daemon/unittests/mockDefs.h
@@ -8,7 +8,7 @@
 
 namespace P2PVR {
 namespace Testing {
-#define DECLAREMOCK(Name) class DLL_PUBLIC Name : public PQ::Mock, public IceTray::DryIce { public: Name(const Ice::StringSeq & opts = {}); }
+#define DECLAREMOCK(Name) class DLL_PUBLIC Name : public DB::PluginMock<PQ::Mock>, public IceTray::DryIce { public: Name(const Ice::StringSeq & opts = {}); }
 
 DECLAREMOCK(SchemaOnlyMockDatabase);
 DECLAREMOCK(StandardMockDatabase);
@@ -20,13 +20,13 @@ class DLL_PUBLIC TestClient : public IceTray::DryIceClient {
 	public:
 		TestClient();
 
-		TunersPrx devices;
-		MaintenancePrx maint;
-		SIPrx si;
-		SchedulesPrx schedules;
-		StoragePrx storage;
-		RecorderPrx recorder;
-		RecordingsPrx recordings;
+		TunersPrxPtr devices;
+		MaintenancePrxPtr maint;
+		SIPrxPtr si;
+		SchedulesPrxPtr schedules;
+		StoragePrxPtr storage;
+		RecorderPrxPtr recorder;
+		RecordingsPrxPtr recordings;
 };
 }
 }
diff --git a/p2pvr/daemon/unittests/mockDevices.cpp b/p2pvr/daemon/unittests/mockDevices.cpp
index e5ec6a4..135664f 100644
--- a/p2pvr/daemon/unittests/mockDevices.cpp
+++ b/p2pvr/daemon/unittests/mockDevices.cpp
@@ -13,7 +13,7 @@ namespace P2PVR {
 		TunerPtr
 		MockDevices::openTuner(const boost::filesystem::path & path) const
 		{
-			return new P2PVR::DVB::Testing::MockTuner(path, ic);
+			return std::make_shared<P2PVR::DVB::Testing::MockTuner>(path, ic);
 		}
 	}
 }
diff --git a/p2pvr/daemon/unittests/mockScheduler.cpp b/p2pvr/daemon/unittests/mockScheduler.cpp
index b19673c..3f5ee99 100644
--- a/p2pvr/daemon/unittests/mockScheduler.cpp
+++ b/p2pvr/daemon/unittests/mockScheduler.cpp
@@ -31,13 +31,13 @@ MockScheduler::GetScheduledToRecord(const::Ice::Current &)
 }
 
 Ice::Int
-MockScheduler::NewSchedule(const::P2PVR::SchedulePtr &, const::Ice::Current &)
+MockScheduler::NewSchedule(const::P2PVR::SchedulePtr, const::Ice::Current &)
 {
 	return 1;
 }
 
 void
-MockScheduler::UpdateSchedule(const::P2PVR::SchedulePtr &, const::Ice::Current &)
+MockScheduler::UpdateSchedule(const::P2PVR::SchedulePtr, const::Ice::Current &)
 {
 }
 }
diff --git a/p2pvr/daemon/unittests/mockScheduler.h b/p2pvr/daemon/unittests/mockScheduler.h
index f718363..d94f502 100644
--- a/p2pvr/daemon/unittests/mockScheduler.h
+++ b/p2pvr/daemon/unittests/mockScheduler.h
@@ -13,8 +13,8 @@ class DLL_PUBLIC MockScheduler : public Schedules {
 		SchedulePtr GetSchedule(::Ice::Int, const ::Ice::Current&) override;
 		ScheduleList GetSchedules(const ::Ice::Current&) override;
 		ScheduledToRecordList GetScheduledToRecord(const ::Ice::Current&) override;
-		Ice::Int NewSchedule(const SchedulePtr&, const ::Ice::Current&) override;
-		void UpdateSchedule(const SchedulePtr&, const ::Ice::Current&) override;
+		Ice::Int NewSchedule(const SchedulePtr, const ::Ice::Current&) override;
+		void UpdateSchedule(const SchedulePtr, const ::Ice::Current&) override;
 };
 }
 }
diff --git a/p2pvr/daemon/unittests/testErrorHandling.cpp b/p2pvr/daemon/unittests/testErrorHandling.cpp
index be44ebc..e38ac8e 100644
--- a/p2pvr/daemon/unittests/testErrorHandling.cpp
+++ b/p2pvr/daemon/unittests/testErrorHandling.cpp
@@ -26,7 +26,7 @@ class Core : public StandardMockDatabase {
 	public:
 		Core()
 		{
-			replace("Devices", new MockDevices(ic));
+			replace("Devices", std::make_shared<MockDevices>(ic));
 		}
 };
 
@@ -36,7 +36,7 @@ class TestDataClient : public RawDataClient {
 			packets(3)
 		{
 		}
-		virtual bool NewData(const Data &, const Ice::Current &) override
+		virtual bool NewData(const Data, const Ice::Current &) override
 		{
 			return !--packets;
 		}
@@ -45,7 +45,7 @@ class TestDataClient : public RawDataClient {
 
 class FailingTestClient : public RawDataClient {
 	public:
-		bool NewData(const Data &, const Ice::Current &) override
+		bool NewData(const Data, const Ice::Current &) override
 		{
 			throw DataHandlingException();
 		}
@@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE(TestRawDataClient)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new TestDataClient());
+	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), std::make_shared<TestDataClient>());
 	BOOST_TEST_CHECKPOINT("Make successful call");
 	devices->SendNetworkInformation(del, a);
 }
@@ -94,7 +94,7 @@ BOOST_AUTO_TEST_CASE(TestParser)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new TestNetworkParser());
+	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), std::make_shared<TestNetworkParser>());
 	BOOST_TEST_CHECKPOINT("Make successful call");
 	devices->SendNetworkInformation(del, a);
 }
@@ -103,7 +103,7 @@ BOOST_AUTO_TEST_CASE(TestRawDataClientWithError)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new FailingTestClient());
+	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), std::make_shared<FailingTestClient>());
 	BOOST_TEST_CHECKPOINT("Make failing call");
 	BOOST_REQUIRE_THROW(devices->SendNetworkInformation(del, a), DataHandlingException);
 }
@@ -112,7 +112,7 @@ BOOST_AUTO_TEST_CASE(TestParserWithError)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new FailingTestNetworkParser());
+	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), std::make_shared<FailingTestNetworkParser>());
 	BOOST_TEST_CHECKPOINT("Make failing call");
 	BOOST_REQUIRE_THROW(devices->SendNetworkInformation(del, a), DataHandlingException);
 }
@@ -121,7 +121,7 @@ BOOST_AUTO_TEST_CASE(TestParserBroken)
 {
 	BOOST_TEST_CHECKPOINT("Setup");
 	auto del = si->GetDeliveryForSi();
-	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), new BrokenTestNetworkParser());
+	TemporaryIceAdapterObject<RawDataClient> a(getAdapter(), std::make_shared<BrokenTestNetworkParser>());
 	BOOST_TEST_CHECKPOINT("Make failing call");
 	BOOST_REQUIRE_THROW(devices->SendNetworkInformation(del, a), Ice::UnknownException);
 }
diff --git a/p2pvr/daemon/unittests/testMaint.cpp b/p2pvr/daemon/unittests/testMaint.cpp
index c15dee3..feb5153 100644
--- a/p2pvr/daemon/unittests/testMaint.cpp
+++ b/p2pvr/daemon/unittests/testMaint.cpp
@@ -7,6 +7,7 @@
 #include <Ice/Service.h>
 #include <maintenance.h>
 #include <mockTuner.h>
+#include <modifycommand.h>
 #include "mockDevices.h"
 #include "mockScheduler.h"
 #include <si.h>
@@ -15,11 +16,13 @@
 #include <definedDirs.h>
 #include "mockDefs.h"
 #include <slicer/db/sqlSelectDeserializer.h>
-#include "commonHelpers.h"
+#include "chronoHelpers.h"
+#include "icetraySupport.h"
 #include <slicer/slicer.h>
 
 using namespace P2PVR;
 using namespace P2PVR::Testing;
+using namespace std::literals;
 
 namespace P2PVR {
 namespace Testing {
@@ -27,8 +30,8 @@ class TestService : public SchemaOnlyMockDatabase {
 	public:
 		TestService()
 		{
-			replace("Devices", new MockDevices(ic));
-			replace("Schedules", new MockScheduler());
+			replace("Devices", std::make_shared<MockDevices>(ic));
+			replace("Schedules", std::make_shared<MockScheduler>());
 		}
 };
 }
@@ -101,7 +104,8 @@ BOOST_AUTO_TEST_CASE( GetNetworks )
 	auto ns = si->GetNetworks();
 	BOOST_REQUIRE_EQUAL(ns.size(), 1);
 	BOOST_REQUIRE_EQUAL(ns[0]->NetworkId, 12333);
-	BOOST_REQUIRE_EQUAL(ns[0]->Name, "Yorkshire");
+	BOOST_REQUIRE(ns[0]->Name);
+	BOOST_REQUIRE_EQUAL(*ns[0]->Name, "Yorkshire");
 }
 
 BOOST_AUTO_TEST_CASE( GetDeliveryForService )
@@ -167,8 +171,10 @@ BOOST_AUTO_TEST_CASE( GetServices )
 	BOOST_REQUIRE_EQUAL(services.size(), 180);
 	BOOST_REQUIRE_EQUAL(services[0]->ServiceId, 4170);
 	BOOST_REQUIRE_EQUAL(services[0]->TransportStreamId, 4170);
-	BOOST_REQUIRE_EQUAL(services[0]->Name, "BBC ONE Yorks");
-	BOOST_REQUIRE_EQUAL(services[0]->DefaultAuthority, "fp.bbc.co.uk");
+	BOOST_REQUIRE(services[0]->Name);
+	BOOST_REQUIRE_EQUAL(*services[0]->Name, "BBC ONE Yorks");
+	BOOST_REQUIRE(services[0]->DefaultAuthority);
+	BOOST_REQUIRE_EQUAL(*services[0]->DefaultAuthority, "fp.bbc.co.uk");
 }
 
 BOOST_AUTO_TEST_CASE( GetService )
@@ -176,8 +182,10 @@ BOOST_AUTO_TEST_CASE( GetService )
 	auto service = si->GetService(serviceId);
 	BOOST_REQUIRE_EQUAL(service->ServiceId, serviceId);
 	BOOST_REQUIRE_EQUAL(service->TransportStreamId, 4170);
-	BOOST_REQUIRE_EQUAL(service->Name, "BBC ONE Yorks");
-	BOOST_REQUIRE_EQUAL(service->DefaultAuthority, "fp.bbc.co.uk");
+	BOOST_REQUIRE(service->Name);
+	BOOST_REQUIRE_EQUAL(*service->Name, "BBC ONE Yorks");
+	BOOST_REQUIRE(service->DefaultAuthority);
+	BOOST_REQUIRE_EQUAL(*service->DefaultAuthority, "fp.bbc.co.uk");
 }
 
 BOOST_AUTO_TEST_CASE( update_events )
@@ -188,8 +196,8 @@ BOOST_AUTO_TEST_CASE( update_events )
 	BOOST_TEST_CHECKPOINT("Write first events");
 	P2PVR::DVB::Testing::MockTuner::SetEventsSet(0);
 	maint->UpdateEvents();
-	auto dayOneEvents = si->EventSearch(IceUtil::Optional<std::string>(), IceUtil::Optional<int>(),
-			Common::DateTime {2017, 8, 22, 3, 0}, Common::DateTime {2017, 8, 23, 3, 0});
+	auto dayOneEvents = si->EventSearch(Ice::optional<std::string>(), Ice::optional<int>(),
+			Chrono::DateTime {2017, 8, 22, 3, 0}, Chrono::DateTime {2017, 8, 23, 3, 0});
 	BOOST_REQUIRE_EQUAL(dayOneEvents.size(), 3023);
 	BOOST_REQUIRE(si->GetEvent(15048, 29747));
 	BOOST_REQUIRE_THROW(si->GetEvent(15856, 3591), P2PVR::NotFound);
@@ -198,34 +206,32 @@ BOOST_AUTO_TEST_CASE( update_events )
 	auto keyEvent1 = dayOneEvents[1000];
 	auto keyEvent2 = dayOneEvents[2000];
 	db->execute("INSERT INTO schedules(repeats) VALUES(false)");
-	auto irecorded = boost::shared_ptr<DB::ModifyCommand>(
-			db->newModifyCommand("INSERT INTO recorded(scheduleId, eventUid) VALUES(?, ?)"));
+	auto irecorded = db->modify("INSERT INTO recorded(scheduleId, eventUid) VALUES(?, ?)");
 	irecorded->bindParamI(0, 1);
 	irecorded->bindParamI(1, keyEvent1->EventUid);
 	irecorded->execute();
-	auto irecordings = boost::shared_ptr<DB::ModifyCommand>(
-			db->newModifyCommand("INSERT INTO recordings(scheduleId, eventUid) VALUES(?, ?)"));
+	auto irecordings = db->modify("INSERT INTO recordings(scheduleId, eventUid) VALUES(?, ?)");
 	irecordings->bindParamI(0, 1);
 	irecordings->bindParamI(1, keyEvent2->EventUid);
 	irecordings->execute();
 	BOOST_REQUIRE(keyEvent1);
 	BOOST_REQUIRE(keyEvent2);
 	BOOST_REQUIRE(keyEvent1->Current);
-	BOOST_REQUIRE_EQUAL(keyEvent1->StartTime, Common::DateTime({2017, 8, 22, 5, 0}));
+	BOOST_REQUIRE_EQUAL(keyEvent1->StartTime, Chrono::DateTime({2017, 8, 22, 5, 0}));
 	BOOST_REQUIRE(keyEvent2->Current);
-	BOOST_REQUIRE_EQUAL(keyEvent2->StartTime, Common::DateTime({2017, 8, 22, 6, 30}));
+	BOOST_REQUIRE_EQUAL(keyEvent2->StartTime, Chrono::DateTime({2017, 8, 22, 6, 30}));
 
 	BOOST_TEST_CHECKPOINT("Write second events");
 	P2PVR::DVB::Testing::MockTuner::SetEventsSet(1);
 	maint->UpdateEvents();
-	auto dayTwoEvents = si->EventSearch(IceUtil::Optional<std::string>(), IceUtil::Optional<int>(),
-			Common::DateTime {2017, 8, 23, 3, 0}, Common::DateTime {2017, 8, 24, 3, 0});
+	auto dayTwoEvents = si->EventSearch(Ice::optional<std::string>(), Ice::optional<int>(),
+			Chrono::DateTime {2017, 8, 23, 3, 0}, Chrono::DateTime {2017, 8, 24, 3, 0});
 	BOOST_REQUIRE_THROW(si->GetEvent(15064, 22), P2PVR::NotFound);
 	BOOST_REQUIRE(si->GetEvent(15048, 29791));
 
 	BOOST_TEST_CHECKPOINT("Check our faked stuff is still there and right");
-	auto dayOneEventsOnDayTwo = si->EventSearch(IceUtil::Optional<std::string>(), IceUtil::Optional<int>(),
-			Common::DateTime {2017, 8, 22, 3, 0}, Common::DateTime {2017, 8, 23, 3, 0});
+	auto dayOneEventsOnDayTwo = si->EventSearch(Ice::optional<std::string>(), Ice::optional<int>(),
+			Chrono::DateTime {2017, 8, 22, 3, 0}, Chrono::DateTime {2017, 8, 23, 3, 0});
 	// Some datetime range overlap, but most are gone
 	BOOST_REQUIRE_EQUAL(dayOneEventsOnDayTwo.size(), 316);
 	BOOST_REQUIRE_EQUAL(std::count_if(dayOneEventsOnDayTwo.begin(), dayOneEventsOnDayTwo.end(),
@@ -243,8 +249,8 @@ BOOST_AUTO_TEST_CASE( update_events )
 
 BOOST_AUTO_TEST_CASE( test_titleFiltering )
 {
-	auto thingsWithNew = si->EventSearch("new", IceUtil::Optional<int>(),
-			IceUtil::Optional<Common::DateTime>(), IceUtil::Optional<Common::DateTime>());
+	auto thingsWithNew = si->EventSearch("new"s, Ice::optional<int>(),
+			Ice::optional<Chrono::DateTime>(), Ice::optional<Chrono::DateTime>());
 	BOOST_REQUIRE_EQUAL(0, std::count_if(thingsWithNew.begin(), thingsWithNew.end(), [](auto e) {
 			return boost::algorithm::starts_with(e->Title, "New:");
 		}));
diff --git a/p2pvr/daemon/unittests/testRecording.cpp b/p2pvr/daemon/unittests/testRecording.cpp
index d875130..533859a 100644
--- a/p2pvr/daemon/unittests/testRecording.cpp
+++ b/p2pvr/daemon/unittests/testRecording.cpp
@@ -14,7 +14,7 @@
 #include <definedDirs.h>
 #include "mockDefs.h"
 #include <slicer/db/sqlSelectDeserializer.h>
-#include "commonHelpers.h"
+#include "chronoHelpers.h"
 #include "serviceStreamer.h"
 #include "temporaryIceAdapterObject.h"
 #include <slicer/slicer.h>
@@ -28,8 +28,8 @@ class TestService : public StandardMockDatabase {
 	public:
 		TestService()
 		{
-			replace("Devices", new MockDevices(ic));
-			replace("Schedules", new MockScheduler());
+			replace("Devices", std::make_shared<MockDevices>(ic));
+			replace("Schedules", std::make_shared<MockScheduler>());
 		}
 };
 
@@ -37,7 +37,7 @@ class MockTarget : public RawDataClient {
 	public:
 		MockTarget() : bytesReceived(0) { }
 
-		bool NewData(const Data & data, const Ice::Current &) override
+		bool NewData(const Data data, const Ice::Current &) override
 		{
 			bytesReceived += data.size();
 			return false;
@@ -55,11 +55,11 @@ BOOST_FIXTURE_TEST_SUITE( RecordingCore, TestClient );
 BOOST_AUTO_TEST_CASE( streamServiceToTarget )
 {
 	BOOST_TEST_CHECKPOINT("Create mock target");
-	IceUtil::Handle<MockTarget> target = new MockTarget();
+	auto target = std::make_shared<MockTarget>();
 	TemporaryIceAdapterObject<RawDataClient> targetPrx(getAdapter(), target);
 
 	BOOST_TEST_CHECKPOINT("Create service streamer");
-	auto ss = ServiceStreamerPtr(new ServiceStreamer(4170, targetPrx, devices, si, getAdapter()));
+	auto ss = std::make_shared<ServiceStreamer>(4170, targetPrx, devices, si, getAdapter());
 
 	BOOST_TEST_CHECKPOINT("Start");
 	ss->Start();
diff --git a/p2pvr/daemon/unittests/testSched.cpp b/p2pvr/daemon/unittests/testSched.cpp
index 18e375c..8450a4c 100644
--- a/p2pvr/daemon/unittests/testSched.cpp
+++ b/p2pvr/daemon/unittests/testSched.cpp
@@ -14,11 +14,12 @@
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid_io.hpp>
 #include <boost/lexical_cast.hpp>
-#include <commonHelpers.h>
+#include <chronoHelpers.h>
 #include "mockDefs.h"
 
 using namespace P2PVR;
 using namespace P2PVR::Testing;
+using namespace std::literals;
 
 namespace P2PVR {
 namespace Testing {
@@ -26,8 +27,8 @@ class TestService : public StandardMockDatabasePlusOffset {
 	public:
 		TestService()
 		{
-			replace("Devices", new MockDevices(ic));
-			replace("Recorder", new MockRecorder());
+			replace("Devices", std::make_shared<MockDevices>(ic));
+			replace("Recorder", std::make_shared<MockRecorder>());
 		}
 };
 }
@@ -60,8 +61,8 @@ BOOST_AUTO_TEST_CASE( sc_getScheduled )
 
 BOOST_AUTO_TEST_CASE( sc_crud )
 {
-	P2PVR::SchedulePtr schedule = new P2PVR::Schedule();
-	schedule->Search = "Top Gear";
+	auto schedule = std::make_shared<P2PVR::Schedule>();
+	schedule->Search = "Top Gear"s;
 
 	schedule->ScheduleId = schedules->NewSchedule(schedule);
 	BOOST_REQUIRE_EQUAL(187, schedule->ScheduleId);
@@ -74,7 +75,7 @@ BOOST_AUTO_TEST_CASE( sc_crud )
 	BOOST_REQUIRE_EQUAL(schedule->Early, fetched->Early);
 	BOOST_REQUIRE_EQUAL(schedule->Late, fetched->Late);
 
-	schedule->Search = "Top Gear Special";
+	schedule->Search = "Top Gear Special"s;
 	schedule->Early.Minutes = 5;
 	schedule->Late.Minutes = 15;
 	schedules->UpdateSchedule(schedule);
diff --git a/p2pvr/daemon/unittests/testSi.cpp b/p2pvr/daemon/unittests/testSi.cpp
index 73f92f3..a894155 100644
--- a/p2pvr/daemon/unittests/testSi.cpp
+++ b/p2pvr/daemon/unittests/testSi.cpp
@@ -13,9 +13,11 @@
 #include <boost/uuid/uuid_io.hpp>
 #include <boost/lexical_cast.hpp>
 #include "mockDefs.h"
+#include "icetraySupport.h"
 
 using namespace P2PVR;
 using namespace P2PVR::Testing;
+using namespace std::literals;
 
 BOOST_GLOBAL_FIXTURE( StandardMockDatabase );
 
@@ -68,19 +70,19 @@ BOOST_AUTO_TEST_CASE( si_getEventsInScheds )
 
 BOOST_AUTO_TEST_CASE( si_getEventsInRange )
 {
-	si->EventsInRange(Common::DateTime {2014, 12, 19, 3, 0}, Common::DateTime {2014, 12, 20, 3, 0});
+	si->EventsInRange(Chrono::DateTime {2014, 12, 19, 3, 0}, Chrono::DateTime {2014, 12, 20, 3, 0});
 }
 
 BOOST_AUTO_TEST_CASE( si_getEventSearch )
 {
-	si->EventSearch("Top Gear", IceUtil::Optional< ::Ice::Int >(),
-			IceUtil::Optional<Common::DateTime>(), IceUtil::Optional<Common::DateTime>());
-	si->EventSearch("Top Gear", 22272,
-			IceUtil::Optional<Common::DateTime>(), IceUtil::Optional<Common::DateTime>());
-	si->EventSearch("Top Gear", 22272,
-			Common::DateTime {2014, 12, 19, 3, 0}, IceUtil::Optional<Common::DateTime>());
-	si->EventSearch("Top Gear", 22272,
-			Common::DateTime {2014, 12, 19, 3, 0}, Common::DateTime {2014, 12, 20, 3, 0});
+	si->EventSearch("Top Gear"s, Ice::optional< ::Ice::Int >(),
+			Ice::optional<Chrono::DateTime>(), Ice::optional<Chrono::DateTime>());
+	si->EventSearch("Top Gear"s, 22272,
+			Ice::optional<Chrono::DateTime>(), Ice::optional<Chrono::DateTime>());
+	si->EventSearch("Top Gear"s, 22272,
+			Chrono::DateTime {2014, 12, 19, 3, 0}, Ice::optional<Chrono::DateTime>());
+	si->EventSearch("Top Gear"s, 22272,
+			Chrono::DateTime {2014, 12, 19, 3, 0}, Chrono::DateTime {2014, 12, 20, 3, 0});
 }
 
 BOOST_AUTO_TEST_CASE( si_getAllDeliveries )
@@ -93,7 +95,7 @@ BOOST_AUTO_TEST_CASE( si_getDeliveryForTransport )
 {
 	auto del = si->GetDeliveryForTransport(4170);
 	BOOST_REQUIRE(del);
-	auto dvbt = DVBSI::TerrestrialDeliveryPtr::dynamicCast(del);
+	auto dvbt = std::dynamic_pointer_cast<DVBSI::TerrestrialDelivery>(del);
 	BOOST_REQUIRE(dvbt);
 	BOOST_REQUIRE_EQUAL(dvbt->TransportStreamId, 4170);
 }
@@ -102,7 +104,7 @@ BOOST_AUTO_TEST_CASE( si_getDeliveryForSI )
 {
 	auto del = si->GetDeliveryForSi();
 	BOOST_REQUIRE(del);
-	auto dvbt = DVBSI::TerrestrialDeliveryPtr::dynamicCast(del);
+	auto dvbt = std::dynamic_pointer_cast<DVBSI::TerrestrialDelivery>(del);
 	BOOST_REQUIRE(dvbt);
 }
 
@@ -110,7 +112,7 @@ BOOST_AUTO_TEST_CASE( si_getDeliveryForService )
 {
 	auto del = si->GetDeliveryForService(4170);
 	BOOST_REQUIRE(del);
-	auto dvbt = DVBSI::TerrestrialDeliveryPtr::dynamicCast(del);
+	auto dvbt = std::dynamic_pointer_cast<DVBSI::TerrestrialDelivery>(del);
 	BOOST_REQUIRE(dvbt);
 	BOOST_REQUIRE_EQUAL(dvbt->TransportStreamId, 4170);
 }
@@ -119,8 +121,10 @@ BOOST_AUTO_TEST_CASE( si_getServices )
 {
 	auto services = si->GetServices();
 	BOOST_REQUIRE_EQUAL(services.size(), 145);
-	BOOST_REQUIRE_EQUAL(services[0]->Name, "BBC ONE Yorks");
-	BOOST_REQUIRE_EQUAL(services[0]->DefaultAuthority, "fp.bbc.co.uk");
+	BOOST_REQUIRE(services[0]->Name);
+	BOOST_REQUIRE_EQUAL(*services[0]->Name, "BBC ONE Yorks");
+	BOOST_REQUIRE(services[0]->DefaultAuthority);
+	BOOST_REQUIRE_EQUAL(*services[0]->DefaultAuthority, "fp.bbc.co.uk");
 	BOOST_REQUIRE_EQUAL(services[0]->EitSchedule, true);
 	BOOST_REQUIRE_EQUAL(services[0]->EitPresentFollowing, true);
 }
@@ -128,8 +132,10 @@ BOOST_AUTO_TEST_CASE( si_getServices )
 BOOST_AUTO_TEST_CASE( si_getService )
 {
 	auto service = si->GetService(4170);
-	BOOST_REQUIRE_EQUAL(service->Name, "BBC ONE Yorks");
-	BOOST_REQUIRE_EQUAL(service->DefaultAuthority, "fp.bbc.co.uk");
+	BOOST_REQUIRE(service->Name);
+	BOOST_REQUIRE_EQUAL(*service->Name, "BBC ONE Yorks");
+	BOOST_REQUIRE(service->DefaultAuthority);
+	BOOST_REQUIRE_EQUAL(*service->DefaultAuthority, "fp.bbc.co.uk");
 	BOOST_REQUIRE_EQUAL(service->EitSchedule, true);
 	BOOST_REQUIRE_EQUAL(service->EitPresentFollowing, true);
 }
diff --git a/p2pvr/daemon/unittests/testStorage.cpp b/p2pvr/daemon/unittests/testStorage.cpp
index e7eee95..f186f4f 100644
--- a/p2pvr/daemon/unittests/testStorage.cpp
+++ b/p2pvr/daemon/unittests/testStorage.cpp
@@ -9,7 +9,7 @@
 #include <si.h>
 #include <storage.h>
 #include <boost/lexical_cast.hpp>
-#include <commonHelpers.h>
+#include <chronoHelpers.h>
 #include <definedDirs.h>
 #include "mockDefs.h"
 
@@ -37,9 +37,9 @@ BOOST_FIXTURE_TEST_SUITE( StCore, TestClient );
 
 static
 void
-runTest(RecordingsPrx recordings, StoragePrx storage)
+runTest(RecordingsPrxPtr recordings, StoragePrxPtr storage)
 {
-	auto id = recordings->NewRecording(new Recording(0, 8, 2556));
+	auto id = recordings->NewRecording(std::make_shared<Recording>(0, 8, 2556));
 	auto rdc = storage->OpenForWrite(id);
 	BOOST_REQUIRE(rdc);
 	auto stats1 = storage->GetVideoStats(id);