Renew the updater branch

Now with some actual consensus on what the updater will do!

1 files changed, 141 insertions, 0 deletions

diff --git a/mmc_updater/src/FileUtils.h b/mmc_updater/src/FileUtils.h
new file mode 100644
index 00000000..cb5830ae
--- /dev/null
+++ b/mmc_updater/src/FileUtils.h
@@ -0,0 +1,141 @@
+#pragma once
+
+#include <exception>
+#include <string>
+
+#include "Platform.h"
+#include "StringUtils.h"
+
+
+/** A set of functions for performing common operations
+  * on files, throwing exceptions if an operation fails.
+  *
+  * Path arguments to FileUtils functions should use Unix-style path
+  * separators.
+  */
+class FileUtils
+{
+	public:
+		/** Base class for exceptions reported by
+		  * FileUtils methods if an operation fails.
+		  */
+		class IOException : public std::exception
+		{
+			public:
+				IOException(const std::string& error);
+				IOException(int errorCode, const std::string& error);
+
+				virtual ~IOException() throw ();
+
+				enum Type
+				{
+					NoError,
+					/** Unknown error type.  Call what() to get the description
+					  * provided by the OS.
+					  */
+					Unknown,
+					ReadOnlyFileSystem,
+					DiskFull
+				};
+
+				virtual const char* what() const throw ()
+				{
+					return m_error.c_str();
+				}
+
+				Type type() const;
+
+			private:
+				void init(int errorCode, const std::string& error);
+
+				std::string m_error;
+				int m_errorCode;
+		};
+
+		/** Remove a file.  Throws an exception if the file
+		 * could not be removed.
+		 *
+		 * On Unix, a file can be removed even if it is in use if the user
+		 * has the necessary permissions.  removeFile() tries to simulate
+		 * this behavior on Windows.  If a file cannot be removed on Windows
+		 * because it is in use it will be moved to a temporary directory and
+		 * scheduled for deletion on the next restart.
+		 */
+		static void removeFile(const char* src) throw (IOException);
+
+		/** Set the permissions of a file.  @p permissions uses the standard
+		  * Unix mode_t values.
+		  */
+		static void chmod(const char* path, int permissions) throw (IOException);
+
+		/** Returns true if the file at @p path exists.  If @p path is a symlink,
+		  * returns true if the symlink itself exists, not the target.
+		  */
+		static bool fileExists(const char* path) throw (IOException);
+
+		/** Returns the Unix mode flags of @p path.  If @p path is a symlink,
+		  * returns the mode flags of the target.
+		  */
+		static int fileMode(const char* path) throw (IOException);
+
+		static void moveFile(const char* src, const char* dest) throw (IOException);
+		static void mkdir(const char* dir) throw (IOException);
+		static void rmdir(const char* dir) throw (IOException);
+		static void createSymLink(const char* link, const char* target) throw (IOException);
+		static void touch(const char* path) throw (IOException);
+		static void copyFile(const char* src, const char* dest) throw (IOException);
+
+		/** Create all the directories in @p path which do not yet exist.
+		  * @p path may be relative or absolute.
+		  */
+		static void mkpath(const char* path) throw (IOException);
+
+		/** Returns the file name part of a file path, including the extension. */
+		static std::string fileName(const char* path);
+
+		/** Returns the directory part of a file path.
+		 * On Windows this includes the drive letter, if present in @p path.
+		 */
+		static std::string dirname(const char* path);
+
+		/** Remove a directory and all of its contents. */
+		static void rmdirRecursive(const char* dir) throw (IOException);
+
+		/** Return the full, absolute path to a file, resolving any
+		  * symlinks and removing redundant sections.
+		  */
+		static std::string canonicalPath(const char* path);
+
+		/** Returns the path to a directory for storing temporary files. */
+		static std::string tempPath();
+
+		/** Returns a copy of the path 'str' with Windows-style '\'
+		 * dir separators converted to Unix-style '/' separators
+		 */
+		static std::string toUnixPathSeparators(const std::string& str);
+
+		static std::string toWindowsPathSeparators(const std::string& str);
+
+		/** Returns true if the provided path is relative.
+		  * Or false if absolute.
+		  */
+		static bool isRelative(const char* path);
+
+		/** Converts @p path to an absolute path.  If @p path is already absolute,
+		  * just returns @p path, otherwise prefixes it with @p basePath to make it absolute.
+		  *
+		  * @p basePath should be absolute.
+		  */
+		static std::string makeAbsolute(const char* path, const char* basePath);
+
+		static void writeFile(const char* path, const char* data, int length) throw (IOException);
+
+		static std::string readFile(const char* path) throw (IOException);
+
+		/** Changes the current working directory to @p path */
+		static void chdir(const char* path) throw (IOException);
+
+		/** Returns the current working directory of the application. */
+		static std::string getcwd() throw (IOException);
+};
+