#include <calibration.hpp>

Classes
class	Converter

struct	Entry

class	FileWriter

class	OutputWriter

class	StreamWriter

class	StringWriter

Public Types
typedef SI_CHAR	SI_CHAR_T

typedef std::multimap< Entry, const SI_CHAR *, typename Entry::KeyOrder >	TKeyVal

typedef std::map< Entry, TKeyVal, typename Entry::KeyOrder >	TSection

typedef std::list< Entry >	TNamesDepend

Public Member Functions
	CSimpleIniTempl (bool a_bIsUtf8=false, bool a_bMultiKey=false, bool a_bMultiLine=false)

	~CSimpleIniTempl ()

void	Reset ()

bool	IsEmpty () const

SI_Error	LoadFile (const char *a_pszFile)

SI_Error	LoadFile (const SI_WCHAR_T *a_pwszFile)

SI_Error	LoadFile (FILE *a_fpFile)

SI_Error	LoadData (std::istream &a_istream)

SI_Error	LoadData (const std::string &a_strData)

SI_Error	LoadData (const char *a_pData, size_t a_uDataLen)

SI_Error	SaveFile (const char *a_pszFile, bool a_bAddSignature=true) const

SI_Error	SaveFile (const SI_WCHAR_T *a_pwszFile, bool a_bAddSignature=true) const

SI_Error	SaveFile (FILE *a_pFile, bool a_bAddSignature=false) const

SI_Error	Save (OutputWriter &a_oOutput, bool a_bAddSignature=false) const

SI_Error	Save (std::ostream &a_ostream, bool a_bAddSignature=false) const

SI_Error	Save (std::string &a_sBuffer, bool a_bAddSignature=false) const

void	GetAllSections (TNamesDepend &a_names) const

bool	GetAllKeys (const SI_CHAR *a_pSection, TNamesDepend &a_names) const

bool	GetAllValues (const SI_CHAR a_pSection, const SI_CHAR a_pKey, TNamesDepend &a_values) const

int	GetSectionSize (const SI_CHAR *a_pSection) const

const TKeyVal *	GetSection (const SI_CHAR *a_pSection) const

const SI_CHAR *	GetValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, const SI_CHAR a_pDefault=NULL, bool a_pHasMultiple=NULL) const

long	GetLongValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, long a_nDefault=0, bool *a_pHasMultiple=NULL) const

double	GetDoubleValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, double a_nDefault=0, bool *a_pHasMultiple=NULL) const

bool	GetBoolValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, bool a_bDefault=false, bool *a_pHasMultiple=NULL) const

SI_Error	SetValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, const SI_CHAR a_pValue, const SI_CHAR a_pComment=NULL, bool a_bForceReplace=false)

SI_Error	SetLongValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, long a_nValue, const SI_CHAR *a_pComment=NULL, bool a_bUseHex=false, bool a_bForceReplace=false)

SI_Error	SetDoubleValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, double a_nValue, const SI_CHAR *a_pComment=NULL, bool a_bForceReplace=false)

SI_Error	SetBoolValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, bool a_bValue, const SI_CHAR *a_pComment=NULL, bool a_bForceReplace=false)

bool	Delete (const SI_CHAR a_pSection, const SI_CHAR a_pKey, bool a_bRemoveEmpty=false)

bool	DeleteValue (const SI_CHAR a_pSection, const SI_CHAR a_pKey, const SI_CHAR *a_pValue, bool a_bRemoveEmpty=false)

Converter	GetConverter () const

Settings
void	SetUnicode (bool a_bIsUtf8=true)

bool	IsUnicode () const

void	SetMultiKey (bool a_bAllowMultiKey=true)

bool	IsMultiKey () const

void	SetMultiLine (bool a_bAllowMultiLine=true)

bool	IsMultiLine () const

void	SetSpaces (bool a_bSpaces=true)

bool	UsingSpaces () const

Detailed Description

template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>
class sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >

Definition at line 127 of file calibration.hpp.

Member Typedef Documentation

◆ SI_CHAR_T

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

typedef SI_CHAR sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SI_CHAR_T

Definition at line 129 of file calibration.hpp.

◆ TKeyVal

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

typedef std::multimap<Entry, const SI_CHAR *, typename Entry::KeyOrder> sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::TKeyVal

map keys to values

Definition at line 194 of file calibration.hpp.

◆ TNamesDepend

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

typedef std::list<Entry> sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::TNamesDepend

set of dependent string pointers. Note that these pointers are dependent on memory owned by CSimpleIni.

Definition at line 202 of file calibration.hpp.

◆ TSection

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

typedef std::map<Entry, TKeyVal, typename Entry::KeyOrder> sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::TSection

map sections to key/value map

Definition at line 197 of file calibration.hpp.

Constructor & Destructor Documentation

◆ CSimpleIniTempl()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::CSimpleIniTempl	(	bool	a_bIsUtf8 = `false`,
		bool	a_bMultiKey = `false`,
		bool	a_bMultiLine = `false`
	)

Default constructor.

Parameters

a_bIsUtf8	See the method SetUnicode() for details.
a_bMultiKey	See the method SetMultiKey() for details.
a_bMultiLine	See the method SetMultiLine() for details.

Definition at line 1144 of file calibration.hpp.

 : m_pData(0)
 , m_uDataLen(0)
 , m_pFileComment(NULL)
 , m_bStoreIsUtf8(a_bIsUtf8)
 , m_bAllowMultiKey(a_bAllowMultiKey)
 , m_bAllowMultiLine(a_bAllowMultiLine)
 , m_bSpaces(true)
 , m_nOrder(0) {
 }

◆ ~CSimpleIniTempl()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::~CSimpleIniTempl

Destructor

Definition at line 1160 of file calibration.hpp.

                                                                      {
     Reset();
 }

Member Function Documentation

◆ Delete()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Delete	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		bool	a_bRemoveEmpty = `false`
	)

Delete an entire section, or a key from a section. Note that the data returned by GetSection is invalid and must not be used after anything has been deleted from that section using this method. Note when multiple keys is enabled, this will delete all keys with that name; to selectively delete individual key/values, use DeleteValue.

Parameters

a_pSection	Section to delete key from, or if a_pKey is NULL, the section to remove.
a_pKey	Key to remove from the section. Set to NULL to remove the entire section.
a_bRemoveEmpty	If the section is empty after this key has been deleted, should the empty section be removed?

