Fix namespace of TypeConverters

Also fix variable name warnings

10 files changed, 473 insertions, 456 deletions

diff --git a/netfs/daemon/daemonDirectory.h b/netfs/daemon/daemonDirectory.h
index 183e102..91a0bc2 100644
--- a/netfs/daemon/daemonDirectory.h
+++ b/netfs/daemon/daemonDirectory.h
@@ -4,7 +4,7 @@
 #include <dirent.h>
 #include <typeConverter.h>
 
-class DirectoryServer : public NetFS::Directory, EntryTypeConverter {
+class DirectoryServer : public NetFS::Directory, NetFS::EntryTypeConverter {
 public:
 	DirectoryServer(DIR * od, EntryTypeConverter &);
 
diff --git a/netfs/daemon/daemonFile.h b/netfs/daemon/daemonFile.h
index 282c74e..623de26 100644
--- a/netfs/daemon/daemonFile.h
+++ b/netfs/daemon/daemonFile.h
@@ -3,7 +3,7 @@
 #include <file.h>
 #include <typeConverter.h>
 
-class FileServer : public NetFS::File, EntryTypeConverter {
+class FileServer : public NetFS::File, NetFS::EntryTypeConverter {
 public:
 	FileServer(int fd, EntryTypeConverter &);
 
diff --git a/netfs/daemon/daemonVolume.h b/netfs/daemon/daemonVolume.h
index d7f7c1b..c7d6c56 100644
--- a/netfs/daemon/daemonVolume.h
+++ b/netfs/daemon/daemonVolume.h
@@ -51,5 +51,5 @@ private:
 
 	EntryResolver<User> & userLookup;
 	EntryResolver<Group> & groupLookup;
-	EntryTypeConverter converter;
+	NetFS::EntryTypeConverter converter;
 };
diff --git a/netfs/fuse/fuseApp.cpp b/netfs/fuse/fuseApp.cpp
index 5f58f28..c09a7e7 100644
--- a/netfs/fuse/fuseApp.cpp
+++ b/netfs/fuse/fuseApp.cpp
@@ -15,302 +15,306 @@
 #include <slicer/slicer.h>
 #include <uriParse.h>
 
-constexpr static unsigned short DEFAULT_PORT = 4000;
-constexpr static unsigned short DEFAULT_MAX_MESSAGE_SIZE = 1024;
-constexpr static unsigned short KILO_MULTIPLIER = 1024;
-
 namespace AdHoc {
 	template class Cache<struct stat, std::size_t>;
 	template class CallCacheable<struct stat, std::size_t>;
 }
 
-NetFS::FuseApp::FuseApp(Ice::StringSeq args) : iceArgs(std::move(args)) { }
+namespace NetFS {
+	constexpr static unsigned short DEFAULT_PORT = 4000;
+	constexpr static unsigned short DEFAULT_MAX_MESSAGE_SIZE = 1024;
+	constexpr static unsigned short KILO_MULTIPLIER = 1024;
 
-NetFS::FuseApp::~FuseApp()
-{
-	for (const OpenDirs::value_type & openDir : openDirs) {
-		// LCOV_EXCL_START
-		try {
-			openDir.second->remote->close();
-		}
-		catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
-		}
-		// LCOV_EXCL_STOP
-	}
-	for (const OpenFiles::value_type & openFile : openFiles) {
-		// LCOV_EXCL_START
-		try {
-			openFile.second->remote->close();
-		}
-		catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
-		}
-		// LCOV_EXCL_STOP
-	}
-	if (volume) {
-		try {
-			volume->disconnect();
-		}
-		catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
-		}
-	}
-	if (session) {
-		try {
-			session->destroy();
-		}
-		catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
-		}
-	}
-	if (ic) {
-		ic->destroy();
-	}
-}
+	FuseApp::FuseApp(Ice::StringSeq args) : iceArgs(std::move(args)) { }
 
-void *
-NetFS::FuseApp::init(struct fuse_conn_info *, struct fuse_config *)
-{
-	BOOST_ASSERT(!ic);
-	ic = Ice::initialize(iceArgs);
-	BOOST_ASSERT(ic);
-	if (!iceArgs.empty()) {
-		const auto & arg = iceArgs.front();
-		if (arg.find("://") != std::string::npos) {
-			fcr = configureFromUri(arg);
-		}
-		else if (auto colon = arg.find(':'); colon != std::string::npos) {
-			fcr = configureFromFile(arg.substr(0, colon), arg.substr(colon + 1));
+	FuseApp::~FuseApp()
+	{
+		for (const OpenDirs::value_type & openDir : openDirs) {
+			// LCOV_EXCL_START
+			try {
+				openDir.second->remote->close();
+			}
+			catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
+			}
+			// LCOV_EXCL_STOP
+		}
+		for (const OpenFiles::value_type & openFile : openFiles) {
+			// LCOV_EXCL_START
+			try {
+				openFile.second->remote->close();
+			}
+			catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
+			}
+			// LCOV_EXCL_STOP
+		}
+		if (volume) {
+			try {
+				volume->disconnect();
+			}
+			catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
+			}
+		}
+		if (session) {
+			try {
+				session->destroy();
+			}
+			catch (...) { // NOLINT(bugprone-empty-catch) - Can't do anything useful here
+			}
+		}
+		if (ic) {
+			ic->destroy();
 		}
 	}
