HK_KeyValue.cpp

Go to the documentation of this file.

/*******************************************************************/
#include "../headers/KeyValue.h"
 
HK_KeyValue::HK_KeyValue(){SetError();}
 
int HK_KeyValue::CheckSelection(int Selection)
{
    if(Selection < 0 || Selection > GetCount())
        return GetCount();
    else
        return Selection;
} 
 
 
int HK_KeyValue::GetCount()
{
    //1 Less Than size() Because Of Error At End
    return HK_SettingKey.size() - 1;
}
        
void HK_KeyValue::Add(string Key, string Value)
{
    HK_SettingKey[GetCount()] = Key;
    HK_SettingValue[GetCount()] = Value;
    HK_Update[GetCount()] = false;
    SetError();
}
 
void HK_KeyValue::Add(HK_KeyValue KeyValue)
{
    for(int A = 0; A < KeyValue.GetCount(); A++)
        Add(KeyValue.GetKey(A), KeyValue.GetValue(A));
}
        
int HK_KeyValue::GetInt(int Selection)
{
    return stoi(HK_SettingValue[CheckSelection(Selection)]);
}
        
int HK_KeyValue::GetInt(string Key)
{
    return stoi(HK_SettingValue[FindSelection(Key)]);
}
 
string HK_KeyValue::GetKey(int Selection)
{
    return HK_SettingKey[CheckSelection(Selection)];
}
        
string HK_KeyValue::GetValue(int Selection)
{
    return HK_SettingValue[CheckSelection(Selection)];
}
        
string HK_KeyValue::GetValue(string Key)
{
    return HK_SettingValue[FindSelection(Key)];
}
 
bool HK_KeyValue::IsDirty(int Selection){return HK_Update[CheckSelection(Selection)];}
bool HK_KeyValue::IsDirty(string Key){return HK_Update[FindSelection(Key)];}
 
HK_KeyValue HK_KeyValue::Search(string Value)
{
    HK_KeyValue Results;
    string Text;
    
    transform(Value.begin(),Value.end(),Value.begin(), ::tolower);
    
    for(int A = 0; A < GetCount(); A++) {
        Text = HK_SettingValue[A];
        transform(Text.begin(),Text.end(),Text.begin(), ::tolower);
        
        if(Text.find(Value) != string::npos)
            Results.Add("Setting " + HK_SettingKey[A] + "'s Value", HK_SettingValue[A]);
    }
    
    return Results;
}
 
void HK_KeyValue::SetClean(int Selection){HK_Update[CheckSelection(Selection)] = false;}
void HK_KeyValue::SetClean(string Key){HK_Update[FindSelection(Key)] = false;}
 
void HK_KeyValue::SetDirty(int Selection){HK_Update[CheckSelection(Selection)] = true;}
void HK_KeyValue::SetDirty(string Key){HK_Update[FindSelection(Key)] = true;}   
 
void HK_KeyValue::SetError() 
{
    HK_SettingKey.push_back("Error!");
    HK_SettingValue.push_back("Error!");
    HK_Update.push_back(false);
}
 
void HK_KeyValue::SetValue(int Selection,string Value){
    HK_SettingValue[CheckSelection(Selection)] = Value;
    HK_Update[CheckSelection(Selection)] = true;
}
        
void HK_KeyValue::SetValue(string Key,string Value){
    HK_SettingValue[FindSelection(Key)] = Value;
    HK_Update[FindSelection(Key)] = true;
}
        
vector<string> HK_KeyValue::GetArray(int Selection){
    return SplitStrings(HK_SettingValue[CheckSelection(Selection)],",");
}
        
vector<string> HK_KeyValue::GetArray(string Key){
    return SplitStrings(HK_SettingValue[FindSelection(Key)],",");
}
        
vector<int> HK_KeyValue::GetIntArray(int Selection){
    vector<int> IntArray;
    vector<string> StringArray = SplitStrings(HK_SettingValue[CheckSelection(Selection)],",");
    
    for(unsigned int A = 0;A < StringArray.size();A++)
        IntArray.push_back(stoi(StringArray[A]));
                
    StringArray.clear();
    StringArray.shrink_to_fit();
            
    return IntArray;
}
        
vector<int> HK_KeyValue::GetIntArray(string Key){
    vector<int> IntArray;
    vector<string> StringArray = SplitStrings(HK_SettingValue[FindSelection(Key)],",");
    
    for(unsigned int A = 0;A < StringArray.size();A++)
        IntArray.push_back(stoi(StringArray[A]));
                
    StringArray.clear();
    StringArray.shrink_to_fit();
            
    return IntArray;
}
        
int HK_KeyValue::FindSelection(string Key){
    for(int A = 0; A < GetCount(); A++){
        if(HK_SettingKey[A] == Key)
            return A;
    }
    //Not Found
    return GetCount();
}
        
vector<string> HK_KeyValue::SplitStrings(string In, string Split){
    string Hold, Empty;
    vector<string> OutArray;
    int B = In.length();
    for(int A = 0; A < B; A++){
        if(In[A] == Split[0]){
            OutArray.push_back(Hold);
            Hold = Empty;
            continue;
        }
        Hold += In[A];
    }
 
    OutArray.push_back(Hold);
    return OutArray;
}
        
void HK_KeyValue::Clear() {
    HK_SettingKey.clear();
    HK_SettingValue.clear();
    HK_Update.clear();
    HK_SettingValue.shrink_to_fit();
    HK_SettingKey.shrink_to_fit();
    HK_Update.shrink_to_fit();
    SetError();
}
 
vector<string> HK_KeyValue::GetUpdate(string TableName)
{
    vector<string> SQL;
    
    for(int A = 0; A < GetCount(); A++) {
        if(IsDirty(A)) {
            SQL.push_back("UPDATE " + TableName + " SET Value = '" + GetValue(A) + "' WHERE Key = '" + GetKey(A) + "';");
            SetClean(A);
        }
    }
    return SQL;
}