Disable copying on ClientUser subclasses.

sstepashka · Dmitrii Kuragin · commit 17f5d700ce99 · 2026-02-09T11:28:51.000-08:00
diff --git a/p4-fusion/commands/change_list.cc b/p4-fusion/commands/change_list.cc
@@ -42,14 +42,14 @@ void ChangeList::PrepareDownload(const BranchSet& branchSet)
 			    // copy will have the target files listing the from-file with
 			    // different changelists than the point-in-time source branch's
 			    // changelist.
-			    const FileLogResult& filelog = p4->FileLog(cl.number);
-			    cl.changedFileGroups = branchSet.ParseAffectedFiles(filelog.GetFileData());
+			    std::unique_ptr<FileLogResult> filelog = p4->FileLog(cl.number);
+			    cl.changedFileGroups = branchSet.ParseAffectedFiles(filelog->GetFileData());
 		    }
 		    else
 		    {
 			    // If we don't care about branches, then p4->Describe is much faster.
-			    const DescribeResult& describe = p4->Describe(cl.number);
-			    cl.changedFileGroups = branchSet.ParseAffectedFiles(describe.GetFileData());
+			    std::unique_ptr<DescribeResult> describe = p4->Describe(cl.number);
+			    cl.changedFileGroups = branchSet.ParseAffectedFiles(describe->GetFileData());
 		    }
 
 		    std::unique_lock<std::mutex> lock(*cl.stateMutex);
@@ -118,11 +118,11 @@ void ChangeList::Flush(std::shared_ptr<std::vector<std::string>> printBatchFiles
 		    // Only perform the batch processing when there are files to process.
 		    if (!printBatchFileData->empty())
 		    {
-			    const PrintResult& printData = p4->PrintFiles(*printBatchFiles);
+			    std::unique_ptr<PrintResult> printData = p4->PrintFiles(*printBatchFiles);
 
 			    for (int i = 0; i < printBatchFiles->size(); i++)
 			    {
-				    printBatchFileData->at(i)->MoveContentsOnceFrom(printData.GetPrintData().at(i).contents);
+				    printBatchFileData->at(i)->MoveContentsOnceFrom(printData->GetPrintData().at(i).contents);
 			    }
 		    }
 
diff --git a/p4-fusion/commands/result.h b/p4-fusion/commands/result.h
@@ -13,7 +13,15 @@ class Result : public ClientUser
 	Error m_Error;
 
 public:
+    Result() = default;
+
 	void HandleError(Error* e) override;
 
 	const Error& GetError() const { return m_Error; }
+
+    Result(const Result&) = delete;
+    Result& operator=(const Result&) = delete;
+
+    Result(Result&&) = delete;
+    Result& operator=(Result&&) = delete;
 };
diff --git a/p4-fusion/main.cc b/p4-fusion/main.cc
@@ -90,7 +90,7 @@ int Main(int argc, char** argv)
 	P4API::P4PORT = Arguments::GetSingleton()->GetPort();
 	P4API::P4USER = Arguments::GetSingleton()->GetUsername();
 
-	const Error serviceConnectionResult = P4API().TestConnection(5).GetError();
+	const Error serviceConnectionResult = P4API().TestConnection(5)->GetError();
 	bool serverAvailable = serviceConnectionResult.IsError() == 0;
 	if (serverAvailable)
 	{
@@ -102,7 +102,7 @@ int Main(int argc, char** argv)
 		return 1;
 	}
 	P4API::P4CLIENT = Arguments::GetSingleton()->GetClient();