-	if (!fcr->Mapper) {
-		fcr->Mapper = std::make_shared<Mapping::DefaultMapper>();
+
+	void *
+	FuseApp::init(struct fuse_conn_info *, struct fuse_config *)
+	{
+		BOOST_ASSERT(!ic);
+		ic = Ice::initialize(iceArgs);
+		BOOST_ASSERT(ic);
+		if (!iceArgs.empty()) {
+			const auto & arg = iceArgs.front();
+			if (arg.find("://") != std::string::npos) {
+				fcr = configureFromUri(arg);
+			}
+			else if (auto colon = arg.find(':'); colon != std::string::npos) {
+				fcr = configureFromFile(arg.substr(0, colon), arg.substr(colon + 1));
+			}
+		}
+		if (!fcr->Mapper) {
+			fcr->Mapper = std::make_shared<Mapping::DefaultMapper>();
+		}
+		BOOST_ASSERT(fcr);
+		converter.mapper = fcr->Mapper;
+		clientSettings.MessageSizeMax
+				= ic->getProperties()->getPropertyAsIntWithDefault("Ice.MessageSizeMax", DEFAULT_MAX_MESSAGE_SIZE);
+		return this;
 	}
-	BOOST_ASSERT(fcr);
-	converter.mapper = fcr->Mapper;
-	clientSettings.MessageSizeMax
-			= ic->getProperties()->getPropertyAsIntWithDefault("Ice.MessageSizeMax", DEFAULT_MAX_MESSAGE_SIZE);
-	return this;
-}
 
-NetFS::Client::ResourcePtr
-NetFS::FuseApp::configureFromFile(const std::filesystem::path & path, const std::string & resourceName)
-{
-	auto deserialiser = Slicer::FileDeserializerFactory::createNew(path.extension().string(), path);
-	auto configuration = Slicer::DeserializeAnyWith<NetFS::Client::ConfigurationPtr>(deserialiser);
-	return AdHoc::safeMapLookup<Client::ResourceNotFound>(configuration->Resources, resourceName);
-}
+	Client::ResourcePtr
+	FuseApp::configureFromFile(const std::filesystem::path & path, const std::string & resourceName)
+	{
+		auto deserialiser = Slicer::FileDeserializerFactory::createNew(path.extension().string(), path);
+		auto configuration = Slicer::DeserializeAnyWith<NetFS::Client::ConfigurationPtr>(deserialiser);
+		return AdHoc::safeMapLookup<Client::ResourceNotFound>(configuration->Resources, resourceName);
+	}
 
-AdHocFormatter(IceEndpointFmt, "%? -h %? -p %?");
+	AdHocFormatter(IceEndpointFmt, "%? -h %? -p %?");
 