Returns: true Key or section was deleted.; false Key or section was not found.

Definition at line 2384 of file calibration.hpp.

           {
     return DeleteValue(a_pSection, a_pKey, NULL, a_bRemoveEmpty);
 }

◆ DeleteValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::DeleteValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		const SI_CHAR *	a_pValue,
		bool	a_bRemoveEmpty = `false`
	)

Delete an entire section, or a key from a section. If value is provided, only remove keys with the value. Note that the data returned by GetSection is invalid and must not be used after anything has been deleted from that section using this method. Note when multiple keys is enabled, all keys with the value will be deleted.

Parameters

a_pSection	Section to delete key from, or if a_pKey is NULL, the section to remove.
a_pKey	Key to remove from the section. Set to NULL to remove the entire section.
a_pValue	Value of key to remove from the section. Set to NULL to remove all keys.
a_bRemoveEmpty	If the section is empty after this key has been deleted, should the empty section be removed?

Returns: true Key/value or section was deleted.; false Key/value or section was not found.

Definition at line 2394 of file calibration.hpp.

           {
     if (!a_pSection) {
         return false;
     }
  
     typename TSection::iterator iSection = m_data.find(a_pSection);
     if (iSection == m_data.end()) {
         return false;
     }
  
     // remove a single key if we have a keyname
     if (a_pKey) {
         typename TKeyVal::iterator iKeyVal = iSection->second.find(a_pKey);
         if (iKeyVal == iSection->second.end()) {
             return false;
         }
  
         const static SI_STRLESS isLess = SI_STRLESS();
  
         // remove any copied strings and then the key
         typename TKeyVal::iterator iDelete;
         bool bDeleted = false;
         do {
             iDelete = iKeyVal++;
  
             if (a_pValue == NULL ||
                     (isLess(a_pValue, iDelete->second) == false &&
                     isLess(iDelete->second, a_pValue) == false)) {
                 DeleteString(iDelete->first.pItem);
                 DeleteString(iDelete->second);
                 iSection->second.erase(iDelete);
                 bDeleted = true;
             }
         } while (iKeyVal != iSection->second.end()
                 && !IsLess(a_pKey, iKeyVal->first.pItem));
  
         if (!bDeleted) {
             return false;
         }
  
         // done now if the section is not empty or we are not pruning away
         // the empty sections. Otherwise let it fall through into the section
         // deletion code
         if (!a_bRemoveEmpty || !iSection->second.empty()) {
             return true;
         }
     } else {
         // delete all copied strings from this section. The actual
         // entries will be removed when the section is removed.
         typename TKeyVal::iterator iKeyVal = iSection->second.begin();
         for (; iKeyVal != iSection->second.end(); ++iKeyVal) {
             DeleteString(iKeyVal->first.pItem);
             DeleteString(iKeyVal->second);
         }
     }
  
     // delete the section itself
     DeleteString(iSection->first.pItem);
     m_data.erase(iSection);
  
     return true;
 }

◆ GetAllKeys()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetAllKeys	(	const SI_CHAR *	a_pSection,
		TNamesDepend &	a_names
	)		const

Retrieve all unique key names in a section. The sort order of the returned strings is NOT DEFINED. You can sort the names into the load order if desired. Search this file for ".sort" for an example. Only unique key names are returned.

NOTE! This structure contains only pointers to strings. The actual string data is stored in memory owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed or Reset() while these strings are in use!

Parameters

a_pSection	Section to request data for
a_names	List that will receive all of the key names. See note above!

Returns: true Section was found.; false Matching section was not found.

Definition at line 2143 of file calibration.hpp.

                 {
     a_names.clear();
  
     if (!a_pSection) {
         return false;
     }
  
     typename TSection::const_iterator iSection = m_data.find(a_pSection);
     if (iSection == m_data.end()) {
         return false;
     }
  
     const TKeyVal & section = iSection->second;
     const SI_CHAR * pLastKey = NULL;
     typename TKeyVal::const_iterator iKeyVal = section.begin();
     for (int n = 0; iKeyVal != section.end(); ++iKeyVal, ++n) {
         if (!pLastKey || IsLess(pLastKey, iKeyVal->first.pItem)) {
             a_names.push_back(iKeyVal->first);
             pLastKey = iKeyVal->first.pItem;
         }
     }
  
     return true;
 }

◆ GetAllSections()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

void sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetAllSections ( TNamesDepend & a_names ) const

Retrieve all section names. The list is returned as an STL vector of names and can be iterated or searched as necessary. Note that the sort order of the returned strings is NOT DEFINED. You can sort the names into the load order if desired. Search this file for ".sort" for an example.

NOTE! This structure contains only pointers to strings. The actual string data is stored in memory owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed or Reset() while these pointers are in use!

Parameters

a_names Vector that will receive all of the section names. See note above!

Definition at line 2131 of file calibration.hpp.

                 {
     a_names.clear();
     typename TSection::const_iterator i = m_data.begin();
     for (int n = 0; i != m_data.end(); ++i, ++n) {
         a_names.push_back(i->first);
     }
 }

◆ GetAllValues()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetAllValues	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		TNamesDepend &	a_values
	)		const

Retrieve all values for a specific key. This method can be used when multiple keys are both enabled and disabled. Note that the sort order of the returned strings is NOT DEFINED. You can sort the names into the load order if desired. Search this file for ".sort" for an example.

NOTE! The returned values are pointers to string data stored in memory owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed or Reset while you are using this pointer!

Parameters

a_pSection	Section to search
a_pKey	Key to search for
a_values	List to return if the key is not found

Returns: true Key was found.; false Matching section/key was not found.

Definition at line 2049 of file calibration.hpp.

                 {
     a_values.clear();
  
     if (!a_pSection || !a_pKey) {
         return false;
     }
     typename TSection::const_iterator iSection = m_data.find(a_pSection);
     if (iSection == m_data.end()) {
         return false;
     }
     typename TKeyVal::const_iterator iKeyVal = iSection->second.find(a_pKey);
     if (iKeyVal == iSection->second.end()) {
         return false;
     }
  
     // insert all values for this key
     a_values.push_back(Entry(iKeyVal->second, iKeyVal->first.pComment, iKeyVal->first.nOrder));
     if (m_bAllowMultiKey) {
         ++iKeyVal;
         while (iKeyVal != iSection->second.end() && !IsLess(a_pKey, iKeyVal->first.pItem)) {
             a_values.push_back(Entry(iKeyVal->second, iKeyVal->first.pComment, iKeyVal->first.nOrder));
             ++iKeyVal;
         }
     }
  
     return true;
 }

