Added read/write with arbitrary streams

Author: Causeless

System/Reader.cpp

@@ -26,6 +26,21 @@ namespace RTE {
 		m_NonModulePath = false;
 	}
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	Reader::Reader(const std::string &fileName, bool overwrites, const ProgressCallback &progressCallback, bool failOK, bool nonModulePath) {
+		Clear();
+		m_NonModulePath = nonModulePath;
+		Create(fileName, overwrites, progressCallback, failOK);
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	Reader::Reader(std::unique_ptr<std::istream> &&stream, bool overwrites, const ProgressCallback &progressCallback, bool failOK) {
+		Clear();
+		Create(std::move(stream), overwrites, progressCallback, failOK);
+	}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int Reader::Create(const std::string &fileName, bool overwrites, const ProgressCallback &progressCallback, bool failOK) {
@@ -47,16 +62,27 @@ namespace RTE {
 			m_DataModuleID = g_PresetMan.GetModuleID(m_DataModuleName);
 		}
 
+		return Create(std::make_unique<std::ifstream>(m_FilePath), overwrites, progressCallback, failOK);
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	int Reader::Create(std::unique_ptr<std::istream> &&stream, bool overwrites, const ProgressCallback &progressCallback, bool failOK) {
 		m_CanFail = failOK;
 
-		m_Stream = std::make_unique<std::ifstream>(m_FilePath);
-		if (!m_CanFail) { RTEAssert(System::PathExistsCaseSensitive(m_FilePath) && m_Stream->good(), "Failed to open data file \"" + m_FilePath + "\"!"); }
+		m_Stream = std::move(stream);
+
+		if (!m_CanFail) { 
+			RTEAssert(System::PathExistsCaseSensitive(m_FilePath) && m_Stream->good(), "Failed to open data file \"" + m_FilePath + "\"!"); 
+		}
 
 		m_OverwriteExisting = overwrites;
 
 		// Report that we're starting a new file
 		m_ReportProgress = progressCallback;
-		if (m_ReportProgress && m_Stream->good()) { m_ReportProgress("\t" + m_FileName + " on line " + std::to_string(m_CurrentLine), true); }
+		if (m_ReportProgress && m_Stream->good()) {
+			m_ReportProgress("\t" + m_FileName + " on line " + std::to_string(m_CurrentLine), true); 
+		}
 
 		return m_Stream->good() ? 0 : -1;
 	}
@@ -311,7 +337,7 @@ namespace RTE {
 
 		if (m_Stream->fail() || !System::PathExistsCaseSensitive(includeFilePath)) {
 			// Backpedal and set up to read the next property in the old stream
-			m_Stream.reset(m_StreamStack.top().Stream); // Destructs the current m_Stream and takes back ownership and management of the raw StreamInfo std::ifstream pointer.
+			m_Stream.reset(m_StreamStack.top().Stream); // Destructs the current m_Stream and takes back ownership and management of the raw StreamInfo std::istream pointer.
 			m_FilePath = m_StreamStack.top().FilePath;
 			m_CurrentLine = m_StreamStack.top().CurrentLine;
 			m_PreviousIndent = m_StreamStack.top().PreviousIndent;

System/Reader.h

@@ -26,7 +26,16 @@ namespace RTE {
 		/// <param name="progressCallback">A function pointer to a function that will be called and sent a string with information about the progress of this Reader's reading.</param>
 		/// <param name="failOK">Whether it's ok for the file to not be there, ie we're only trying to open, and if it's not there, then fail silently.</param>
 		/// <param name="nonModulePath">Whether this Reader is reading from path that is not a DataModule and should just read it as provided.</param>
-		Reader(const std::string &fileName, bool overwrites = false, const ProgressCallback &progressCallback = nullptr, bool failOK = false, bool nonModulePath = false) { Clear(); m_NonModulePath = nonModulePath; Create(fileName, overwrites, progressCallback, failOK); }
+		Reader(const std::string &fileName, bool overwrites = false, const ProgressCallback &progressCallback = nullptr, bool failOK = false, bool nonModulePath = false);
+
+		/// <summary>
+		/// Constructor method used to instantiate a Reader object in system memory and make it ready for reading from the passed in file path.
+		/// </summary>
+		/// <param name="stream">Stream to read from.</param>
+		/// <param name="overwrites">Whether object definitions read here overwrite existing ones with the same names.</param>
+		/// <param name="progressCallback">A function pointer to a function that will be called and sent a string with information about the progress of this Reader's reading.</param>
+		/// <param name="failOK">Whether it's ok for the file to not be there, ie we're only trying to open, and if it's not there, then fail silently.</param>
+		Reader(std::unique_ptr<std::istream> &&stream, bool overwrites = false, const ProgressCallback &progressCallback = nullptr, bool failOK = false);
 
 		/// <summary>
 		/// Makes the Reader object ready for use.
@@ -37,6 +46,16 @@ namespace RTE {
 		/// <param name="failOK">Whether it's ok for the file to not be there, ie we're only trying to open, and if it's not there, then fail silently.</param>
 		/// <returns>An error return value signaling success or any particular failure.  Anything below 0 is an error signal.</returns>
 		int Create(const std::string &fileName, bool overwrites = false, const ProgressCallback &progressCallback = nullptr, bool failOK = false);
+
+		/// <summary>
+		/// Makes the Reader object ready for use.
+		/// </summary>
+		/// <param name="stream">Stream to read from.</param>
+		/// <param name="overwrites"> Whether object definitions read here overwrite existing ones with the same names.</param>
+		/// <param name="progressCallback">A function pointer to a function that will be called and sent a string with information about the progress of this Reader's reading.</param>
+		/// <param name="failOK">Whether it's ok for the file to not be there, ie we're only trying to open, and if it's not there, then fail silently.</param>
+		/// <returns>An error return value signaling success or any particular failure.  Anything below 0 is an error signal.</returns>
+		int Create(std::unique_ptr<std::istream> &&stream, bool overwrites = false, const ProgressCallback &progressCallback = nullptr, bool failOK = false);
 #pragma endregion
 
 #pragma region Getters and Setters
@@ -152,7 +171,7 @@ namespace RTE {
 		/// Shows whether this is still OK to read from. If file isn't present, etc, this will return false.
 		/// </summary>
 		/// <returns>Whether this Reader's stream is OK or not.</returns>
-		bool ReaderOK() const { return m_Stream.get() && !m_Stream->fail() && m_Stream->is_open(); }
+		bool ReaderOK() const { return m_Stream.get() && m_Stream->good(); }
 
 		/// <summary>
 		/// Makes an error message box pop up for the user that tells them something went wrong with the reading, and where.
@@ -192,16 +211,16 @@ namespace RTE {
 			/// <summary>
 			/// Constructor method used to instantiate a StreamInfo object in system memory.
 			/// </summary>
-			StreamInfo(std::ifstream *stream, const std::string &filePath, int currentLine, int prevIndent) : Stream(stream), FilePath(filePath), CurrentLine(currentLine), PreviousIndent(prevIndent) {}
+			StreamInfo(std::istream *stream, const std::string &filePath, int currentLine, int prevIndent) : Stream(stream), FilePath(filePath), CurrentLine(currentLine), PreviousIndent(prevIndent) {}
 
 			// NOTE: These members are owned by the reader that owns this struct, so are not deleted when this is destroyed.
-			std::ifstream *Stream; //!< Currently used stream, is not on the StreamStack until a new stream is opened.
+			std::istream *Stream; //!< Currently used stream, is not on the StreamStack until a new stream is opened.
 			std::string FilePath; //!< Currently used stream's filepath.
 			int CurrentLine; //!< The line number the stream is on.
 			int PreviousIndent; //!< Count of tabs encountered on the last line DiscardEmptySpace() discarded.
 		};
 
-		std::unique_ptr<std::ifstream> m_Stream; //!< Currently used stream, is not on the StreamStack until a new stream is opened.
+		std::unique_ptr<std::istream> m_Stream; //!< Currently used stream, is not on the StreamStack until a new stream is opened.
 		std::stack<StreamInfo> m_StreamStack; //!< Stack of open streams in this Reader, each one representing a file opened to read from within another.
 		bool m_EndOfStreams; //!< All streams have been depleted.
 

System/Writer.cpp

@@ -13,6 +13,20 @@ namespace RTE {
 		m_IndentCount = 0;
 	}
 
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	Writer::Writer(const std::string &fileName, bool append, bool createDir) {
+		Clear(); 
+		Create(fileName, append, createDir);
+	}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+	Writer::Writer(std::unique_ptr<std::ostream> &&stream) {
+		Clear();
+		Create(std::move(stream));
+	}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 	int Writer::Create(const std::string &fileName, bool append, bool createDir) {
@@ -23,13 +37,21 @@ namespace RTE {
 		m_FileName = m_FilePath.substr(slashPos + 1);
 		m_FolderPath = m_FilePath.substr(0, slashPos + 1);
 
-		if (createDir && !std::filesystem::exists(System::GetWorkingDirectory() + m_FolderPath)) { System::MakeDirectory(System::GetWorkingDirectory() + m_FolderPath); }
+		if (createDir && !std::filesystem::exists(System::GetWorkingDirectory() + m_FolderPath)) { 
+			System::MakeDirectory(System::GetWorkingDirectory() + m_FolderPath); 
+		}
+
+		return Create(std::make_unique<std::ofstream>(fileName, append ? (std::ios::out | std::ios::app | std::ios::ate) : (std::ios::out | std::ios::trunc)));
+	}
 
-		m_Stream = std::make_unique<std::ofstream>(fileName, append ? (std::ios::out | std::ios::app | std::ios::ate) : (std::ios::out | std::ios::trunc));
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+	int Writer::Create(std::unique_ptr<std::ostream> &&stream) {
+		m_Stream = std::move(stream);
 		if (!m_Stream->good()) {
 			return -1;
 		}
+
 		return 0;
 	}
 

System/Writer.h

@@ -22,7 +22,13 @@ namespace RTE {
 		/// <param name="filename">Path to the file to open for writing. If the directory doesn't exist the stream will fail to open.</param>
 		/// <param name="append">Whether to append to the file if it exists, or to overwrite it.</param>
 		/// <param name="createDir">Whether to create the directory path to the file name before attempting to open the stream, in case it doesn't exist.</param>
-		Writer(const std::string &fileName, bool append = false, bool createDir = false) { Clear(); Create(fileName, append, createDir); }
+		Writer(const std::string &fileName, bool append = false, bool createDir = false);
+
+		/// <summary>
+		/// Constructor method used to instantiate a Writer object in system memory and make it ready for writing to the passed in file path.
+		/// </summary>
+		/// <param name="stream">Stream to write to.</param>
+		Writer(std::unique_ptr<std::ostream> &&stream);
 
 		/// <summary>
 		/// Makes the Writer object ready for use.
@@ -32,6 +38,13 @@ namespace RTE {
 		/// <param name="createDir">Whether to create the directory path to the file name before attempting to open the stream, in case it doesn't exist.</param>
 		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
 		int Create(const std::string &fileName, bool append = false, bool createDir = false);
+
+		/// <summary>
+		/// Makes the Writer object ready for use.
+		/// </summary>
+		/// <param name="stream">Stream to write to.</param>
+		/// <returns>An error return value signaling success or any particular failure. Anything below 0 is an error signal.</returns>
+		int Create(std::unique_ptr<std::ostream> &&stream);
 #pragma endregion
 
 #pragma region Getters
@@ -111,12 +124,12 @@ namespace RTE {
 		/// Shows whether the writer is ready to start accepting data streamed to it.
 		/// </summary>
 		/// <returns>Whether the writer is ready to start accepting data streamed to it or not.</returns>
-		bool WriterOK() const { return m_Stream.get() && !m_Stream->fail() && m_Stream->is_open(); }
+		bool WriterOK() const { return m_Stream.get() && m_Stream->good(); }
 
 		/// <summary>
 		/// Flushes and closes the output stream of this Writer. This happens automatically at destruction but needs to be called manually if a written file must be read from in the same scope.
 		/// </summary>
-		void EndWrite() const { m_Stream->flush(); m_Stream->close(); }
+		void EndWrite() { m_Stream->flush(); m_Stream.reset(); }
 #pragma endregion
 
 #pragma region Operator Overloads
@@ -144,7 +157,7 @@ namespace RTE {
 
 	protected:
 
-		std::unique_ptr<std::ofstream> m_Stream; //!< Stream used for writing to files.
+		std::unique_ptr<std::ostream> m_Stream; //!< Stream used for writing.
 		std::string m_FilePath; //!< Currently used stream's filepath.
 		std::string m_FolderPath; //!< Only the path to the folder that we are writing a file in, excluding the filename.
 		std::string m_FileName; //!< Only the name of the currently read file, excluding the path.