-NetFS::Client::ResourcePtr
-NetFS::FuseApp::configureFromUri(const std::string & uriString)
-{
-	const AdHoc::Uri uri(uriString);
+	Client::ResourcePtr
+	FuseApp::configureFromUri(const std::string & uriString)
+	{
+		const AdHoc::Uri uri(uriString);
 
-	auto resource = std::make_shared<NetFS::Client::Resource>();
-	resource->ExportName = uri.path->string();
-	resource->Endpoints.emplace_back(IceEndpointFmt::get(uri.scheme, uri.host, uri.port ? *uri.port : DEFAULT_PORT));
-	if (uri.password) {
-		resource->AuthToken = *uri.password;
+		auto resource = std::make_shared<NetFS::Client::Resource>();
+		resource->ExportName = uri.path->string();
+		resource->Endpoints.emplace_back(
+				IceEndpointFmt::get(uri.scheme, uri.host, uri.port ? *uri.port : DEFAULT_PORT));
+		if (uri.password) {
+			resource->AuthToken = *uri.password;
+		}
+		auto set = [&uri](const auto & param, auto & setting) {
+			if (auto value = uri.query.find(param); value != uri.query.end()) {
+				setting = boost::lexical_cast<std::remove_reference_t<decltype(setting)>>(value->second);
+			}
+		};
+		auto setWith = [&uri](const auto & param, auto & setting, auto && func) {
+			if (auto value = uri.query.find(param); value != uri.query.end()) {
+				setting = func(value->second);
+			}
+		};
+		set("async", resource->Async);
+		setWith("mapper", resource->Mapper, [&set, &setWith](auto && mapper) -> NetFS::Mapping::MapperPtr {
+			if (mapper == "hide") {
+				return std::make_shared<NetFS::Client::HideUnknownMapperImpl>();
+			}
+			if (mapper == "mask") {
+				auto mapperImpl = std::make_shared<NetFS::Client::MaskUnknownMapperImpl>();
+				set("mapper.unknownuser", mapperImpl->UnknownUser);
+				set("mapper.unknowngroup", mapperImpl->UnknownGroup);
+				setWith("mapper.usermask", mapperImpl->UserMask, Client::fromOctal);
+				setWith("mapper.groupmask", mapperImpl->GroupMask, Client::fromOctal);
+				return mapperImpl;
+			}
+			return {};
+		});
+		return resource;
 	}
-	auto set = [&uri](const auto & param, auto & setting) {
-		if (auto value = uri.query.find(param); value != uri.query.end()) {
-			setting = boost::lexical_cast<std::remove_reference_t<decltype(setting)>>(value->second);
+
+	int
+	FuseApp::opt_parse(void * data, const char * arg, int, struct fuse_args *)
+	{
+		auto & iceArgs = *static_cast<Ice::StringSeq *>(data);
+		std::string_view argV {arg};
+		if (argV.starts_with("--Ice.")) {
+			iceArgs.emplace_back(arg);
+			return 0;
 		}
-	};
-	auto setWith = [&uri](const auto & param, auto & setting, auto && func) {
-		if (auto value = uri.query.find(param); value != uri.query.end()) {
-			setting = func(value->second);
+		if (argV == "_netdev") {
+			return 0;
 		}
-	};
-	set("async", resource->Async);
-	setWith("mapper", resource->Mapper, [&set, &setWith](auto && mapper) -> NetFS::Mapping::MapperPtr {
-		if (mapper == "hide") {
-			return std::make_shared<NetFS::Client::HideUnknownMapperImpl>();
+		if (argV.front() == '-') {
+			return 1;
 		}
-		if (mapper == "mask") {
-			auto mapperImpl = std::make_shared<NetFS::Client::MaskUnknownMapperImpl>();
-			set("mapper.unknownuser", mapperImpl->UnknownUser);
-			set("mapper.unknowngroup", mapperImpl->UnknownGroup);
-			setWith("mapper.usermask", mapperImpl->UserMask, Client::fromOctal);
-			setWith("mapper.groupmask", mapperImpl->GroupMask, Client::fromOctal);
-			return mapperImpl;
+		if (iceArgs.empty() || iceArgs.front().starts_with("--Ice.")) {
+			iceArgs.emplace(iceArgs.begin(), arg);
+			return 0;
 		}
-		return {};
-	});
-	return resource;
-}
-
-int
-NetFS::FuseApp::opt_parse(void * data, const char * arg, int, struct fuse_args *)
-{
-	auto & iceArgs = *static_cast<Ice::StringSeq *>(data);
-	std::string_view argV {arg};
-	if (argV.starts_with("--Ice.")) {
-		iceArgs.emplace_back(arg);
-		return 0;
-	}
-	if (argV == "_netdev") {
-		return 0;
-	}
-	if (argV.front() == '-') {
 		return 1;
 	}
-	if (iceArgs.empty() || iceArgs.front().starts_with("--Ice.")) {
-		iceArgs.emplace(iceArgs.begin(), arg);
-		return 0;
-	}
-	return 1;
-}
 
-void
-NetFS::FuseApp::connectSession()
-{
-	Lock(mutex);
-	if (!sessionOpened && ic->getDefaultRouter()) {
-		auto router = Ice::checkedCast<Glacier2::RouterPrx>(ic->getDefaultRouter());
-		session = router->createSession("", "");
-		if (int acmTimeout = router->getACMTimeout() > 0) {
-			Ice::ConnectionPtr conn = router->ice_getCachedConnection();
-			conn->setACM(acmTimeout, IceUtil::None, Ice::ACMHeartbeat::HeartbeatAlways);
+	void
+	FuseApp::connectSession()
+	{
+		Lock(mutex);
+		if (!sessionOpened && ic->getDefaultRouter()) {
+			auto router = Ice::checkedCast<Glacier2::RouterPrx>(ic->getDefaultRouter());
+			session = router->createSession("", "");
+			if (int acmTimeout = router->getACMTimeout() > 0) {
+				Ice::ConnectionPtr conn = router->ice_getCachedConnection();
+				conn->setACM(acmTimeout, IceUtil::None, Ice::ACMHeartbeat::HeartbeatAlways);
+			}
+			sessionOpened = true;
 		}
-		sessionOpened = true;
 	}
-}
 
-NetFS::FuseApp::CombinedSettings
-NetFS::FuseApp::combineSettings(const Settings & daemon, const Settings & client)
-{
-	return {safe {std::min(daemon.MessageSizeMax.value_or(DEFAULT_MAX_MESSAGE_SIZE),
-						  client.MessageSizeMax.value_or(DEFAULT_MAX_MESSAGE_SIZE))
-			* KILO_MULTIPLIER}};
-}
+	FuseApp::CombinedSettings
+	FuseApp::combineSettings(const Settings & daemon, const Settings & client)
+	{
+		return {safe {std::min(daemon.MessageSizeMax.value_or(DEFAULT_MAX_MESSAGE_SIZE),
+							  client.MessageSizeMax.value_or(DEFAULT_MAX_MESSAGE_SIZE))
+				* KILO_MULTIPLIER}};
+	}
 
-void
-NetFS::FuseApp::connectToService()
-{
-	Lock(mutex);
-	if (!service) {
-		auto proxyAddr = fcr->ServiceIdentity;
-		for (const auto & endpoint : fcr->Endpoints) {
-			proxyAddr += ":" + endpoint;
-		}
-		service = Ice::checkedCast<NetFS::ServicePrx>(ic->stringToProxy(proxyAddr));
+	void
+	FuseApp::connectToService()
+	{
+		Lock(mutex);
 		if (!service) {
-			throw std::runtime_error("Invalid service proxy: " + proxyAddr);
+			auto proxyAddr = fcr->ServiceIdentity;
+			for (const auto & endpoint : fcr->Endpoints) {
+				proxyAddr += ":" + endpoint;
+			}
+			service = Ice::checkedCast<NetFS::ServicePrx>(ic->stringToProxy(proxyAddr));
+			if (!service) {
+				throw std::runtime_error("Invalid service proxy: " + proxyAddr);
+			}
+			daemonSettings = service->getSettings();
+			combinedSettings = combineSettings(*daemonSettings, clientSettings);
 		}
-		daemonSettings = service->getSettings();
-		combinedSettings = combineSettings(*daemonSettings, clientSettings);
 	}
-}
 
-void
-NetFS::FuseApp::connectToVolume(bool force)
-{
-	Lock(mutex);
-	if (force || !volume) {
-		volume = service->connect(fcr->ExportName, fcr->AuthToken);
-		if (!volume) {
-			throw std::runtime_error("Invalid filesystem proxy");
+	void
+	FuseApp::connectToVolume(bool force)
+	{
+		Lock(mutex);
+		if (force || !volume) {
+			volume = service->connect(fcr->ExportName, fcr->AuthToken);
+			if (!volume) {
+				throw std::runtime_error("Invalid filesystem proxy");
+			}
 		}
 	}
-}
 
-void
-NetFS::FuseApp::connectHandles()
-{
-	for (const OpenFiles::value_type & openFile : openFiles) {
-		try {
-			openFile.second->remote->ice_ping();
-		}
-		catch (const Ice::ObjectNotExistException &) {
-			openFile.second->remote = volume->open(reqEnv(), openFile.second->path, openFile.second->flags & !O_CREAT);
+	void
+	FuseApp::connectHandles()
+	{
+		for (const OpenFiles::value_type & openFile : openFiles) {
+			try {
+				openFile.second->remote->ice_ping();
+			}
+			catch (const Ice::ObjectNotExistException &) {
+				openFile.second->remote
+						= volume->open(reqEnv(), openFile.second->path, openFile.second->flags & !O_CREAT);
+			}
+		}
+		for (const OpenDirs::value_type & openDir : openDirs) {
+			try {
+				openDir.second->remote->ice_ping();
+			}
+			catch (const Ice::ObjectNotExistException &) {
+				openDir.second->remote = volume->opendir(reqEnv(), openDir.second->path);
+			}
 		}
 	}
-	for (const OpenDirs::value_type & openDir : openDirs) {
-		try {
-			openDir.second->remote->ice_ping();
-		}
-		catch (const Ice::ObjectNotExistException &) {
-			openDir.second->remote = volume->opendir(reqEnv(), openDir.second->path);
-		}
-	}
-}
 
-void
-NetFS::FuseApp::verifyConnection()
-{
-	Lock(mutex);
-	if (session) {
-		try {
-			session->ice_ping();
-		}
-		catch (const Ice::Exception &) {
-			session = nullptr;
-			sessionOpened = false;
-		}
-	}
-	if (service) {
-		try {
-			service->ice_ping();
-		}
-		catch (const Ice::Exception &) {
-			service = nullptr;
-		}
-	}
-	if (volume) {
-		try {
-			volume->ice_ping();
-		}
-		catch (const Ice::Exception &) {
-			volume = nullptr;
+	void
+	FuseApp::verifyConnection()
+	{
+		Lock(mutex);
+		if (session) {
+			try {
+				session->ice_ping();
+			}
+			catch (const Ice::Exception &) {
+				session = nullptr;
+				sessionOpened = false;
+			}
+		}
+		if (service) {
+			try {
+				service->ice_ping();
+			}
+			catch (const Ice::Exception &) {
+				service = nullptr;
+			}
+		}
+		if (volume) {
+			try {
+				volume->ice_ping();
+			}
+			catch (const Ice::Exception &) {
+				volume = nullptr;
+			}
 		}
 	}
-}
 
-int
-NetFS::FuseApp::onError(const std::exception & error) noexcept
-{
-	if (dynamic_cast<const Ice::SocketException *>(&error) || dynamic_cast<const Ice::TimeoutException *>(&error)) {
-		log(LOG_ERR, error.what());
-		try {
-			verifyConnection();
-			connectSession();
-			connectToService();
-			connectToVolume(false);
-			connectHandles();
-			return 0;
-		}
-		catch (...) {
-			return -EIO;
-		}
+	int
+	FuseApp::onError(const std::exception & error) noexcept
+	{
+		if (dynamic_cast<const Ice::SocketException *>(&error) || dynamic_cast<const Ice::TimeoutException *>(&error)) {
+			log(LOG_ERR, error.what());
+			try {
+				verifyConnection();
+				connectSession();
+				connectToService();
+				connectToVolume(false);
+				connectHandles();
+				return 0;
+			}
+			catch (...) {
+				return -EIO;
+			}
+		}
+		if (dynamic_cast<const Ice::RequestFailedException *>(&error)) {
+			try {
+				connectToVolume(true);
+				connectHandles();
+				return 0;
+			}
+			catch (...) {
+				return -EIO;
+			}
+		}
+		if (dynamic_cast<const NetFS::AuthError *>(&error)) {
+			return -EPERM;
+		}
+		return FuseAppBase::onError(error);
 	}
-	if (dynamic_cast<const Ice::RequestFailedException *>(&error)) {
-		try {
-			connectToVolume(true);
-			connectHandles();
-			return 0;
-		}
-		catch (...) {
-			return -EIO;
-		}
-	}
-	if (dynamic_cast<const NetFS::AuthError *>(&error)) {
-		return -EPERM;
-	}
-	return FuseAppBase::onError(error);
-}
 
-void
-NetFS::FuseApp::beforeOperation()
-{
-	connectSession();
-	connectToService();
-	connectToVolume(false);
-}
+	void
+	FuseApp::beforeOperation()
+	{
+		connectSession();
+		connectToService();
+		connectToVolume(false);
+	}
 
-NetFS::ReqEnv
-NetFS::FuseApp::reqEnv()
-{
-	struct fuse_context * context = fuseGetContext();
-	auto transportContext = converter.mapper->mapFileSystem(safe {context->uid}, safe {context->gid});
-	return {.user = std::move(transportContext.username), .grp = std::move(transportContext.groupname)};
+	ReqEnv
+	FuseApp::reqEnv()
+	{
+		struct fuse_context * context = fuseGetContext();
+		auto transportContext = converter.mapper->mapFileSystem(safe {context->uid}, safe {context->gid});
+		return {.user = std::move(transportContext.username), .grp = std::move(transportContext.groupname)};
+	}
 }
diff --git a/netfs/fuse/fuseConfigImpl.cpp b/netfs/fuse/fuseConfigImpl.cpp
index 9dca813..351a794 100644
--- a/netfs/fuse/fuseConfigImpl.cpp
+++ b/netfs/fuse/fuseConfigImpl.cpp
@@ -3,8 +3,10 @@
 
 AdHocFormatter(ResourceNotFoundMsg, "No such resource: %?");
 
-void
-NetFS::Client::ResourceNotFound::ice_print(std::ostream & stream) const
-{
-	ResourceNotFoundMsg::write(stream, resourceName);
+namespace NetFS {
+	void
+	Client::ResourceNotFound::ice_print(std::ostream & stream) const
+	{
+		ResourceNotFoundMsg::write(stream, resourceName);
+	}
 }
diff --git a/netfs/fuse/fuseMisc.cpp b/netfs/fuse/fuseMisc.cpp
index 21c4a32..f5d5f67 100644
--- a/netfs/fuse/fuseMisc.cpp
+++ b/netfs/fuse/fuseMisc.cpp
@@ -4,111 +4,113 @@
 #include <numeric.h>
 #include <span>
 
-int
-NetFS::FuseApp::access(const char * path, int accessMode)
-{
-	return -volume->access(reqEnv(), path, accessMode);
-}
-
-int
-NetFS::FuseApp::chmod(const char * path, mode_t mode, fuse_file_info *)
-{
-	try {
-		volume->chmod(reqEnv(), path, safe {mode});
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+namespace NetFS {
+	int
+	FuseApp::access(const char * path, int accessMode)
+	{
+		return -volume->access(reqEnv(), path, accessMode);
 	}
-}
 
-int
-NetFS::FuseApp::chown(const char * path, uid_t uid, gid_t gid, fuse_file_info *)
-{
-	try {
-		volume->chown(reqEnv(), path, safe {uid}, safe {gid});
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+	int
+	FuseApp::chmod(const char * path, mode_t mode, fuse_file_info *)
+	{
+		try {
+			volume->chmod(reqEnv(), path, safe {mode});
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-}
 
-int
-NetFS::FuseApp::link(const char * path1, const char * path2)
-{
-	try {
-		volume->link(reqEnv(), path1, path2);
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+	int
+	FuseApp::chown(const char * path, uid_t uid, gid_t gid, fuse_file_info *)
+	{
+		try {
+			volume->chown(reqEnv(), path, safe {uid}, safe {gid});
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-}
 
-int
-NetFS::FuseApp::mknod(const char * path, mode_t mode, dev_t dev)
-{
-	try {
-		volume->mknod(reqEnv(), path, safe {mode}, safe {dev});
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+	int
+	FuseApp::link(const char * path1, const char * path2)
+	{
+		try {
+			volume->link(reqEnv(), path1, path2);
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-}
 
-int
-NetFS::FuseApp::symlink(const char * path1, const char * path2)
-{
-	try {
-		volume->symlink(reqEnv(), path1, path2);
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+	int
+	FuseApp::mknod(const char * path, mode_t mode, dev_t dev)
+	{
+		try {
+			volume->mknod(reqEnv(), path, safe {mode}, safe {dev});
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-}
 
-int
-NetFS::FuseApp::readlink(const char * path, char * path2, size_t size)
-{
-	try {
-		const auto link = volume->readlink(reqEnv(), path);
-		if (size <= link.length()) {
-			return -ENAMETOOLONG;
-		}
-		link.copy(path2, size);
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+	int
+	FuseApp::symlink(const char * path1, const char * path2)
+	{
+		try {
+			volume->symlink(reqEnv(), path1, path2);
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-}
 
-int
-NetFS::FuseApp::rename(const char * path1, const char * path2, unsigned int flags)
-{
-	try {
-		volume->rename(reqEnv(), path1, path2, safe {flags});
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+	int
+	FuseApp::readlink(const char * path, char * path2, size_t size)
+	{
+		try {
+			const auto link = volume->readlink(reqEnv(), path);
+			if (size <= link.length()) {
+				return -ENAMETOOLONG;
+			}
+			link.copy(path2, size);
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-}
 
-int
-// NOLINTNEXTLINE(*-c-arrays)
-NetFS::FuseApp::utimens(const char * path, const struct timespec times[2], fuse_file_info *)
-{
-	try {
-		std::span<const struct timespec, 2> timesSpan(times, 2);
-		volume->utimens(reqEnv(), path, timesSpan.front().tv_sec, timesSpan.front().tv_nsec, timesSpan.back().tv_sec,
-				timesSpan.back().tv_nsec);
-		return 0;
+	int
+	FuseApp::rename(const char * path1, const char * path2, unsigned int flags)
+	{
+		try {
+			volume->rename(reqEnv(), path1, path2, safe {flags});
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+
+	int
+	// NOLINTNEXTLINE(*-c-arrays)
+	FuseApp::utimens(const char * path, const struct timespec times[2], fuse_file_info *)
+	{
+		try {
+			std::span<const struct timespec, 2> timesSpan(times, 2);
+			volume->utimens(reqEnv(), path, timesSpan.front().tv_sec, timesSpan.front().tv_nsec,
+					timesSpan.back().tv_sec, timesSpan.back().tv_nsec);
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
 }
diff --git a/netfs/fuse/fuseSystem.cpp b/netfs/fuse/fuseSystem.cpp
index 91d71f1..3af1b36 100644
--- a/netfs/fuse/fuseSystem.cpp
+++ b/netfs/fuse/fuseSystem.cpp
@@ -1,13 +1,15 @@
 #include "fuseApp.h"
 
-int
-NetFS::FuseApp::statfs(const char * path, struct statvfs * vfs)
-{
-	try {
-		*vfs = converter.TypeConverter::convert(volume->statfs(reqEnv(), path));
-		return 0;
-	}
-	catch (NetFS::SystemError & e) {
-		return -e.syserrno;
+namespace NetFS {
+	int
+	FuseApp::statfs(const char * path, struct statvfs * vfs)
+	{
+		try {
+			*vfs = converter.TypeConverter::convert(volume->statfs(reqEnv(), path));
+			return 0;
+		}
+		catch (NetFS::SystemError & e) {
+			return -e.syserrno;
+		}
 	}
 }
diff --git a/netfs/ice/exceptionsImpl.cpp b/netfs/ice/exceptionsImpl.cpp
index 9588476..0c68630 100644
--- a/netfs/ice/exceptionsImpl.cpp
+++ b/netfs/ice/exceptionsImpl.cpp
@@ -2,8 +2,11 @@
 #include <exceptions.h>
 
 AdHocFormatter(ExportNotFoundMsg, "Export [%?] not found on remote host");
-void
-NetFS::ExportNotFound::ice_print(std::ostream & s) const
-{
-	ExportNotFoundMsg::write(s, exportName);
+
+namespace NetFS {
+	void
+	ExportNotFound::ice_print(std::ostream & stream) const
+	{
+		ExportNotFoundMsg::write(stream, exportName);
+	}
 }
diff --git a/netfs/ice/typeConverter.cpp b/netfs/ice/typeConverter.cpp
index 90fa439..5db7315 100644
--- a/netfs/ice/typeConverter.cpp
+++ b/netfs/ice/typeConverter.cpp
@@ -1,82 +1,84 @@
 #include "typeConverter.h"
 #include "numeric.h"
 
-EntryTypeConverter::EntryTypeConverter(NetFS::Mapping::MapperPtr m) : mapper(std::move(m)) { }
+namespace NetFS {
+	EntryTypeConverter::EntryTypeConverter(NetFS::Mapping::MapperPtr mapperImpl) : mapper(std::move(mapperImpl)) { }
 
-struct stat
-EntryTypeConverter::convert(const NetFS::Attr & a) const
-{
-	auto map = mapper->mapTransport(a.uid, a.gid);
-	struct stat s {};
-	static_assert(sizeof(s.st_ino) == sizeof(a.inode));
-	s.st_dev = safe {a.dev};
-	std::memcpy(&s.st_ino, &a.inode, sizeof(s.st_ino));
-	s.st_mode = safe {a.mode & ~map.mask};
-	s.st_nlink = safe {a.links};
-	s.st_uid = safe {map.uid};
-	s.st_gid = safe {map.gid};
-	s.st_rdev = safe {a.rdev};
-	s.st_size = safe {a.size};
-	s.st_blksize = safe {a.blockSize};
-	s.st_blocks = safe {a.blocks};
-	s.st_atime = safe {a.atime};
-	s.st_mtime = safe {a.mtime};
-	s.st_ctime = safe {a.ctime};
-	return s;
-}
+	struct stat
+	EntryTypeConverter::convert(const NetFS::Attr & attr) const
+	{
+		auto map = mapper->mapTransport(attr.uid, attr.gid);
+		struct stat stat {};
+		static_assert(sizeof(stat.st_ino) == sizeof(attr.inode));
+		stat.st_dev = safe {attr.dev};
+		std::memcpy(&stat.st_ino, &attr.inode, sizeof(stat.st_ino));
+		stat.st_mode = safe {attr.mode & ~map.mask};
+		stat.st_nlink = safe {attr.links};
+		stat.st_uid = safe {map.uid};
+		stat.st_gid = safe {map.gid};
+		stat.st_rdev = safe {attr.rdev};
+		stat.st_size = safe {attr.size};
+		stat.st_blksize = safe {attr.blockSize};
+		stat.st_blocks = safe {attr.blocks};
+		stat.st_atime = safe {attr.atime};
+		stat.st_mtime = safe {attr.mtime};
+		stat.st_ctime = safe {attr.ctime};
+		return stat;
+	}
 
-struct statvfs
-TypeConverter::convert(const NetFS::VFS & v) const
-{
-	struct statvfs vfs {};
-	vfs.f_bsize = safe {v.blockSize};
-	vfs.f_frsize = safe {v.fragmentSize};
-	vfs.f_blocks = safe {v.blocks};
-	vfs.f_bfree = safe {v.freeBlocks};
-	vfs.f_bavail = safe {v.availBlocks};
-	vfs.f_files = safe {v.files};
-	vfs.f_ffree = safe {v.freeFiles};
-	vfs.f_favail = safe {v.availFiles};
-	vfs.f_flag = safe {v.flags};
-	vfs.f_namemax = safe {v.maxNameLen};
-	return vfs;
-}
+	struct statvfs
+	TypeConverter::convert(const NetFS::VFS & vfs)
+	{
+		struct statvfs statvfs {};
+		statvfs.f_bsize = safe {vfs.blockSize};
+		statvfs.f_frsize = safe {vfs.fragmentSize};
+		statvfs.f_blocks = safe {vfs.blocks};
+		statvfs.f_bfree = safe {vfs.freeBlocks};
+		statvfs.f_bavail = safe {vfs.availBlocks};
+		statvfs.f_files = safe {vfs.files};
+		statvfs.f_ffree = safe {vfs.freeFiles};
+		statvfs.f_favail = safe {vfs.availFiles};
+		statvfs.f_flag = safe {vfs.flags};
+		statvfs.f_namemax = safe {vfs.maxNameLen};
+		return statvfs;
+	}
 
-NetFS::Attr
-EntryTypeConverter::convert(const struct stat & s) const
-{
-	auto map = mapper->mapFileSystem(safe {s.st_uid}, safe {s.st_gid});
-	NetFS::Attr a {};
-	static_assert(sizeof(s.st_ino) == sizeof(a.inode));
-	a.dev = safe {s.st_dev};
-	std::memcpy(&a.inode, &s.st_ino, sizeof(a.inode));
-	a.mode = safe {s.st_mode & static_cast<decltype(s.st_mode)>(~map.mask)};
-	a.links = safe {s.st_nlink};
-	a.uid = std::move(map.username);
-	a.gid = std::move(map.groupname);
-	a.rdev = safe {s.st_rdev};
-	a.size = safe {s.st_size};
-	a.blockSize = safe {s.st_blksize};
-	a.blocks = safe {s.st_blocks};
-	a.atime = safe {s.st_atime};
-	a.mtime = safe {s.st_mtime};
-	a.ctime = safe {s.st_ctime};
-	return a;
-}
+	NetFS::Attr
+	EntryTypeConverter::convert(const struct stat & stat) const
+	{
+		auto map = mapper->mapFileSystem(safe {stat.st_uid}, safe {stat.st_gid});
+		NetFS::Attr attr {};
+		static_assert(sizeof(stat.st_ino) == sizeof(attr.inode));
+		attr.dev = safe {stat.st_dev};
+		std::memcpy(&attr.inode, &stat.st_ino, sizeof(attr.inode));
+		attr.mode = safe {stat.st_mode & static_cast<decltype(stat.st_mode)>(~map.mask)};
+		attr.links = safe {stat.st_nlink};
+		attr.uid = std::move(map.username);
+		attr.gid = std::move(map.groupname);
+		attr.rdev = safe {stat.st_rdev};
+		attr.size = safe {stat.st_size};
+		attr.blockSize = safe {stat.st_blksize};
+		attr.blocks = safe {stat.st_blocks};
+		attr.atime = safe {stat.st_atime};
+		attr.mtime = safe {stat.st_mtime};
+		attr.ctime = safe {stat.st_ctime};
+		return attr;
+	}
 
-NetFS::VFS
-TypeConverter::convert(const struct statvfs & s) const
-{
-	NetFS::VFS t {};
-	t.blockSize = safe {s.f_bsize};
-	t.fragmentSize = safe {s.f_frsize};
-	t.blocks = safe {s.f_blocks};
-	t.freeBlocks = safe {s.f_bfree};
-	t.availBlocks = safe {s.f_bavail};
-	t.files = safe {s.f_files};
-	t.freeFiles = safe {s.f_ffree};
-	t.availFiles = safe {s.f_favail};
-	t.flags = safe {s.f_flag};
-	t.maxNameLen = safe {s.f_namemax};
-	return t;
+	NetFS::VFS
+	TypeConverter::convert(const struct statvfs & statvfs)
+	{
+		NetFS::VFS vfs {};
+		vfs.blockSize = safe {statvfs.f_bsize};
+		vfs.fragmentSize = safe {statvfs.f_frsize};
+		vfs.blocks = safe {statvfs.f_blocks};
+		vfs.freeBlocks = safe {statvfs.f_bfree};
+		vfs.availBlocks = safe {statvfs.f_bavail};
+		vfs.files = safe {statvfs.f_files};
+		vfs.freeFiles = safe {statvfs.f_ffree};
+		vfs.availFiles = safe {statvfs.f_favail};
+		vfs.flags = safe {statvfs.f_flag};
+		vfs.maxNameLen = safe {statvfs.f_namemax};
+		return vfs;
+	}
 }
diff --git a/netfs/ice/typeConverter.h b/netfs/ice/typeConverter.h
index 01746c4..ef8a35a 100644
--- a/netfs/ice/typeConverter.h
+++ b/netfs/ice/typeConverter.h
@@ -6,21 +6,23 @@
 #include <types.h>
 #include <visibility.h>
 
-class DLL_PUBLIC TypeConverter {
-public:
-	// VFS
-	struct statvfs convert(const NetFS::VFS &) const;
-	NetFS::VFS convert(const struct statvfs &) const;
-};
+namespace NetFS {
+	class DLL_PUBLIC TypeConverter {
+	public:
+		// VFS
+		[[nodiscard]] static struct statvfs convert(const NetFS::VFS &);
+		[[nodiscard]] static NetFS::VFS convert(const struct statvfs &);
+	};
 
-class DLL_PUBLIC EntryTypeConverter : public TypeConverter {
-public:
-	EntryTypeConverter() = default;
-	explicit EntryTypeConverter(NetFS::Mapping::MapperPtr);
+	class DLL_PUBLIC EntryTypeConverter : public TypeConverter {
+	public:
+		EntryTypeConverter() = default;
+		explicit EntryTypeConverter(NetFS::Mapping::MapperPtr);
 
-	// Attributes
-	struct stat convert(const NetFS::Attr &) const;
-	NetFS::Attr convert(const struct stat &) const;
+		// Attributes
+		[[nodiscard]] struct stat convert(const NetFS::Attr &) const;
+		[[nodiscard]] NetFS::Attr convert(const struct stat &) const;
 
-	NetFS::Mapping::MapperPtr mapper;
-};
+		NetFS::Mapping::MapperPtr mapper;
+	};
+}