◆ GetBoolValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetBoolValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		bool	a_bDefault = `false`,
		bool *	a_pHasMultiple = `NULL`
	)		const

Retrieve a boolean value for a specific key. If multiple keys are enabled (see SetMultiKey) then only the first value associated with that key will be returned, see GetAllValues for getting all values with multikey.

Strings starting with "t", "y", "on" or "1" are returned as logically true. Strings starting with "f", "n", "of" or "0" are returned as logically false. For all other values the default is returned. Character comparisons are case-insensitive.

Parameters

a_pSection	Section to search
a_pKey	Key to search for
a_bDefault	Value to return if the key is not found
a_pHasMultiple	Optionally receive notification of if there are multiple entries for this key.

Returns: a_nDefault Key was not found in the section; other Value of the key

Definition at line 1990 of file calibration.hpp.

                 {
     // return the default if we don't have a value
     const SI_CHAR * pszValue = GetValue(a_pSection, a_pKey, NULL, a_pHasMultiple);
     if (!pszValue || !*pszValue) return a_bDefault;
  
     // we only look at the minimum number of characters
     switch (pszValue[0]) {
         case 't': case 'T': // true
         case 'y': case 'Y': // yes
         case '1': // 1 (one)
             return true;
  
         case 'f': case 'F': // false
         case 'n': case 'N': // no
         case '0': // 0 (zero)
             return false;
  
         case 'o': case 'O':
             if (pszValue[1] == 'n' || pszValue[1] == 'N') return true; // on
             if (pszValue[1] == 'f' || pszValue[1] == 'F') return false; // off
             break;
     }
  
     // no recognized value, return the default
     return a_bDefault;
 }

◆ GetConverter()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

Converter sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetConverter ( ) const

inline

Return a conversion object to convert text to the same encoding as is used by the Save(), SaveFile() and SaveString() functions. Use this to prepare the strings that you wish to append or prepend to the output INI data.

Definition at line 991 of file calibration.hpp.

                                    {
         return Converter(m_bStoreIsUtf8);
     }

◆ GetDoubleValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

double sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetDoubleValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		double	a_nDefault = `0`,
		bool *	a_pHasMultiple = `NULL`
	)		const

Retrieve a numeric value for a specific key. If multiple keys are enabled (see SetMultiKey) then only the first value associated with that key will be returned, see GetAllValues for getting all values with multikey.

Parameters

a_pSection	Section to search
a_pKey	Key to search for
a_nDefault	Value to return if the key is not found
a_pHasMultiple	Optionally receive notification of if there are multiple entries for this key.

Returns: a_nDefault Key was not found in the section; other Value of the key

Definition at line 1930 of file calibration.hpp.

                 {
     // return the default if we don't have a value
     const SI_CHAR * pszValue = GetValue(a_pSection, a_pKey, NULL, a_pHasMultiple);
     if (!pszValue || !*pszValue) return a_nDefault;
  
     // convert to UTF-8/MBCS which for a numeric value will be the same as ASCII
     char szValue[64] = {0};
     SI_CONVERTER c(m_bStoreIsUtf8);
     if (!c.ConvertToStore(pszValue, szValue, sizeof (szValue))) {
         return a_nDefault;
     }
  
     char * pszSuffix = NULL;
     double nValue = strtod(szValue, &pszSuffix);
  
     // any invalid strings will return the default value
     if (!pszSuffix || *pszSuffix) {
         return a_nDefault;
     }
  
     return nValue;
 }

◆ GetLongValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

long sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetLongValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		long	a_nDefault = `0`,
		bool *	a_pHasMultiple = `NULL`
	)		const

Retrieve a numeric value for a specific key. If multiple keys are enabled (see SetMultiKey) then only the first value associated with that key will be returned, see GetAllValues for getting all values with multikey.

Parameters

a_pSection	Section to search
a_pKey	Key to search for
a_nDefault	Value to return if the key is not found
a_pHasMultiple	Optionally receive notification of if there are multiple entries for this key.

Returns: a_nDefault Key was not found in the section; other Value of the key

Definition at line 1862 of file calibration.hpp.

                 {
     // return the default if we don't have a value
     const SI_CHAR * pszValue = GetValue(a_pSection, a_pKey, NULL, a_pHasMultiple);
     if (!pszValue || !*pszValue) return a_nDefault;
  
     // convert to UTF-8/MBCS which for a numeric value will be the same as ASCII
     char szValue[64] = {0};
     SI_CONVERTER c(m_bStoreIsUtf8);
     if (!c.ConvertToStore(pszValue, szValue, sizeof (szValue))) {
         return a_nDefault;
     }
  
     // handle the value as hex if prefaced with "0x"
     long nValue = a_nDefault;
     char * pszSuffix = szValue;
     if (szValue[0] == '0' && (szValue[1] == 'x' || szValue[1] == 'X')) {
         if (!szValue[2]) return a_nDefault;
         nValue = strtol(&szValue[2], &pszSuffix, 16);
     } else {
         nValue = strtol(szValue, &pszSuffix, 10);
     }
  
     // any invalid strings will return the default value
     if (*pszSuffix) {
         return a_nDefault;
     }
  
     return nValue;
 }

◆ GetSection()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

const CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::TKeyVal * sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetSection ( const SI_CHAR * a_pSection ) const

Retrieve all key and value pairs for a section. The data is returned as a pointer to an STL map and can be iterated or searched as desired. Note that multiple entries for the same key may exist when multiple keys have been enabled.

NOTE! This structure contains only pointers to strings. The actual string data is stored in memory owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed or Reset() while these strings are in use!

Parameters

a_pSection Name of the section to return

Returns: boolean Was a section matching the supplied name found.

Definition at line 2117 of file calibration.hpp.

                 {
     if (a_pSection) {
         typename TSection::const_iterator i = m_data.find(a_pSection);
         if (i != m_data.end()) {
             return &(i->second);
         }
     }
     return 0;
 }

◆ GetSectionSize()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

int sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetSectionSize ( const SI_CHAR * a_pSection ) const

Query the number of keys in a specific section. Note that if multiple keys are enabled, then this value may be different to the number of keys returned by GetAllKeys.

Parameters

a_pSection Section to request data for