-	P4API::ClientSpec = P4API().Client().GetClientSpec();
+	P4API::ClientSpec = P4API().Client()->GetClientSpec();
 
 	if (P4API::ClientSpec.mapping.empty())
 	{
@@ -169,7 +169,7 @@ int Main(int argc, char** argv)
 		auto tempStr = depotPath.substr(0, depotPath.size() - 4);
 		auto val = p4.Stream(tempStr);
 		// First we get the shallow imports.
-		for (auto const& v : val.GetStreamSpec().mapping)
+		for (auto const& v : val->GetStreamSpec().mapping)
 		{
 			// We don't need stream isolate or share, so we don't check them
 			if (v.rule == StreamResult::EStreamImport)
@@ -196,7 +196,7 @@ int Main(int argc, char** argv)
 			// A path isn't nessecarily a fully qualified stream in itself but p4 stream works with arbitrary paths
 			auto streamName = mappings[idx].stream2.substr(0, mappings[idx].stream2.size() - 4);
 			auto subStream = p4.Stream(streamName);
-			for (auto& v : subStream.GetStreamSpec().mapping)
+			for (auto& v : subStream->GetStreamSpec().mapping)
 			{
 				// According to the perforce rules, exclude should not be propagated outside the parent stream
 				// The only rules we need to care about are import and exclude.
@@ -279,14 +279,14 @@ int Main(int argc, char** argv)
 
 	PRINT("Requesting changelists to convert from the Perforce server");
 
-	std::vector<ChangeList> changes = std::move(p4.Changes(depotPath, resumeFromCL, maxChanges).GetChanges());
+	std::vector<ChangeList> changes = std::move(p4.Changes(depotPath, resumeFromCL, maxChanges)->GetChanges());
 
 	if (streamMappings)
 	{
 		PRINT("Path: " << depotPath << " has " << changes.size() << " changes!");
 		for (auto const& mapped : mappings)
 		{
-			std::vector<ChangeList> temp = std::move(p4.Changes(mapped.stream2, resumeFromCL, maxChanges).GetChanges());
+			std::vector<ChangeList> temp = std::move(p4.Changes(mapped.stream2, resumeFromCL, maxChanges)->GetChanges());
 			PRINT("Path: " << mapped.stream2 << " has " << temp.size() << " changes!");
 			changes.insert(changes.end(), std::make_move_iterator(temp.begin()), std::make_move_iterator(temp.end()));
 		}
@@ -340,11 +340,11 @@ int Main(int argc, char** argv)
 
 	SUCCESS("Queued first " << startupDownloadsCount << " CLs up until CL " << changes.at(lastDownloadedCL).number << " for downloading");
 
-	int timezoneMinutes = p4.Info().GetServerTimezoneMinutes();
+	int timezoneMinutes = p4.Info()->GetServerTimezoneMinutes();
 	SUCCESS("Perforce server timezone is " << timezoneMinutes << " minutes");
 
 	// Map usernames to emails
-	const std::unordered_map<UsersResult::UserID, UsersResult::UserData> users = std::move(p4.Users().GetUserEmails());
+	const std::unordered_map<UsersResult::UserID, UsersResult::UserData> users = std::move(p4.Users()->GetUserEmails());
 	SUCCESS("Received userbase details from the Perforce server");
 
 	// Commit procedure start
diff --git a/p4-fusion/p4_api.cc b/p4-fusion/p4_api.cc
@@ -7,6 +7,7 @@
 #include "p4_api.h"
 
 #include <csignal>
+#include <memory>
 
 #include "commands/stream_result.h"
 #include "utils/std_helpers.h"
@@ -166,32 +167,32 @@ void P4API::UpdateClientSpec()
 	Run<Result>("client", {});
 }
 
-ClientResult P4API::Client()
+std::unique_ptr<ClientResult> P4API::Client()
 {
 	return Run<ClientResult>("client", { "-o" });
 }
 
-StreamResult P4API::Stream(const std::string& path)
+std::unique_ptr<StreamResult> P4API::Stream(const std::string& path)
 {
 	return Run<StreamResult>("stream", { "-o", path });
 }
 
-TestResult P4API::TestConnection(const int retries)
+std::unique_ptr<TestResult> P4API::TestConnection(const int retries)
 {
 	return RunEx<TestResult>("changes", { "-m", "1", "//..." }, retries);
 }
 
-ChangesResult P4API::ShortChanges(const std::string& path)
+std::unique_ptr<ChangesResult> P4API::ShortChanges(const std::string& path)
 {
-	ChangesResult changes = Run<ChangesResult>("changes", {
+	std::unique_ptr<ChangesResult> changes = Run<ChangesResult>("changes", {
 	                                                          "-s", "submitted", // Only include submitted CLs
 	                                                          path // Depot path to get CLs from
 	                                                      });
-	changes.reverse();
+	changes->reverse();
 	return changes;
 }
 
-ChangesResult P4API::Changes(const std::string& path)
+std::unique_ptr<ChangesResult> P4API::Changes(const std::string& path)
 {
 	MTR_SCOPE("P4", __func__);
 	return Run<ChangesResult>("changes", {
@@ -201,7 +202,7 @@ ChangesResult P4API::Changes(const std::string& path)
 	                                     });
 }
 
-ChangesResult P4API::Changes(const std::string& path, const std::string& from, int32_t maxCount)
+std::unique_ptr<ChangesResult> P4API::Changes(const std::string& path, const std::string& from, int32_t maxCount)
 {
 	std::vector<std::string> args = {
 		"-l", // Get full descriptions instead of sending cut-short ones
@@ -231,12 +232,12 @@ ChangesResult P4API::Changes(const std::string& path, const std::string& from, i
 
 	args.push_back(path + pathAddition);
 
-	ChangesResult result = Run<ChangesResult>("changes", args);
-	result.reverse();
+	std::unique_ptr<ChangesResult> result = Run<ChangesResult>("changes", args);
+	result->reverse();
 	return result;
 }
 
-ChangesResult P4API::ChangesFromTo(const std::string& path, const std::string& from, const std::string& to)
+std::unique_ptr<ChangesResult> P4API::ChangesFromTo(const std::string& path, const std::string& from, const std::string& to)
 {
 	std::string pathArg = path + "@" + from + "," + to;
 	return Run<ChangesResult>("changes", {
@@ -245,7 +246,7 @@ ChangesResult P4API::ChangesFromTo(const std::string& path, const std::string& f
 	                                     });
 }
 
-ChangesResult P4API::LatestChange(const std::string& path)
+std::unique_ptr<ChangesResult> P4API::LatestChange(const std::string& path)
 {
 	MTR_SCOPE("P4", __func__);
 	return Run<ChangesResult>("changes", {
@@ -255,25 +256,25 @@ ChangesResult P4API::LatestChange(const std::string& path)
 	                                     });
 }
 
-ChangesResult P4API::OldestChange(const std::string& path)
+std::unique_ptr<ChangesResult> P4API::OldestChange(const std::string& path)
 {
-	ChangesResult changes = Run<ChangesResult>("changes", {
+	std::unique_ptr<ChangesResult> changes = Run<ChangesResult>("changes", {
 	                                                          "-s", "submitted", // Only include submitted CLs,
 	                                                          "-m", "1", // Get top-most change
 	                                                          path // Depot path to get CLs from
 	                                                      });
-	changes.reverse();
+	changes->reverse();
 	return changes;
 }
 
-DescribeResult P4API::Describe(const std::string& cl)
+std::unique_ptr<DescribeResult> P4API::Describe(const std::string& cl)
 {
 	MTR_SCOPE("P4", __func__);
 	return Run<DescribeResult>("describe", { "-s", // Omit the diffs
 	                                           cl });
 }
 
-FileLogResult P4API::FileLog(const std::string& changelist)
+std::unique_ptr<FileLogResult> P4API::FileLog(const std::string& changelist)
 {
 	return Run<FileLogResult>("filelog", {
 	                                         "-c", // restrict output to a single changelist
@@ -283,17 +284,17 @@ FileLogResult P4API::FileLog(const std::string& changelist)
 	                                     });
 }
 
-SizesResult P4API::Size(const std::string& file)
+std::unique_ptr<SizesResult> P4API::Size(const std::string& file)
 {
 	return Run<SizesResult>("sizes", { "-a", "-s", file });
 }
 
-Result P4API::Sync()
+std::unique_ptr<Result> P4API::Sync()
 {
 	return Run<Result>("sync", {});
 }
 
-SyncResult P4API::GetFilesToSyncAtCL(const std::string& path, const std::string& cl)
+std::unique_ptr<SyncResult> P4API::GetFilesToSyncAtCL(const std::string& path, const std::string& cl)
 {
 	std::string clCommand = "@" + cl;
 	return Run<SyncResult>("sync", {
@@ -302,40 +303,40 @@ SyncResult P4API::GetFilesToSyncAtCL(const std::string& path, const std::string&
 	                               });
 }
 
-PrintResult P4API::PrintFile(const std::string& filePathRevision)
+std::unique_ptr<PrintResult> P4API::PrintFile(const std::string& filePathRevision)
 {
 	return Run<PrintResult>("print", {
 	                                     filePathRevision,
 	                                 });
 }
 
-PrintResult P4API::PrintFiles(const std::vector<std::string>& fileRevisions)
+std::unique_ptr<PrintResult> P4API::PrintFiles(const std::vector<std::string>& fileRevisions)
 {
 	MTR_SCOPE("P4", __func__);
 
 	if (fileRevisions.empty())
 	{
-		return PrintResult();
+		return std::unique_ptr<PrintResult>(new PrintResult());
 	}
 
 	return Run<PrintResult>("print", fileRevisions);
 }
 
-Result P4API::Sync(const std::string& path)
+std::unique_ptr<Result> P4API::Sync(const std::string& path)
 {
 	return Run<Result>("sync", {
 	                               path // Sync a particular depot path
 	                           });
 }
 
-UsersResult P4API::Users()
+std::unique_ptr<UsersResult> P4API::Users()
 {
 	return Run<UsersResult>("users", {
 	                                     "-a" // Include service accounts
 	                                 });
 }
 
-InfoResult P4API::Info()
+std::unique_ptr<InfoResult> P4API::Info()
 {
 	return Run<InfoResult>("info", {});
 }
diff --git a/p4-fusion/p4_api.h b/p4-fusion/p4_api.h

Original file line number	Diff line number	Diff line change
`@@ -42,14 +42,14 @@ void ChangeList::PrepareDownload(const BranchSet& branchSet)`
`42`	`42`	`// copy will have the target files listing the from-file with`
`43`	`43`	`// different changelists than the point-in-time source branch's`
`44`	`44`	`// changelist.`
`45`		`- const FileLogResult& filelog = p4->FileLog(cl.number);`
`46`		`- cl.changedFileGroups = branchSet.ParseAffectedFiles(filelog.GetFileData());`
	`45`	`+ std::unique_ptr<FileLogResult> filelog = p4->FileLog(cl.number);`
	`46`	`+ cl.changedFileGroups = branchSet.ParseAffectedFiles(filelog->GetFileData());`
`47`	`47`	`}`
`48`	`48`	`else`
`49`	`49`	`{`
`50`	`50`	`// If we don't care about branches, then p4->Describe is much faster.`
`51`		`- const DescribeResult& describe = p4->Describe(cl.number);`
`52`		`- cl.changedFileGroups = branchSet.ParseAffectedFiles(describe.GetFileData());`
	`51`	`+ std::unique_ptr<DescribeResult> describe = p4->Describe(cl.number);`
	`52`	`+ cl.changedFileGroups = branchSet.ParseAffectedFiles(describe->GetFileData());`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`std::unique_lock<std::mutex> lock(*cl.stateMutex);`
`@@ -118,11 +118,11 @@ void ChangeList::Flush(std::shared_ptr<std::vector<std::string>> printBatchFiles`
`118`	`118`	`// Only perform the batch processing when there are files to process.`
`119`	`119`	`if (!printBatchFileData->empty())`
`120`	`120`	`{`
`121`		`- const PrintResult& printData = p4->PrintFiles(*printBatchFiles);`
	`121`	`+ std::unique_ptr<PrintResult> printData = p4->PrintFiles(*printBatchFiles);`
`122`	`122`
`123`	`123`	`for (int i = 0; i < printBatchFiles->size(); i++)`
`124`	`124`	`{`
`125`		`- printBatchFileData->at(i)->MoveContentsOnceFrom(printData.GetPrintData().at(i).contents);`
	`125`	`+ printBatchFileData->at(i)->MoveContentsOnceFrom(printData->GetPrintData().at(i).contents);`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`#include "p4_api.h"`
`8`	`8`
`9`	`9`	`#include <csignal>`
	`10`	`+#include <memory>`
`10`	`11`
`11`	`12`	`#include "commands/stream_result.h"`
`12`	`13`	`#include "utils/std_helpers.h"`
`@@ -166,32 +167,32 @@ void P4API::UpdateClientSpec()`
`166`	`167`	`Run<Result>("client", {});`
`167`	`168`	`}`
`168`	`169`
`169`		`-ClientResult P4API::Client()`
	`170`	`+std::unique_ptr<ClientResult> P4API::Client()`
`170`	`171`	`{`
`171`	`172`	`return Run<ClientResult>("client", { "-o" });`
`172`	`173`	`}`
`173`	`174`
`174`		`-StreamResult P4API::Stream(const std::string& path)`
	`175`	`+std::unique_ptr<StreamResult> P4API::Stream(const std::string& path)`
`175`	`176`	`{`
`176`	`177`	`return Run<StreamResult>("stream", { "-o", path });`
`177`	`178`	`}`
`178`	`179`
`179`		`-TestResult P4API::TestConnection(const int retries)`
	`180`	`+std::unique_ptr<TestResult> P4API::TestConnection(const int retries)`
`180`	`181`	`{`
`181`	`182`	`return RunEx<TestResult>("changes", { "-m", "1", "//..." }, retries);`
`182`	`183`	`}`
`183`	`184`
`184`		`-ChangesResult P4API::ShortChanges(const std::string& path)`
	`185`	`+std::unique_ptr<ChangesResult> P4API::ShortChanges(const std::string& path)`
`185`	`186`	`{`
`186`		`- ChangesResult changes = Run<ChangesResult>("changes", {`
	`187`	`+ std::unique_ptr<ChangesResult> changes = Run<ChangesResult>("changes", {`
`187`	`188`	`"-s", "submitted", // Only include submitted CLs`
`188`	`189`	`path // Depot path to get CLs from`
`189`	`190`	`});`
`190`		`- changes.reverse();`
	`191`	`+ changes->reverse();`
`191`	`192`	`return changes;`
`192`	`193`	`}`
`193`	`194`
`194`		`-ChangesResult P4API::Changes(const std::string& path)`
	`195`	`+std::unique_ptr<ChangesResult> P4API::Changes(const std::string& path)`
`195`	`196`	`{`
`196`	`197`	`MTR_SCOPE("P4", __func__);`
`197`	`198`	`return Run<ChangesResult>("changes", {`
`@@ -201,7 +202,7 @@ ChangesResult P4API::Changes(const std::string& path)`
`201`	`202`	`});`
`202`	`203`	`}`
`203`	`204`
`204`		`-ChangesResult P4API::Changes(const std::string& path, const std::string& from, int32_t maxCount)`
	`205`	`+std::unique_ptr<ChangesResult> P4API::Changes(const std::string& path, const std::string& from, int32_t maxCount)`
`205`	`206`	`{`
`206`	`207`	`std::vector<std::string> args = {`
`207`	`208`	`"-l", // Get full descriptions instead of sending cut-short ones`
`@@ -231,12 +232,12 @@ ChangesResult P4API::Changes(const std::string& path, const std::string& from, i`
`231`	`232`
`232`	`233`	`args.push_back(path + pathAddition);`
`233`	`234`
`234`		`- ChangesResult result = Run<ChangesResult>("changes", args);`
`235`		`- result.reverse();`
	`235`	`+ std::unique_ptr<ChangesResult> result = Run<ChangesResult>("changes", args);`
	`236`	`+ result->reverse();`
`236`	`237`	`return result;`
`237`	`238`	`}`
`238`	`239`
`239`		`-ChangesResult P4API::ChangesFromTo(const std::string& path, const std::string& from, const std::string& to)`
	`240`	`+std::unique_ptr<ChangesResult> P4API::ChangesFromTo(const std::string& path, const std::string& from, const std::string& to)`
`240`	`241`	`{`
`241`	`242`	`std::string pathArg = path + "@" + from + "," + to;`
`242`	`243`	`return Run<ChangesResult>("changes", {`
`@@ -245,7 +246,7 @@ ChangesResult P4API::ChangesFromTo(const std::string& path, const std::string& f`
`245`	`246`	`});`
`246`	`247`	`}`
`247`	`248`
`248`		`-ChangesResult P4API::LatestChange(const std::string& path)`
	`249`	`+std::unique_ptr<ChangesResult> P4API::LatestChange(const std::string& path)`
`249`	`250`	`{`
`250`	`251`	`MTR_SCOPE("P4", __func__);`
`251`	`252`	`return Run<ChangesResult>("changes", {`
`@@ -255,25 +256,25 @@ ChangesResult P4API::LatestChange(const std::string& path)`
`255`	`256`	`});`
`256`	`257`	`}`
`257`	`258`
`258`		`-ChangesResult P4API::OldestChange(const std::string& path)`
	`259`	`+std::unique_ptr<ChangesResult> P4API::OldestChange(const std::string& path)`
`259`	`260`	`{`
`260`		`- ChangesResult changes = Run<ChangesResult>("changes", {`
	`261`	`+ std::unique_ptr<ChangesResult> changes = Run<ChangesResult>("changes", {`
`261`	`262`	`"-s", "submitted", // Only include submitted CLs,`
`262`	`263`	`"-m", "1", // Get top-most change`
`263`	`264`	`path // Depot path to get CLs from`
`264`	`265`	`});`
`265`		`- changes.reverse();`
	`266`	`+ changes->reverse();`
`266`	`267`	`return changes;`
`267`	`268`	`}`
`268`	`269`
`269`		`-DescribeResult P4API::Describe(const std::string& cl)`
	`270`	`+std::unique_ptr<DescribeResult> P4API::Describe(const std::string& cl)`
`270`	`271`	`{`
`271`	`272`	`MTR_SCOPE("P4", __func__);`
`272`	`273`	`return Run<DescribeResult>("describe", { "-s", // Omit the diffs`
`273`	`274`	`cl });`
`274`	`275`	`}`
`275`	`276`
`276`		`-FileLogResult P4API::FileLog(const std::string& changelist)`
	`277`	`+std::unique_ptr<FileLogResult> P4API::FileLog(const std::string& changelist)`
`277`	`278`	`{`
`278`	`279`	`return Run<FileLogResult>("filelog", {`
`279`	`280`	`"-c", // restrict output to a single changelist`
`@@ -283,17 +284,17 @@ FileLogResult P4API::FileLog(const std::string& changelist)`
`283`	`284`	`});`
`284`	`285`	`}`
`285`	`286`
`286`		`-SizesResult P4API::Size(const std::string& file)`
	`287`	`+std::unique_ptr<SizesResult> P4API::Size(const std::string& file)`
`287`	`288`	`{`
`288`	`289`	`return Run<SizesResult>("sizes", { "-a", "-s", file });`
`289`	`290`	`}`
`290`	`291`
`291`		`-Result P4API::Sync()`
	`292`	`+std::unique_ptr<Result> P4API::Sync()`
`292`	`293`	`{`
`293`	`294`	`return Run<Result>("sync", {});`
`294`	`295`	`}`
`295`	`296`
`296`		`-SyncResult P4API::GetFilesToSyncAtCL(const std::string& path, const std::string& cl)`
	`297`	`+std::unique_ptr<SyncResult> P4API::GetFilesToSyncAtCL(const std::string& path, const std::string& cl)`
`297`	`298`	`{`
`298`	`299`	`std::string clCommand = "@" + cl;`
`299`	`300`	`return Run<SyncResult>("sync", {`
`@@ -302,40 +303,40 @@ SyncResult P4API::GetFilesToSyncAtCL(const std::string& path, const std::string&`
`302`	`303`	`});`
`303`	`304`	`}`
`304`	`305`
`305`		`-PrintResult P4API::PrintFile(const std::string& filePathRevision)`
	`306`	`+std::unique_ptr<PrintResult> P4API::PrintFile(const std::string& filePathRevision)`
`306`	`307`	`{`
`307`	`308`	`return Run<PrintResult>("print", {`
`308`	`309`	`filePathRevision,`
`309`	`310`	`});`
`310`	`311`	`}`
`311`	`312`
`312`		`-PrintResult P4API::PrintFiles(const std::vector<std::string>& fileRevisions)`
	`313`	`+std::unique_ptr<PrintResult> P4API::PrintFiles(const std::vector<std::string>& fileRevisions)`
`313`	`314`	`{`
`314`	`315`	`MTR_SCOPE("P4", __func__);`
`315`	`316`
`316`	`317`	`if (fileRevisions.empty())`
`317`	`318`	`{`
`318`		`- return PrintResult();`
	`319`	`+ return std::unique_ptr<PrintResult>(new PrintResult());`
`319`	`320`	`}`
`320`	`321`
`321`	`322`	`return Run<PrintResult>("print", fileRevisions);`
`322`	`323`	`}`
`323`	`324`
`324`		`-Result P4API::Sync(const std::string& path)`
	`325`	`+std::unique_ptr<Result> P4API::Sync(const std::string& path)`
`325`	`326`	`{`
`326`	`327`	`return Run<Result>("sync", {`
`327`	`328`	`path // Sync a particular depot path`
`328`	`329`	`});`
`329`	`330`	`}`
`330`	`331`
`331`		`-UsersResult P4API::Users()`
	`332`	`+std::unique_ptr<UsersResult> P4API::Users()`
`332`	`333`	`{`
`333`	`334`	`return Run<UsersResult>("users", {`
`334`	`335`	`"-a" // Include service accounts`
`335`	`336`	`});`
`336`	`337`	`}`
`337`	`338`
`338`		`-InfoResult P4API::Info()`
	`339`	`+std::unique_ptr<InfoResult> P4API::Info()`
`339`	`340`	`{`
`340`	`341`	`return Run<InfoResult>("info", {});`
`341`	`342`	`}`