Skip to content

GitLab

Commit f7dafc63 authored by llea's avatar llea
Browse files
Options

Remove CDataFile class. 

Add Point class for new skin config file.
Fix bug for recovering the line after two on/off-hold
parent ce595e1c
Hide whitespace changes
Inline Side-by-side
Showing with 223 additions and 1253 deletions
src/CDataFile.cpp deleted 100644 → 0
View file @ ce595e1c
//
// CDataFile Class Implementation
//
// The purpose of this class is to provide a simple, full featured means to
// store persistent data to a text file. It uses a simple key/value paradigm
// to achieve this. The class can read/write to standard Windows .ini files,
// and yet does not rely on any windows specific calls. It should work as
// well in a linux environment (with some minor adjustments) as it does in
// a Windows one.
//
// Written July, 2002 by Gary McNickle <gary#sunstorm.net>
// If you use this class in your application, credit would be appreciated.
//
//
// CDataFile
// The purpose of this class is to provide the means to easily store key/value
// pairs in a config file, seperated by independant sections. Sections may not
// have duplicate keys, although two or more sections can have the same key.
// Simple support for comments is included. Each key, and each section may have
// it's own multiline comment.
//
// An example might look like this;
//
// [UserSettings]
// Name=Joe User
// Date of Birth=12/25/01
//
// ;
// ; Settings unique to this server
// ;
// [ServerSettings]
// Port=1200
// IP_Address=127.0.0.1
// MachineName=ADMIN
//
#include <vector>
#include <string>
#include <ctype.h>
#include <stdio.h>
#include <stdarg.h>
#include <fstream.h>
#include <float.h>
#include <iostream.h>
#ifdef WIN32
#include <windows.h>
#endif
#include "CDataFile.h"
// Compatibility Defines ////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
#ifdef WIN32
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#endif
// CDataFile
// Our default contstructor. If it can load the file, it will do so and populate
// the section list with the values from the file.
CDataFile::CDataFile(t_Str szFileName)
{
m_bDirty = false;
m_szFileName = szFileName;
m_Flags = (AUTOCREATE_SECTIONS | AUTOCREATE_KEYS);
m_Sections.push_back( *(new t_Section) );
Load(m_szFileName);
}
CDataFile::CDataFile()
{
Clear();
m_Flags = (AUTOCREATE_SECTIONS | AUTOCREATE_KEYS);
m_Sections.push_back( *(new t_Section) );
}
// ~CDataFile
// Saves the file if any values have changed since the last save.
CDataFile::~CDataFile()
{
if ( m_bDirty )
Save();
}
// Clear
// Resets the member variables to their defaults
void CDataFile::Clear()
{
m_bDirty = false;
m_szFileName = t_Str("");
m_Sections.clear();
}
// SetFileName
// Set's the m_szFileName member variable. For use when creating the CDataFile
// object by hand (-vs- loading it from a file
void CDataFile::SetFileName(t_Str szFileName)
{
if (m_szFileName.size() != 0 && CompareNoCase(szFileName, m_szFileName) != 0)
{
m_bDirty = true;
Report(E_WARN, "[CDataFile::SetFileName] The filename has changed from <%s> to <%s>.",
m_szFileName.c_str(), szFileName.c_str());
}
m_szFileName = szFileName;
}
// Load
// Attempts to load in the text file. If successful it will populate the
// Section list with the key/value pairs found in the file. Note that comments
// are saved so that they can be rewritten to the file later.
bool CDataFile::Load(t_Str szFileName)
{
// We dont want to create a new file here. If it doesn't exist, just
// return false and report the failure.
fstream File(szFileName.c_str(), ios::in /* | ios::nocreate */ );
if ( File.is_open() )
{
bool bDone = false;
bool bAutoKey = (m_Flags & AUTOCREATE_KEYS) == AUTOCREATE_KEYS;
bool bAutoSec = (m_Flags & AUTOCREATE_SECTIONS) == AUTOCREATE_SECTIONS;
t_Str szLine;
t_Str szComment;
char buffer[MAX_BUFFER_LEN];
t_Section* pSection = GetSection("");
// These need to be set, we'll restore the original values later.
m_Flags |= AUTOCREATE_KEYS;
m_Flags |= AUTOCREATE_SECTIONS;
while ( !bDone )
{
memset(buffer, 0, MAX_BUFFER_LEN);
File.getline(buffer, MAX_BUFFER_LEN);
szLine = buffer;
Trim(szLine);
bDone = ( File.eof() || File.bad() || File.fail() );
if ( szLine.find_first_of(CommentIndicators) == 0 )
{
szComment += "\n";
szComment += szLine;
}
else
if ( szLine.find_first_of('[') == 0 ) // new section
{
szLine.erase( 0, 1 );
szLine.erase( szLine.find_last_of(']'), 1 );
CreateSection(szLine, szComment);
pSection = GetSection(szLine);
szComment = t_Str("");
}
else
if ( szLine.size() > 0 ) // we have a key, add this key/value pair
{
t_Str szKey = GetNextWord(szLine);
t_Str szValue = szLine;
if ( szKey.size() > 0 && szValue.size() > 0 )
{
SetValue(szKey, szValue, szComment, pSection->szName);
szComment = t_Str("");
}
}
}
// Restore the original flag values.
if ( !bAutoKey )
m_Flags &= ~AUTOCREATE_KEYS;
if ( !bAutoSec )
m_Flags &= ~AUTOCREATE_SECTIONS;
}
else
{
Report(E_INFO, "[CDataFile::Load] Unable to open file. Does it exist?");
return false;
}
File.close();
return true;
}
// Save
// Attempts to save the Section list and keys to the file. Note that if Load
// was never called (the CDataFile object was created manually), then you
// must set the m_szFileName variable before calling save.
bool CDataFile::Save()
{
if ( KeyCount() == 0 && SectionCount() == 0 )
{
// no point in saving
Report(E_INFO, "[CDataFile::Save] Nothing to save.");
return false;
}
if ( m_szFileName.size() == 0 )
{
Report(E_ERROR, "[CDataFile::Save] No filename has been set.");
return false;
}
fstream File(m_szFileName.c_str(), ios::out|ios::trunc);
if ( File.is_open() )
{
SectionItor s_pos;
KeyItor k_pos;
t_Section Section;
t_Key Key;
for (s_pos = m_Sections.begin(); s_pos != m_Sections.end(); s_pos++)
{
Section = (*s_pos);
bool bWroteComment = false;
if ( Section.szComment.size() > 0 )
{
bWroteComment = true;
WriteLn(File, "\n%s", CommentStr(Section.szComment).c_str());
}
if ( Section.szName.size() > 0 )
{
WriteLn(File, "%s[%s]",
bWroteComment ? "" : "\n",
Section.szName.c_str());
}
for (k_pos = Section.Keys.begin(); k_pos != Section.Keys.end(); k_pos++)
{
Key = (*k_pos);
if ( Key.szKey.size() > 0 && Key.szValue.size() > 0 )
{
WriteLn(File, "%s%s%s%s%c%s",
Key.szComment.size() > 0 ? "\n" : "",
CommentStr(Key.szComment).c_str(),
Key.szComment.size() > 0 ? "\n" : "",
Key.szKey.c_str(),
EqualIndicators[0],
Key.szValue.c_str());
}
}
}
}
else
{
Report(E_ERROR, "[CDataFile::Save] Unable to save file.");
return false;
}
m_bDirty = false;
File.flush();
File.close();
return true;
}
// SetKeyComment
// Set the comment of a given key. Returns true if the key is not found.
bool CDataFile::SetKeyComment(t_Str szKey, t_Str szComment, t_Str szSection)
{
KeyItor k_pos;
t_Section* pSection;
if ( (pSection = GetSection(szSection)) == NULL )
return false;
for (k_pos = pSection->Keys.begin(); k_pos != pSection->Keys.end(); k_pos++)
{
if ( CompareNoCase( (*k_pos).szKey, szKey ) == 0 )
{
(*k_pos).szComment = szComment;
m_bDirty = true;
return true;
}
}
return false;
}
// SetSectionComment
// Set the comment for a given section. Returns false if the section
// was not found.
bool CDataFile::SetSectionComment(t_Str szSection, t_Str szComment)
{
SectionItor s_pos;
for (s_pos = m_Sections.begin(); s_pos != m_Sections.end(); s_pos++)
{
if ( CompareNoCase( (*s_pos).szName, szSection ) == 0 )
{
(*s_pos).szComment = szComment;
m_bDirty = true;
return true;
}
}
return false;
}
// SetValue
// Given a key, a value and a section, this function will attempt to locate the
// Key within the given section, and if it finds it, change the keys value to
// the new value. If it does not locate the key, it will create a new key with
// the proper value and place it in the section requested.
bool CDataFile::SetValue(t_Str szKey, t_Str szValue, t_Str szComment, t_Str szSection)
{
t_Key* pKey = GetKey(szKey, szSection);
t_Section* pSection = GetSection(szSection);
if (pSection == NULL)
{
if ( !(m_Flags & AUTOCREATE_SECTIONS) || !CreateSection(szSection,""))
return false;
pSection = GetSection(szSection);
}
// Sanity check...
if ( pSection == NULL )
return false;
// if the key does not exist in that section, and the value passed
// is not t_Str("") then add the new key.
if ( pKey == NULL && szValue.size() > 0 && (m_Flags & AUTOCREATE_KEYS))
{
pKey = new t_Key;
pKey->szKey = szKey;
pKey->szValue = szValue;
pKey->szComment = szComment;
m_bDirty = true;
pSection->Keys.push_back(*pKey);
return true;
}
if ( pKey != NULL )
{
pKey->szValue = szValue;
pKey->szComment = szComment;
m_bDirty = true;
return true;
}
return false;
}
// SetFloat
// Passes the given float to SetValue as a string
bool CDataFile::SetFloat(t_Str szKey, float fValue, t_Str szComment, t_Str szSection)
{
char szStr[64];
snprintf(szStr, 64, "%f", fValue);
return SetValue(szKey, szStr, szComment, szSection);
}
// SetInt
// Passes the given int to SetValue as a string
bool CDataFile::SetInt(t_Str szKey, int nValue, t_Str szComment, t_Str szSection)
{
char szStr[64];
snprintf(szStr, 64, "%d", nValue);
return SetValue(szKey, szStr, szComment, szSection);
}
// SetBool
// Passes the given bool to SetValue as a string
bool CDataFile::SetBool(t_Str szKey, bool bValue, t_Str szComment, t_Str szSection)
{
t_Str szValue = bValue ? "True" : "False";
return SetValue(szKey, szValue, szComment, szSection);
}
// GetValue
// Returns the key value as a t_Str object. A return value of
// t_Str("") indicates that the key could not be found.
t_Str CDataFile::GetValue(t_Str szKey, t_Str szSection)
{
t_Key* pKey = GetKey(szKey, szSection);
return (pKey == NULL) ? t_Str("") : pKey->szValue;
}
// GetString
// Returns the key value as a t_Str object. A return value of
// t_Str("") indicates that the key could not be found.
t_Str CDataFile::GetString(t_Str szKey, t_Str szSection)
{
return GetValue(szKey, szSection);
}
// GetFloat
// Returns the key value as a float type. Returns FLT_MIN if the key is
// not found.
float CDataFile::GetFloat(t_Str szKey, t_Str szSection)
{
t_Str szValue = GetValue(szKey, szSection);
if ( szValue.size() == 0 )
return FLT_MIN;
return (float)atof( szValue.c_str() );
}
// GetInt
// Returns the key value as an integer type. Returns INT_MIN if the key is
// not found.
int CDataFile::GetInt(t_Str szKey, t_Str szSection)
{
t_Str szValue = GetValue(szKey, szSection);
if ( szValue.size() == 0 )
return INT_MIN;
return atoi( szValue.c_str() );
}
// GetBool
// Returns the key value as a bool type. Returns false if the key is
// not found.
bool CDataFile::GetBool(t_Str szKey, t_Str szSection)
{
bool bValue = false;
t_Str szValue = GetValue(szKey, szSection);
if ( szValue.find("1") == 0
|| CompareNoCase(szValue, "true")
|| CompareNoCase(szValue, "yes") )
{
bValue = true;
}
return bValue;
}
// DeleteSection
// Delete a specific section. Returns false if the section cannot be
// found or true when sucessfully deleted.
bool CDataFile::DeleteSection(t_Str szSection)
{
SectionItor s_pos;
for (s_pos = m_Sections.begin(); s_pos != m_Sections.end(); s_pos++)
{
if ( CompareNoCase( (*s_pos).szName, szSection ) == 0 )
{
m_Sections.erase(s_pos);
return true;
}
}
return false;
}
// DeleteKey
// Delete a specific key in a specific section. Returns false if the key
// cannot be found or true when sucessfully deleted.
bool CDataFile::DeleteKey(t_Str szKey, t_Str szFromSection)
{
KeyItor k_pos;
t_Section* pSection;
if ( (pSection = GetSection(szFromSection)) == NULL )
return false;
for (k_pos = pSection->Keys.begin(); k_pos != pSection->Keys.end(); k_pos++)
{
if ( CompareNoCase( (*k_pos).szKey, szKey ) == 0 )
{
pSection->Keys.erase(k_pos);
return true;
}
}
return false;
}
// CreateKey
// Given a key, a value and a section, this function will attempt to locate the
// Key within the given section, and if it finds it, change the keys value to
// the new value. If it does not locate the key, it will create a new key with
// the proper value and place it in the section requested.
bool CDataFile::CreateKey(t_Str szKey, t_Str szValue, t_Str szComment, t_Str szSection)
{
bool bAutoKey = (m_Flags & AUTOCREATE_KEYS) == AUTOCREATE_KEYS;
bool bReturn = false;
m_Flags |= AUTOCREATE_KEYS;
bReturn = SetValue(szKey, szValue, szComment, szSection);
if ( !bAutoKey )
m_Flags &= ~AUTOCREATE_KEYS;
return bReturn;
}
// CreateSection
// Given a section name, this function first checks to see if the given section
// allready exists in the list or not, if not, it creates the new section and
// assigns it the comment given in szComment. The function returns true if
// sucessfully created, or false otherwise.
bool CDataFile::CreateSection(t_Str szSection, t_Str szComment)
{
t_Section* pSection = GetSection(szSection);
if ( pSection )
{
Report(E_INFO, "[CDataFile::CreateSection] Section <%s> allready exists. Aborting.", szSection.c_str());
return false;
}
pSection = new t_Section;
pSection->szName = szSection;
pSection->szComment = szComment;
m_Sections.push_back(*pSection);
m_bDirty = true;
return true;
}
// CreateSection
// Given a section name, this function first checks to see if the given section
// allready exists in the list or not, if not, it creates the new section and
// assigns it the comment given in szComment. The function returns true if
// sucessfully created, or false otherwise. This version accpets a KeyList
// and sets up the newly created Section with the keys in the list.
bool CDataFile::CreateSection(t_Str szSection, t_Str szComment, KeyList Keys)
{
if ( !CreateSection(szSection, szComment) )
return false;
t_Section* pSection = GetSection(szSection);
if ( !pSection )
return false;
KeyItor k_pos;
pSection->szName = szSection;
for (k_pos = Keys.begin(); k_pos != Keys.end(); k_pos++)
{
t_Key* pKey = new t_Key;
pKey->szComment = (*k_pos).szComment;
pKey->szKey = (*k_pos).szKey;
pKey->szValue = (*k_pos).szValue;
pSection->Keys.push_back(*pKey);
}
m_Sections.push_back(*pSection);
m_bDirty = true;
return true;
}
// SectionCount
// Simply returns the number of sections in the list.
int CDataFile::SectionCount()
{
return m_Sections.size();
}
// KeyCount
// Returns the total number of keys contained within all the sections.
int CDataFile::KeyCount()
{
int nCounter = 0;
SectionItor s_pos;
for (s_pos = m_Sections.begin(); s_pos != m_Sections.end(); s_pos++)
nCounter += (*s_pos).Keys.size();
return nCounter;
}
// Protected Member Functions ///////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// GetKey
// Given a key and section name, looks up the key and if found, returns a
// pointer to that key, otherwise returns NULL.
t_Key* CDataFile::GetKey(t_Str szKey, t_Str szSection)
{
KeyItor k_pos;
t_Section* pSection;
// Since our default section has a name value of t_Str("") this should
// always return a valid section, wether or not it has any keys in it is
// another matter.
if ( (pSection = GetSection(szSection)) == NULL )
return NULL;
for (k_pos = pSection->Keys.begin(); k_pos != pSection->Keys.end(); k_pos++)
{