Returns: -1 Section does not exist in the file; >=0 Number of keys in the section

Definition at line 2083 of file calibration.hpp.

                 {
     if (!a_pSection) {
         return -1;
     }
  
     typename TSection::const_iterator iSection = m_data.find(a_pSection);
     if (iSection == m_data.end()) {
         return -1;
     }
     const TKeyVal & section = iSection->second;
  
     // if multi-key isn't permitted then the section size is
     // the number of keys that we have.
     if (!m_bAllowMultiKey || section.empty()) {
         return (int) section.size();
     }
  
     // otherwise we need to count them
     int nCount = 0;
     const SI_CHAR * pLastKey = NULL;
     typename TKeyVal::const_iterator iKeyVal = section.begin();
     for (int n = 0; iKeyVal != section.end(); ++iKeyVal, ++n) {
         if (!pLastKey || IsLess(pLastKey, iKeyVal->first.pItem)) {
             ++nCount;
             pLastKey = iKeyVal->first.pItem;
         }
     }
     return nCount;
 }

◆ GetValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

const SI_CHAR * sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::GetValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		const SI_CHAR *	a_pDefault = `NULL`,
		bool *	a_pHasMultiple = `NULL`
	)		const

Retrieve the value for a specific key. If multiple keys are enabled (see SetMultiKey) then only the first value associated with that key will be returned, see GetAllValues for getting all values with multikey.

NOTE! The returned value is a pointer to string data stored in memory owned by CSimpleIni. Ensure that the CSimpleIni object is not destroyed or Reset while you are using this pointer!

Parameters

a_pSection	Section to search
a_pKey	Key to search for
a_pDefault	Value to return if the key is not found
a_pHasMultiple	Optionally receive notification of if there are multiple entries for this key.

Returns: a_pDefault Key was not found in the section; other Value of the key

Definition at line 1826 of file calibration.hpp.

                 {
     if (a_pHasMultiple) {
         *a_pHasMultiple = false;
     }
     if (!a_pSection || !a_pKey) {
         return a_pDefault;
     }
     typename TSection::const_iterator iSection = m_data.find(a_pSection);
     if (iSection == m_data.end()) {
         return a_pDefault;
     }
     typename TKeyVal::const_iterator iKeyVal = iSection->second.find(a_pKey);
     if (iKeyVal == iSection->second.end()) {
         return a_pDefault;
     }
  
     // check for multiple entries with the same key
     if (m_bAllowMultiKey && a_pHasMultiple) {
         typename TKeyVal::const_iterator iTemp = iKeyVal;
         if (++iTemp != iSection->second.end()) {
             if (!IsLess(a_pKey, iTemp->first.pItem)) {
                 *a_pHasMultiple = true;
             }
         }
     }
  
     return iKeyVal->second;
 }

Referenced by sl_oc::tools::ConfManager::getValue().

◆ IsEmpty()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::IsEmpty ( ) const

inline

Has any data been loaded

Definition at line 334 of file calibration.hpp.

                          {
         return m_data.empty();
     }

◆ IsMultiKey()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::IsMultiKey ( ) const

inline

Get the storage format of the INI data.

Definition at line 387 of file calibration.hpp.

                             {
         return m_bAllowMultiKey;
     }

◆ IsMultiLine()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::IsMultiLine ( ) const

inline

Query the status of multi-line data

Definition at line 403 of file calibration.hpp.

                              {
         return m_bAllowMultiLine;
     }

◆ IsUnicode()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::IsUnicode ( ) const

inline

Get the storage format of the INI data.

Definition at line 360 of file calibration.hpp.

                            {
         return m_bStoreIsUtf8;
     }

