From 9c10729f007aad4b75d9a3dbdf01b39a193e069c Mon Sep 17 00:00:00 2001 From: Alexander Harkness Date: Sun, 24 Nov 2013 14:22:15 +0000 Subject: Moved iniFile --- lib/inifile/iniFile.cpp | 807 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 807 insertions(+) create mode 100644 lib/inifile/iniFile.cpp (limited to 'lib/inifile/iniFile.cpp') diff --git a/lib/inifile/iniFile.cpp b/lib/inifile/iniFile.cpp new file mode 100644 index 000000000..da523e783 --- /dev/null +++ b/lib/inifile/iniFile.cpp @@ -0,0 +1,807 @@ +// IniFile.cpp: Implementation of the CIniFile class. +// Written by: Adam Clauss +// Email: cabadam@houston.rr.com +// You may use this class/code as you wish in your programs. Feel free to distribute it, and +// email suggested changes to me. +// +// Rewritten by: Shane Hill +// Date: 21/08/2001 +// Email: Shane.Hill@dsto.defence.gov.au +// Reason: Remove dependancy on MFC. Code should compile on any +// platform. +////////////////////////////////////////////////////////////////////// + +/* +!! MODIFIED BY FAKETRUTH and xoft !! +*/ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +// C++ Includes +#include + +// C Includes +#include + +// Local Includes +#include "iniFile.h" + +#if defined(WIN32) + #define iniEOL endl +#else + #define iniEOL '\r' << endl +#endif + +#ifndef _WIN32 + #define sscanf_s(buffer, stringbuffer, ...) (sscanf(buffer, stringbuffer, __VA_ARGS__)) +#endif + +using namespace std; + + + + + +cIniFile::cIniFile(void) : + m_IsCaseInsensitive(true) +{ +} + + + + + +bool cIniFile::ReadFile(const AString & a_FileName, bool a_AllowExampleRedirect) +{ + // Normally you would use ifstream, but the SGI CC compiler has + // a few bugs with ifstream. So ... fstream used. + fstream f; + AString line; + AString keyname, valuename, value; + AString::size_type pLeft, pRight; + bool IsFromExampleRedirect = false; + + f.open((FILE_IO_PREFIX + a_FileName).c_str(), ios::in); + if (f.fail()) + { + f.clear(); + if (a_AllowExampleRedirect) + { + // Retry with the .example.ini file instead of .ini: + AString ExPath(a_FileName.substr(0, a_FileName.length() - 4)); + ExPath.append(".example.ini"); + f.open((FILE_IO_PREFIX + ExPath).c_str(), ios::in); + if (f.fail()) + { + return false; + } + IsFromExampleRedirect = true; + } + else + { + return false; + } + } + + while (getline(f, line)) + { + // To be compatible with Win32, check for existence of '\r'. + // Win32 files have the '\r' and Unix files don't at the end of a line. + // Note that the '\r' will be written to INI files from + // Unix so that the created INI file can be read under Win32 + // without change. + size_t lineLength = line.length(); + if (lineLength == 0) + { + continue; + } + if (line[lineLength - 1] == '\r') + { + line = line.substr(0, lineLength - 1); + } + + if (line.length() == 0) + { + continue; + } + + // Check that the user hasn't opened a binary file by checking the first + // character of each line! + if (!isprint(line[0])) + { + printf("%s: Binary-check failed on char %d\n", __FUNCTION__, line[0]); + f.close(); + return false; + } + if ((pLeft = line.find_first_of(";#[=")) == AString::npos) + { + continue; + } + + switch (line[pLeft]) + { + case '[': + { + if ( + ((pRight = line.find_last_of("]")) != AString::npos) && + (pRight > pLeft) + ) + { + keyname = line.substr(pLeft + 1, pRight - pLeft - 1); + AddKeyName(keyname); + } + break; + } + + case '=': + { + valuename = line.substr(0, pLeft); + value = line.substr(pLeft + 1); + SetValue(keyname, valuename, value); + break; + } + + case ';': + case '#': + { + if (names.size() == 0) + { + AddHeaderComment(line.substr(pLeft + 1)); + } + else + { + AddKeyComment(keyname, line.substr(pLeft + 1)); + } + break; + } + } // switch (line[pLeft]) + } // while (getline()) + + f.close(); + if (names.size() == 0) + { + return false; + } + + if (IsFromExampleRedirect) + { + WriteFile(FILE_IO_PREFIX + a_FileName); + } + return true; +} + + + + + +bool cIniFile::WriteFile(const AString & a_FileName) const +{ + // Normally you would use ofstream, but the SGI CC compiler has + // a few bugs with ofstream. So ... fstream used. + fstream f; + + f.open((FILE_IO_PREFIX + a_FileName).c_str(), ios::out); + if (f.fail()) + { + return false; + } + + // Write header comments. + size_t NumComments = comments.size(); + for (size_t commentID = 0; commentID < NumComments; ++commentID) + { + f << ';' << comments[commentID] << iniEOL; + } + if (NumComments > 0) + { + f << iniEOL; + } + + // Write keys and values. + for (size_t keyID = 0; keyID < keys.size(); ++keyID) + { + f << '[' << names[keyID] << ']' << iniEOL; + + // Comments. + for (size_t commentID = 0; commentID < keys[keyID].comments.size(); ++commentID) + { + f << ';' << keys[keyID].comments[commentID] << iniEOL; + } + + // Values. + for (size_t valueID = 0; valueID < keys[keyID].names.size(); ++valueID) + { + f << keys[keyID].names[valueID] << '=' << keys[keyID].values[valueID] << iniEOL; + } + f << iniEOL; + } + f.close(); + + return true; +} + + + + + +int cIniFile::FindKey(const AString & a_KeyName) const +{ + AString CaseKeyName = CheckCase(a_KeyName); + for (size_t keyID = 0; keyID < names.size(); ++keyID) + { + if (CheckCase(names[keyID]) == CaseKeyName) + { + return keyID; + } + } + return noID; +} + + + + + +int cIniFile::FindValue(const int keyID, const AString & a_ValueName) const +{ + if (!keys.size() || (keyID >= (int)keys.size())) + { + return noID; + } + + AString CaseValueName = CheckCase(a_ValueName); + for (size_t valueID = 0; valueID < keys[keyID].names.size(); ++valueID) + { + if (CheckCase(keys[keyID].names[valueID]) == CaseValueName) + { + return int(valueID); + } + } + return noID; +} + + + + + +int cIniFile::AddKeyName(const AString & keyname) +{ + names.resize(names.size() + 1, keyname); + keys.resize(keys.size() + 1); + return names.size() - 1; +} + + + + + +AString cIniFile::GetKeyName(const int keyID) const +{ + if (keyID < (int)names.size()) + { + return names[keyID]; + } + else + { + return ""; + } +} + + + + + +int cIniFile::GetNumValues(const int keyID) const +{ + if (keyID < (int)keys.size()) + { + return (int)keys[keyID].names.size(); + } + return 0; +} + + + + + +int cIniFile::GetNumValues(const AString & keyname) const +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return 0; + } + return (int)keys[keyID].names.size(); +} + + + + + +AString cIniFile::GetValueName(const int keyID, const int valueID) const +{ + if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size())) + { + return keys[keyID].names[valueID]; + } + return ""; +} + + + + + +AString cIniFile::GetValueName(const AString & keyname, const int valueID) const +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return ""; + } + return GetValueName(keyID, valueID); +} + + + + + +bool cIniFile::SetValue(const int keyID, const int valueID, const AString & value) +{ + if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size())) + { + keys[keyID].values[valueID] = value; + } + return false; +} + + + + + +bool cIniFile::SetValue(const AString & keyname, const AString & valuename, const AString & value, bool const create) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + if (create) + { + keyID = int(AddKeyName(keyname)); + } + else + { + return false; + } + } + + int valueID = FindValue(int(keyID), valuename); + if (valueID == noID) + { + if (!create) + { + return false; + } + keys[keyID].names.resize(keys[keyID].names.size() + 1, valuename); + keys[keyID].values.resize(keys[keyID].values.size() + 1, value); + } + else + { + if (!create) + { + keys[keyID].values[valueID] = value; + } + else + { + keys[keyID].names.resize(keys[keyID].names.size() + 1, valuename); + keys[keyID].values.resize(keys[keyID].values.size() + 1, value); + } + } + + return true; +} + + + + + +bool cIniFile::SetValueI(const AString & keyname, const AString & valuename, const int value, bool const create) +{ + AString Data; + Printf(Data, "%d", value); + return SetValue(keyname, valuename, Data, create); +} + + + + + +bool cIniFile::SetValueF(const AString & keyname, const AString & valuename, double const value, bool const create) +{ + AString Data; + Printf(Data, "%f", value); + return SetValue(keyname, valuename, Data, create); +} + + + + + +bool cIniFile::SetValueV(const AString & keyname, const AString & valuename, char * format, ...) +{ + va_list args; + va_start(args, format); + + AString Data; + AppendVPrintf(Data, format, args); + va_end(args); + return SetValue(keyname, valuename, Data); +} + + + + + +AString cIniFile::GetValue(const int keyID, const int valueID, const AString & defValue) const +{ + if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size())) + { + return keys[keyID].values[valueID]; + } + return defValue; +} + + + + + +AString cIniFile::GetValue(const AString & keyname, const AString & valuename, const AString & defValue) const +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return defValue; + } + + int valueID = FindValue(int(keyID), valuename); + if (valueID == noID) + { + return defValue; + } + + return keys[keyID].values[valueID]; +} + + + + + +int cIniFile::GetValueI(const AString & keyname, const AString & valuename, const int defValue) const +{ + AString Data; + Printf(Data, "%d", defValue); + return atoi(GetValue(keyname, valuename, Data).c_str()); +} + + + + + +double cIniFile::GetValueF(const AString & keyname, const AString & valuename, double const defValue) const +{ + AString Data; + Printf(Data, "%f", defValue); + return atof(GetValue(keyname, valuename, Data).c_str()); +} + + + + + +AString cIniFile::GetValueSet(const AString & keyname, const AString & valuename, const AString & defValue) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + SetValue(keyname, valuename, defValue); + return defValue; + } + + int valueID = FindValue(int(keyID), valuename); + if (valueID == noID) + { + SetValue(keyname, valuename, defValue); + return defValue; + } + + return keys[keyID].values[valueID]; +} + + + + + +double cIniFile::GetValueSetF(const AString & keyname, const AString & valuename, const double defValue) +{ + AString Data; + Printf(Data, "%f", defValue); + return atof(GetValueSet(keyname, valuename, Data).c_str()); +} + + + + + +int cIniFile::GetValueSetI(const AString & keyname, const AString & valuename, const int defValue) +{ + AString Data; + Printf(Data, "%d", defValue); + return atoi(GetValueSet(keyname, valuename, Data).c_str()); +} + + + + + +bool cIniFile::DeleteValueByID(const int keyID, const int valueID) +{ + if ((keyID < (int)keys.size()) && (valueID < (int)keys[keyID].names.size())) + { + // This looks strange, but is neccessary. + vector::iterator npos = keys[keyID].names.begin() + valueID; + vector::iterator vpos = keys[keyID].values.begin() + valueID; + keys[keyID].names.erase(npos, npos + 1); + keys[keyID].values.erase(vpos, vpos + 1); + return true; + } + return false; +} + + + + + +bool cIniFile::DeleteValue(const AString & keyname, const AString & valuename) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return false; + } + + int valueID = FindValue(int(keyID), valuename); + if (valueID == noID) + { + return false; + } + + return DeleteValueByID(keyID, valueID); +} + + + + + +bool cIniFile::DeleteKey(const AString & keyname) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return false; + } + + vector::iterator npos = names.begin() + keyID; + vector::iterator kpos = keys.begin() + keyID; + names.erase(npos, npos + 1); + keys.erase(kpos, kpos + 1); + + return true; +} + + + + + +void cIniFile::Clear(void) +{ + names.clear(); + keys.clear(); + comments.clear(); +} + + + + + +void cIniFile::AddHeaderComment(const AString & comment) +{ + comments.push_back(comment); + // comments.resize(comments.size() + 1, comment); +} + + + + + +AString cIniFile::GetHeaderComment(const int commentID) const +{ + if (commentID < (int)comments.size()) + { + return comments[commentID]; + } + return ""; +} + + + + + +bool cIniFile::DeleteHeaderComment(int commentID) +{ + if (commentID < (int)comments.size()) + { + vector::iterator cpos = comments.begin() + commentID; + comments.erase(cpos, cpos + 1); + return true; + } + return false; +} + + + + + +int cIniFile::GetNumKeyComments(const int keyID) const +{ + if (keyID < (int)keys.size()) + { + return keys[keyID].comments.size(); + } + return 0; +} + + + + + +int cIniFile::GetNumKeyComments(const AString & keyname) const +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return 0; + } + return (int)keys[keyID].comments.size(); +} + + + + + +bool cIniFile::AddKeyComment(const int keyID, const AString & comment) +{ + if (keyID < (int)keys.size()) + { + keys[keyID].comments.resize(keys[keyID].comments.size() + 1, comment); + return true; + } + return false; +} + + + + + +bool cIniFile::AddKeyComment(const AString & keyname, const AString & comment) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return false; + } + return AddKeyComment(keyID, comment); +} + + + + + +AString cIniFile::GetKeyComment(const int keyID, const int commentID) const +{ + if ((keyID < (int)keys.size()) && (commentID < (int)keys[keyID].comments.size())) + { + return keys[keyID].comments[commentID]; + } + return ""; +} + + + + + +AString cIniFile::GetKeyComment(const AString & keyname, const int commentID) const +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return ""; + } + return GetKeyComment(int(keyID), commentID); +} + + + + + +bool cIniFile::DeleteKeyComment(const int keyID, const int commentID) +{ + if ((keyID < (int)keys.size()) && (commentID < (int)keys[keyID].comments.size())) + { + vector::iterator cpos = keys[keyID].comments.begin() + commentID; + keys[keyID].comments.erase(cpos, cpos + 1); + return true; + } + return false; +} + + + + + +bool cIniFile::DeleteKeyComment(const AString & keyname, const int commentID) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return false; + } + return DeleteKeyComment(int(keyID), commentID); +} + + + + + +bool cIniFile::DeleteKeyComments(const int keyID) +{ + if (keyID < (int)keys.size()) + { + keys[keyID].comments.clear(); + return true; + } + return false; +} + + + + + +bool cIniFile::DeleteKeyComments(const AString & keyname) +{ + int keyID = FindKey(keyname); + if (keyID == noID) + { + return false; + } + return DeleteKeyComments(int(keyID)); +} + + + + + +AString cIniFile::CheckCase(const AString & s) const +{ + if (!m_IsCaseInsensitive) + { + return s; + } + AString res(s); + size_t len = res.length(); + for (size_t i = 0; i < len; i++) + { + res[i] = tolower(res[i]); + } + return res; +} + + + + -- cgit v1.2.3