◆ LoadData() [1/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadData	(	const char *	a_pData,
		size_t	a_uDataLen
	)

Load INI file data direct from memory

Parameters

a_pData	Data to be loaded
a_uDataLen	Length of the data in bytes

Returns: SI_Error See error definitions

Definition at line 1272 of file calibration.hpp.

           {
     SI_CONVERTER converter(m_bStoreIsUtf8);
  
     if (a_uDataLen == 0) {
         return SI_OK;
     }
  
     // consume the UTF-8 BOM if it exists
     if (m_bStoreIsUtf8 && a_uDataLen >= 3) {
         if (memcmp(a_pData, SI_UTF8_SIGNATURE, 3) == 0) {
             a_pData += 3;
             a_uDataLen -= 3;
         }
     }
  
     // determine the length of the converted data
     size_t uLen = converter.SizeFromStore(a_pData, a_uDataLen);
     if (uLen == (size_t) (-1)) {
         return SI_FAIL;
     }
  
     // allocate memory for the data, ensure that there is a NULL
     // terminator wherever the converted data ends
     SI_CHAR * pData = new(std::nothrow) SI_CHAR[uLen + 1];
     if (!pData) {
         return SI_NOMEM;
     }
     memset(pData, 0, sizeof (SI_CHAR)*(uLen + 1));
  
     // convert the data
     if (!converter.ConvertFromStore(a_pData, a_uDataLen, pData, uLen)) {
         delete[] pData;
         return SI_FAIL;
     }
  
     // parse it
     const static SI_CHAR empty = 0;
     SI_CHAR * pWork = pData;
     const SI_CHAR * pSection = &empty;
     const SI_CHAR * pItem = NULL;
     const SI_CHAR * pVal = NULL;
     const SI_CHAR * pComment = NULL;
  
     // We copy the strings if we are loading data into this class when we
     // already have stored some.
     bool bCopyStrings = (m_pData != NULL);
  
     // find a file comment if it exists, this is a comment that starts at the
     // beginning of the file and continues until the first blank line.
     SI_Error rc = FindFileComment(pWork, bCopyStrings);
     if (rc < 0) return rc;
  
     // add every entry in the file to the data table
     while (FindEntry(pWork, pSection, pItem, pVal, pComment)) {
         rc = AddEntry(pSection, pItem, pVal, pComment, false, bCopyStrings);
         if (rc < 0) return rc;
     }
  
     // store these strings if we didn't copy them
     if (bCopyStrings) {
         delete[] pData;
     } else {
         m_pData = pData;
         m_uDataLen = uLen + 1;
     }
  
     return SI_OK;
 }

References sl_oc::tools::SI_FAIL, sl_oc::tools::SI_NOMEM, and sl_oc::tools::SI_OK.

◆ LoadData() [2/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadData ( const std::string & a_strData )

inline

Load INI file data direct from a std::string

Parameters

a_strData Data to be loaded

Returns: SI_Error See error definitions

Definition at line 479 of file calibration.hpp.

                                                    {
         return LoadData(a_strData.c_str(), a_strData.size());
     }

References sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadData().

◆ LoadData() [3/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadData ( std::istream & a_istream )

Load INI file data from an istream.

Parameters

a_istream Stream to read from

Returns: SI_Error See error definitions

Definition at line 1348 of file calibration.hpp.

           {
     std::string strData;
     char szBuf[512];
     do {
         a_istream.get(szBuf, sizeof (szBuf), '\0');
         strData.append(szBuf);
     } while (a_istream.good());
     return LoadData(strData);
 }

Referenced by sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadData().

◆ LoadFile() [1/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadFile ( const char * a_pszFile )

Load an INI file from disk into memory

Parameters

a_pszFile Path of the file to be loaded. This will be passed to fopen() and so must be a valid path for the current platform.

Returns: SI_Error See error definitions

Definition at line 1188 of file calibration.hpp.

           {
     FILE * fp = NULL;
 #if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
     fopen_s(&fp, a_pszFile, "rb");
 #else // !__STDC_WANT_SECURE_LIB__
     fp = fopen(a_pszFile, "rb");
 #endif // __STDC_WANT_SECURE_LIB__
     if (!fp) {
         return SI_FILE;
     }
     SI_Error rc = LoadFile(fp);
     fclose(fp);
     return rc;
 }

References sl_oc::tools::SI_FILE.

Referenced by sl_oc::tools::ConfManager::ConfManager().

◆ LoadFile() [2/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadFile ( const SI_WCHAR_T * a_pwszFile )

Load an INI file from disk into memory

Parameters

a_pwszFile Path of the file to be loaded in UTF-16.

Returns: SI_Error See error definitions

Definition at line 1209 of file calibration.hpp.

           {
 #ifdef _WIN32
     FILE * fp = NULL;
 #if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
     _wfopen_s(&fp, a_pwszFile, L"rb");
 #else // !__STDC_WANT_SECURE_LIB__
     fp = _wfopen(a_pwszFile, L"rb");
 #endif // __STDC_WANT_SECURE_LIB__
     if (!fp) return SI_FILE;
     SI_Error rc = LoadFile(fp);
     fclose(fp);
     return rc;
 #else // !_WIN32 (therefore SI_CONVERT_ICU)
     char szFile[256];
     u_austrncpy(szFile, a_pwszFile, sizeof (szFile));
     return LoadFile(szFile);
 #endif // _WIN32
 }

References sl_oc::tools::SI_FILE.

◆ LoadFile() [3/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::LoadFile ( FILE * a_fpFile )

Load the file from a file pointer.

Parameters

a_fpFile Valid file pointer to read the file data from. The file will be read until end of file.

Returns: SI_Error See error definitions

Definition at line 1233 of file calibration.hpp.

           {
     // load the raw file data
     int retval = fseek(a_fpFile, 0, SEEK_END);
     if (retval != 0) {
         return SI_FILE;
     }
     long lSize = ftell(a_fpFile);
     if (lSize < 0) {
         return SI_FILE;
     }
     if (lSize == 0) {
         return SI_OK;
     }
  
     // allocate and ensure NULL terminated
     char * pData = new(std::nothrow) char[lSize + 1];
     if (!pData) {
         return SI_NOMEM;
     }
     pData[lSize] = 0;
  
     // load data into buffer
     fseek(a_fpFile, 0, SEEK_SET);
     size_t uRead = fread(pData, sizeof (char), lSize, a_fpFile);
     if (uRead != (size_t) lSize) {
         delete[] pData;
         return SI_FILE;
     }
  
     // convert the raw data to unicode
     SI_Error rc = LoadData(pData, uRead);
     delete[] pData;
     return rc;
 }

References sl_oc::tools::SI_FILE, sl_oc::tools::SI_NOMEM, and sl_oc::tools::SI_OK.

◆ Reset()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

void sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Reset

Deallocate all memory stored by this object

Definition at line 1166 of file calibration.hpp.

                                                           {
     // remove all data
     delete[] m_pData;
     m_pData = NULL;
     m_uDataLen = 0;
     m_pFileComment = NULL;
     if (!m_data.empty()) {
         m_data.erase(m_data.begin(), m_data.end());
     }
  
     // remove all strings
     if (!m_strings.empty()) {
         typename TNamesDepend::iterator i = m_strings.begin();
         for (; i != m_strings.end(); ++i) {
             delete[] const_cast<SI_CHAR*> (i->pItem);
         }
         m_strings.erase(m_strings.begin(), m_strings.end());
     }
 }

◆ Save() [1/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Save	(	OutputWriter &	a_oOutput,
		bool	a_bAddSignature = `false`
	)		const

Save the INI data. The data will be written to the output device in a format appropriate to the current data, selected by:

SI_CHAR	FORMAT
char	same format as when loaded (MBCS or UTF-8)
wchar_t	UTF-8
other	UTF-8

Note that comments from the original data is preserved as per the documentation on comments. The order of the sections and values from the original file will be preserved.

Any data prepended or appended to the output device must use the the same format (MBCS or UTF-8). You may use the GetConverter() method to convert text to the correct format regardless of the output format being used by SimpleIni.

To add a BOM to UTF-8 data, write it out manually at the very beginning like is done in SaveFile when a_bUseBOM is true.

Parameters

a_oOutput	Output writer to write the data to.
a_bAddSignature	Prepend the UTF-8 BOM if the output data is in UTF-8 format. If it is not UTF-8 then this value is ignored. Do not set this to true if anything has already been written to the OutputWriter.

Returns: SI_Error See error definitions

Definition at line 2229 of file calibration.hpp.

                 {
     Converter convert(m_bStoreIsUtf8);
  
     // add the UTF-8 signature if it is desired
     if (m_bStoreIsUtf8 && a_bAddSignature) {
         a_oOutput.Write(SI_UTF8_SIGNATURE);
     }
  
     // get all of the sections sorted in load order
     TNamesDepend oSections;
     GetAllSections(oSections);
 #if defined(_MSC_VER) && _MSC_VER <= 1200
     oSections.sort();
 #elif defined(__BORLANDC__)
     oSections.sort(Entry::LoadOrder());
 #else
     oSections.sort(typename Entry::LoadOrder());
 #endif
  
     // write the file comment if we have one
     bool bNeedNewLine = false;
     if (m_pFileComment) {
         if (!OutputMultiLineText(a_oOutput, convert, m_pFileComment)) {
             return SI_FAIL;
         }
         bNeedNewLine = true;
     }
  
     // iterate through our sections and output the data
     typename TNamesDepend::const_iterator iSection = oSections.begin();
     for (; iSection != oSections.end(); ++iSection) {
         // write out the comment if there is one
         if (iSection->pComment) {
             if (bNeedNewLine) {
                 a_oOutput.Write(SI_NEWLINE_A);
                 a_oOutput.Write(SI_NEWLINE_A);
             }
             if (!OutputMultiLineText(a_oOutput, convert, iSection->pComment)) {
                 return SI_FAIL;
             }
             bNeedNewLine = false;
         }
  
         if (bNeedNewLine) {
             a_oOutput.Write(SI_NEWLINE_A);
             a_oOutput.Write(SI_NEWLINE_A);
             bNeedNewLine = false;
         }
  
         // write the section (unless there is no section name)
         if (*iSection->pItem) {
             if (!convert.ConvertToStore(iSection->pItem)) {
                 return SI_FAIL;
             }
             a_oOutput.Write("[");
             a_oOutput.Write(convert.Data());
             a_oOutput.Write("]");
             a_oOutput.Write(SI_NEWLINE_A);
         }
  
         // get all of the keys sorted in load order
         TNamesDepend oKeys;
         GetAllKeys(iSection->pItem, oKeys);
 #if defined(_MSC_VER) && _MSC_VER <= 1200
         oKeys.sort();
 #elif defined(__BORLANDC__)
         oKeys.sort(Entry::LoadOrder());
 #else
         oKeys.sort(typename Entry::LoadOrder());
 #endif
  
         // write all keys and values
         typename TNamesDepend::const_iterator iKey = oKeys.begin();
         for (; iKey != oKeys.end(); ++iKey) {
             // get all values for this key
             TNamesDepend oValues;
             GetAllValues(iSection->pItem, iKey->pItem, oValues);
  
             typename TNamesDepend::const_iterator iValue = oValues.begin();
             for (; iValue != oValues.end(); ++iValue) {
                 // write out the comment if there is one
                 if (iValue->pComment) {
                     a_oOutput.Write(SI_NEWLINE_A);
                     if (!OutputMultiLineText(a_oOutput, convert, iValue->pComment)) {
                         return SI_FAIL;
                     }
                 }
  
                 // write the key
                 if (!convert.ConvertToStore(iKey->pItem)) {
                     return SI_FAIL;
                 }
                 a_oOutput.Write(convert.Data());
  
                 // write the value
                 if (!convert.ConvertToStore(iValue->pItem)) {
                     return SI_FAIL;
                 }
                 a_oOutput.Write(m_bSpaces ? " = " : "=");
                 if (m_bAllowMultiLine && IsMultiLineData(iValue->pItem)) {
                     // multi-line data needs to be processed specially to ensure
                     // that we use the correct newline format for the current system
                     a_oOutput.Write("<<<END_OF_TEXT" SI_NEWLINE_A);
                     if (!OutputMultiLineText(a_oOutput, convert, iValue->pItem)) {
                         return SI_FAIL;
                     }
                     a_oOutput.Write("END_OF_TEXT");
                 } else {
                     a_oOutput.Write(convert.Data());
                 }
                 a_oOutput.Write(SI_NEWLINE_A);
             }
         }
  
         bNeedNewLine = true;
     }
  
     return SI_OK;
 }

References sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Converter::ConvertToStore(), sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Converter::Data(), sl_oc::tools::SI_FAIL, sl_oc::tools::SI_OK, and sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::OutputWriter::Write().

Referenced by sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Save().

◆ Save() [2/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Save	(	std::ostream &	a_ostream,
		bool	a_bAddSignature = `false`
	)		const

inline

Save the INI data to an ostream. See Save() for details.

Parameters

a_ostream	String to have the INI data appended to.
a_bAddSignature	Prepend the UTF-8 BOM if the output data is in UTF-8 format. If it is not UTF-8 then this value is ignored. Do not set this to true if anything has already been written to the stream.

Returns: SI_Error See error definitions

Definition at line 596 of file calibration.hpp.

                     {
         StreamWriter writer(a_ostream);
         return Save(writer, a_bAddSignature);
     }

References sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Save().

◆ Save() [3/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Save	(	std::string &	a_sBuffer,
		bool	a_bAddSignature = `false`
	)		const

inline

Append the INI data to a string. See Save() for details.

Parameters

a_sBuffer	String to have the INI data appended to.
a_bAddSignature	Prepend the UTF-8 BOM if the output data is in UTF-8 format. If it is not UTF-8 then this value is ignored. Do not set this to true if anything has already been written to the string.

Returns: SI_Error See error definitions

Definition at line 616 of file calibration.hpp.

                     {
         StringWriter writer(a_sBuffer);
         return Save(writer, a_bAddSignature);
     }

References sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::Save().

◆ SaveFile() [1/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SaveFile	(	const char *	a_pszFile,
		bool	a_bAddSignature = `true`
	)		const

Save an INI file from memory to disk

Parameters

a_pszFile	Path of the file to be saved. This will be passed to fopen() and so must be a valid path for the current platform.
a_bAddSignature	Prepend the UTF-8 BOM if the output data is in UTF-8 format. If it is not UTF-8 then this parameter is ignored.

Returns: SI_Error See error definitions

Definition at line 2174 of file calibration.hpp.

                 {
     FILE * fp = NULL;
 #if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
     fopen_s(&fp, a_pszFile, "wb");
 #else // !__STDC_WANT_SECURE_LIB__
     fp = fopen(a_pszFile, "wb");
 #endif // __STDC_WANT_SECURE_LIB__
     if (!fp) return SI_FILE;
     SI_Error rc = SaveFile(fp, a_bAddSignature);
     fclose(fp);
     return rc;
 }

References sl_oc::tools::SI_FILE.

◆ SaveFile() [2/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SaveFile	(	const SI_WCHAR_T *	a_pwszFile,
		bool	a_bAddSignature = `true`
	)		const

Save an INI file from memory to disk

Parameters

a_pwszFile	Path of the file to be saved in UTF-16.
a_bAddSignature	Prepend the UTF-8 BOM if the output data is in UTF-8 format. If it is not UTF-8 then this parameter is ignored.

Returns: SI_Error See error definitions

Definition at line 2194 of file calibration.hpp.

                 {
 #ifdef _WIN32
     FILE * fp = NULL;
 #if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
     _wfopen_s(&fp, a_pwszFile, L"wb");
 #else // !__STDC_WANT_SECURE_LIB__
     fp = _wfopen(a_pwszFile, L"wb");
 #endif // __STDC_WANT_SECURE_LIB__
     if (!fp) return SI_FILE;
     SI_Error rc = SaveFile(fp, a_bAddSignature);
     fclose(fp);
     return rc;
 #else // !_WIN32 (therefore SI_CONVERT_ICU)
     char szFile[256];
     u_austrncpy(szFile, a_pwszFile, sizeof (szFile));
     return SaveFile(szFile, a_bAddSignature);
 #endif // _WIN32
 }

References sl_oc::tools::SI_FILE.

◆ SaveFile() [3/3]

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SaveFile	(	FILE *	a_pFile,
		bool	a_bAddSignature = `false`
	)		const

Save the INI data to a file. See Save() for details.

Parameters

a_pFile	Handle to a file. File should be opened for binary output.
a_bAddSignature	Prepend the UTF-8 BOM if the output data is in UTF-8 format. If it is not UTF-8 then this value is ignored. Do not set this to true if anything has already been written to the file.

Returns: SI_Error See error definitions

Definition at line 2219 of file calibration.hpp.

                 {
     FileWriter writer(a_pFile);
     return Save(writer, a_bAddSignature);
 }

◆ SetBoolValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetBoolValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		bool	a_bValue,
		const SI_CHAR *	a_pComment = `NULL`,
		bool	a_bForceReplace = `false`
	)

Add or update a boolean value. This will always insert when multiple keys are enabled.

Parameters

a_pSection	Section to add or update
a_pKey	Key to add or update.
a_bValue	Value to set.
a_pComment	Comment to be associated with the key. See the notes on SetValue() for comments.
a_bForceReplace	Should all existing values in a multi-key INI file be replaced with this entry. This option has no effect if not using multi-key files. The difference between Delete/SetBoolValue and SetBoolValue with a_bForceReplace = true, is that the load order and comment will be preserved this way.

Returns: SI_Error See error definitions; SI_UPDATED Value was updated; SI_INSERTED Value was inserted

Definition at line 2024 of file calibration.hpp.

           {
     // use SetValue to create sections
     if (!a_pSection || !a_pKey) return SI_FAIL;
  
     // convert to an ASCII string
     const char * pszInput = a_bValue ? "true" : "false";
  
     // convert to output text
     SI_CHAR szOutput[64];
     SI_CONVERTER c(m_bStoreIsUtf8);
     c.ConvertFromStore(pszInput, strlen(pszInput) + 1,
             szOutput, sizeof (szOutput) / sizeof (SI_CHAR));
  
     // actually add it
     return AddEntry(a_pSection, a_pKey, szOutput, a_pComment, a_bForceReplace, true);
 }

References sl_oc::tools::SI_FAIL.

◆ SetDoubleValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetDoubleValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		double	a_nValue,
		const SI_CHAR *	a_pComment = `NULL`,
		bool	a_bForceReplace = `false`
	)

Add or update a double value. This will always insert when multiple keys are enabled.

Parameters

a_pSection	Section to add or update
a_pKey	Key to add or update.
a_nValue	Value to set.
a_pComment	Comment to be associated with the key. See the notes on SetValue() for comments.
a_bForceReplace	Should all existing values in a multi-key INI file be replaced with this entry. This option has no effect if not using multi-key files. The difference between Delete/SetDoubleValue and SetDoubleValue with a_bForceReplace = true, is that the load order and comment will be preserved this way.

Returns: SI_Error See error definitions; SI_UPDATED Value was updated; SI_INSERTED Value was inserted

Definition at line 1960 of file calibration.hpp.

           {
     // use SetValue to create sections
     if (!a_pSection || !a_pKey) return SI_FAIL;
  
     // convert to an ASCII string
     char szInput[64];
 #if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
     sprintf_s(szInput, "%f", a_nValue);
 #else // !__STDC_WANT_SECURE_LIB__
     sprintf(szInput, "%f", a_nValue);
 #endif // __STDC_WANT_SECURE_LIB__
  
     // convert to output text
     SI_CHAR szOutput[64];
     SI_CONVERTER c(m_bStoreIsUtf8);
     c.ConvertFromStore(szInput, strlen(szInput) + 1,
             szOutput, sizeof (szOutput) / sizeof (SI_CHAR));
  
     // actually add it
     return AddEntry(a_pSection, a_pKey, szOutput, a_pComment, a_bForceReplace, true);
 }

References sl_oc::tools::SI_FAIL.

◆ SetLongValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetLongValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		long	a_nValue,
		const SI_CHAR *	a_pComment = `NULL`,
		bool	a_bUseHex = `false`,
		bool	a_bForceReplace = `false`
	)

Add or update a numeric value. This will always insert when multiple keys are enabled.

Parameters

a_pSection	Section to add or update
a_pKey	Key to add or update.
a_nValue	Value to set.
a_pComment	Comment to be associated with the key. See the notes on SetValue() for comments.
a_bUseHex	By default the value will be written to the file in decimal format. Set this to true to write it as hexadecimal.
a_bForceReplace	Should all existing values in a multi-key INI file be replaced with this entry. This option has no effect if not using multi-key files. The difference between Delete/SetLongValue and SetLongValue with a_bForceReplace = true, is that the load order and comment will be preserved this way.

Returns: SI_Error See error definitions; SI_UPDATED Value was updated; SI_INSERTED Value was inserted

Definition at line 1899 of file calibration.hpp.

           {
     // use SetValue to create sections
     if (!a_pSection || !a_pKey) return SI_FAIL;
  
     // convert to an ASCII string
     char szInput[64];
 #if __STDC_WANT_SECURE_LIB__ && !_WIN32_WCE
     sprintf_s(szInput, a_bUseHex ? "0x%lx" : "%ld", a_nValue);
 #else // !__STDC_WANT_SECURE_LIB__
     sprintf(szInput, a_bUseHex ? "0x%lx" : "%ld", a_nValue);
 #endif // __STDC_WANT_SECURE_LIB__
  
     // convert to output text
     SI_CHAR szOutput[64];
     SI_CONVERTER c(m_bStoreIsUtf8);
     c.ConvertFromStore(szInput, strlen(szInput) + 1,
             szOutput, sizeof (szOutput) / sizeof (SI_CHAR));
  
     // actually add it
     return AddEntry(a_pSection, a_pKey, szOutput, a_pComment, a_bForceReplace, true);
 }

References sl_oc::tools::SI_FAIL.

◆ SetMultiKey()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

void sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetMultiKey ( bool a_bAllowMultiKey = true )

inline

Should multiple identical keys be permitted in the file. If set to false then the last value encountered will be used as the value of the key. If set to true, then all values will be available to be queried. For example, with the following input:

[section]
test=value1
test=value2

Then with SetMultiKey(true), both of the values "value1" and "value2" will be returned for the key test. If SetMultiKey(false) is used, then the value for "test" will only be "value2". This value may be changed at any time.

Parameters

a_bAllowMultiKey Allow multi-keys in the source?

Definition at line 382 of file calibration.hpp.

                                                    {
         m_bAllowMultiKey = a_bAllowMultiKey;
     }

◆ SetMultiLine()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

void sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetMultiLine ( bool a_bAllowMultiLine = true )

inline

Should data values be permitted to span multiple lines in the file. If set to false then the multi-line construct <<<TAG as a value will be returned as is instead of loading the data. This value may be changed at any time.

Parameters

a_bAllowMultiLine Allow multi-line values in the source?

Definition at line 398 of file calibration.hpp.

                                                      {
         m_bAllowMultiLine = a_bAllowMultiLine;
     }

◆ SetSpaces()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

void sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetSpaces ( bool a_bSpaces = true )

inline

Should spaces be added around the equals sign when writing key/value pairs out. When true, the result will be "key = value". When false, the result will be "key=value". This value may be changed at any time.

Parameters

a_bSpaces Add spaces around the equals sign?

Definition at line 413 of file calibration.hpp.

                                           {
         m_bSpaces = a_bSpaces;
     }

◆ SetUnicode()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

void sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetUnicode ( bool a_bIsUtf8 = true )

inline

Set the storage format of the INI data. This affects both the loading and saving of the INI data using all of the Load/Save API functions. This value cannot be changed after any INI data has been loaded.

If the file is not set to Unicode (UTF-8), then the data encoding is assumed to be the OS native encoding. This encoding is the system locale on Linux/Unix and the legacy MBCS encoding on Windows NT/2K/XP. If the storage format is set to Unicode then the file will be loaded as UTF-8 encoded data regardless of the native file encoding. If SI_CHAR == char then all of the char* parameters take and return UTF-8 encoded data regardless of the system locale.

Parameters

a_bIsUtf8 Assume UTF-8 encoding for the source?

Definition at line 355 of file calibration.hpp.

                                            {
         if (!m_pData) m_bStoreIsUtf8 = a_bIsUtf8;
     }

Referenced by sl_oc::tools::ConfManager::ConfManager().

◆ SetValue()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

SI_Error sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::SetValue	(	const SI_CHAR *	a_pSection,
		const SI_CHAR *	a_pKey,
		const SI_CHAR *	a_pValue,
		const SI_CHAR *	a_pComment = `NULL`,
		bool	a_bForceReplace = `false`
	)

inline

Add or update a section or value. This will always insert when multiple keys are enabled.

Parameters

a_pSection	Section to add or update
a_pKey	Key to add or update. Set to NULL to create an empty section.
a_pValue	Value to set. Set to NULL to create an empty section.
a_pComment	Comment to be associated with the section or the key. If a_pKey is NULL then it will be associated with the section, otherwise the key. Note that a comment may be set ONLY when the section or key is first created (i.e. when this function returns the value SI_INSERTED). If you wish to create a section with a comment then you need to create the section separately to the key. The comment string must be in full comment form already (have a comment character starting every line).
a_bForceReplace	Should all existing values in a multi-key INI file be replaced with this entry. This option has no effect if not using multi-key files. The difference between Delete/SetValue and SetValue with a_bForceReplace = true, is that the load order and comment will be preserved this way.

Returns: SI_Error See error definitions; SI_UPDATED Value was updated; SI_INSERTED Value was inserted

Definition at line 836 of file calibration.hpp.

               {
         return AddEntry(a_pSection, a_pKey, a_pValue, a_pComment, a_bForceReplace, true);
     }

Referenced by sl_oc::tools::ConfManager::setValue().

◆ UsingSpaces()

template<class SI_CHAR , class SI_STRLESS , class SI_CONVERTER >

bool sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >::UsingSpaces ( ) const

inline

Query the status of spaces output

Definition at line 418 of file calibration.hpp.

                              {
         return m_bSpaces;
     }

The documentation for this class was generated from the following file:

calibration.hpp

Classes

Public Types

Public Member Functions

Detailed Description

template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER> class sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >

Member Typedef Documentation

◆ SI_CHAR_T

◆ TKeyVal

◆ TNamesDepend

◆ TSection

Constructor & Destructor Documentation

◆ CSimpleIniTempl()

◆ ~CSimpleIniTempl()

Member Function Documentation

◆ Delete()

◆ DeleteValue()

◆ GetAllKeys()

◆ GetAllSections()

◆ GetAllValues()

◆ GetBoolValue()

◆ GetConverter()

◆ GetDoubleValue()

◆ GetLongValue()

◆ GetSection()

◆ GetSectionSize()

◆ GetValue()

◆ IsEmpty()

◆ IsMultiKey()

◆ IsMultiLine()

◆ IsUnicode()

◆ LoadData() [1/3]

◆ LoadData() [2/3]

◆ LoadData() [3/3]

◆ LoadFile() [1/3]

◆ LoadFile() [2/3]

◆ LoadFile() [3/3]

◆ Reset()

◆ Save() [1/3]

◆ Save() [2/3]

◆ Save() [3/3]

◆ SaveFile() [1/3]

◆ SaveFile() [2/3]

◆ SaveFile() [3/3]

◆ SetBoolValue()

◆ SetDoubleValue()

◆ SetLongValue()

◆ SetMultiKey()

◆ SetMultiLine()

◆ SetSpaces()

◆ SetUnicode()

◆ SetValue()

◆ UsingSpaces()

template<class SI_CHAR, class SI_STRLESS, class SI_CONVERTER>
class sl_oc::tools::CSimpleIniTempl< SI_CHAR, SI_STRLESS, SI_CONVERTER >