Leviathan::KeyConfiguration Class Reference

Holds key configuration for an application. More...

#include <KeyConfiguration.h>

Inheritance diagram for Leviathan::KeyConfiguration:

Public Member Functions
DLLEXPORT	KeyConfiguration (const std::string &configfile)
DLLEXPORT	KeyConfiguration ()
	Creates an in-memory only configuration. More...
DLLEXPORT	~KeyConfiguration ()
DLLEXPORT bool	Init (std::function< void(Lock &guard, KeyConfiguration *checkfrom)> functocheck)
	Loads the defined keys from a file. More...
DLLEXPORT void	Release ()
	Saves all keys if modified. More...
DLLEXPORT bool	AddKeyIfMissing (Lock &guard, const std::string &name, const std::vector< std::string > &defaultkeys)
	Adds a key if one with the name isn't defined. More...
DLLEXPORT void	MarkAsChanged ()
	Marks current keys as changed and that the configuration should be saved to a file. More...
DLLEXPORT void	Save (Lock &guard)
	Saves current keys. More...
DLLEXPORT std::shared_ptr< std::vector< GKey > >	ResolveControlNameToKey (const std::string &controlkey)
	Resolves a control key string ("WalkForward") to a key. More...
DLLEXPORT const std::vector< GKey > &	ResolveControlNameToKeyVector (const std::string &controlkey)
	Resolve variant for getting a reference to the vector of keys. More...
DLLEXPORT GKey	ResolveControlNameToFirstKey (const std::string &controlkey)
	Resolve variant for getting the first binding or throwing. More...
DLLEXPORT std::string	ResolveKeyToControlName (const GKey &key)
Public Member Functions inherited from Leviathan::ThreadSafeGeneric< MutexType >
DLLEXPORT	ThreadSafeGeneric ()
DLLEXPORT	~ThreadSafeGeneric ()
FORCE_INLINE void	VerifyLock (RecursiveLock &guard) const
FORCE_INLINE void	VerifyLock (Lock &lockit) const

Additional Inherited Members
Public Types inherited from Leviathan::ThreadSafeGeneric< MutexType >
using	LockT = typename LockTypeResolver< MutexType >::LType
Protected Attributes inherited from Leviathan::ThreadSafeGeneric< MutexType >
MutexType	ObjectsLock

Detailed Description

Holds key configuration for an application.

Definition at line 15 of file KeyConfiguration.h.

Constructor & Destructor Documentation

KeyConfiguration() [1/2]

DLLEXPORT KeyConfiguration::KeyConfiguration

(

const std::string &

configfile

)

Parameters

configfile

The file which is used for saving and loading keys

Definition at line 8 of file KeyConfiguration.cpp.

                                                                        :
    KeyStorageFile(configfile)
{}

KeyConfiguration() [2/2]

DLLEXPORT KeyConfiguration::KeyConfiguration

(

)

Creates an in-memory only configuration.

Definition at line 13 of file KeyConfiguration.cpp.

: InMemory(true) {}

~KeyConfiguration()

DLLEXPORT KeyConfiguration::~KeyConfiguration

(

)

Definition at line 15 of file KeyConfiguration.cpp.

{
    // The keys should already be saved by now //
}

Member Function Documentation

AddKeyIfMissing()

DLLEXPORT bool KeyConfiguration::AddKeyIfMissing	(	Lock &	guard,
		const std::string &	name,
		const std::vector< std::string > &	defaultkeys
	)

Adds a key if one with the name isn't defined.

Returns

True if added

Definition at line 73 of file KeyConfiguration.cpp.

{
    if(defaultkeys.empty()) {
        LOG_WARNING("KeyConfiguration: AddKeyIfMissing: defaultkeys is empty, not adding one "
                    "with name: " +
                    name);
        return false;
    }

    auto iter = KeyConfigurations.find(name);
    if(iter != KeyConfigurations.end())
        return false;

    auto keys = std::make_shared<std::vector<GKey>>();

    for(const auto& key : defaultkeys)
        keys->push_back(GKey::GenerateKeyFromString(key));

    KeyConfigurations[name] = keys;

    Marked = true;
    return true;
}

Init()

DLLEXPORT bool KeyConfiguration::Init

(

std::function< void(Lock &guard, KeyConfiguration *checkfrom)>

functocheck

)

Loads the defined keys from a file.

the function argument is called to verify that all required keys are defined and it can add missing keys

Definition at line 20 of file KeyConfiguration.cpp.

{
    GUARD_LOCK();

    // Load the values from the file //
    if(!InMemory) {
        std::vector<std::shared_ptr<NamedVariableList>> tmpvalues;

        if(FileSystem::LoadDataDump(KeyStorageFile, tmpvalues, Logger::Get())) {
            // Create keys from the values //

            for(auto iter = tmpvalues.begin(); iter != tmpvalues.end(); ++iter) {
                // Get name for storing //
                auto name = (*iter)->GetName();
                // Try to create a key //
                auto keys = std::make_shared<std::vector<GKey>>();

                std::vector<VariableBlock*>& values = (*iter)->GetValues();

                for(size_t i = 0; i < values.size(); i++) {
                    // Parse a key //
                    if(values[i]->IsConversionAllowedNonPtr<std::string>()) {
                        keys->push_back(
                            GKey::GenerateKeyFromString(values[i]->operator std::string()));
                    }
                }

                // Assign to the map //
                KeyConfigurations[name] = keys;
            }
        }
    }

    // Call the function with a pointer to this for it to verify loaded keys //
    if(functocheck)
        functocheck(guard, this);

    if(Marked)
        Save(guard);

    return true;
}

MarkAsChanged()

DLLEXPORT void KeyConfiguration::MarkAsChanged

(

)

Marks current keys as changed and that the configuration should be saved to a file.

Useful during initially checking that all keys exist

Definition at line 98 of file KeyConfiguration.cpp.

{
    Marked = true;
}

Release()

DLLEXPORT void KeyConfiguration::Release

(

)

Saves all keys if modified.

Definition at line 64 of file KeyConfiguration.cpp.

{
    GUARD_LOCK();

    // Save all the keys //
    if(Marked)
        Save(guard);
}

ResolveControlNameToFirstKey()

DLLEXPORT GKey KeyConfiguration::ResolveControlNameToFirstKey

(

const std::string &

controlkey

)

Resolve variant for getting the first binding or throwing.

Exceptions

InvalidArgument

if controlkey not found

Definition at line 169 of file KeyConfiguration.cpp.

{
    GUARD_LOCK();
    auto iter = KeyConfigurations.find(controlkey);

    if(iter != KeyConfigurations.end())
        return iter->second->at(0);

    throw InvalidArgument("Key with name \"" + controlkey + "\" not found");
}

ResolveControlNameToKey()

DLLEXPORT std::shared_ptr< std::vector< GKey > > KeyConfiguration::ResolveControlNameToKey

(

const std::string &

controlkey

)

Resolves a control key string ("WalkForward") to a key.

Definition at line 140 of file KeyConfiguration.cpp.

{
    GUARD_LOCK();
    auto iter = KeyConfigurations.find(controlkey);

    if(iter != KeyConfigurations.end())
        return iter->second;

    return NULL;
}

ResolveControlNameToKeyVector()

DLLEXPORT const std::vector< GKey > & KeyConfiguration::ResolveControlNameToKeyVector

(

const std::string &

controlkey

)

Resolve variant for getting a reference to the vector of keys.

Exceptions

InvalidArgument

if controlkey not found

Definition at line 152 of file KeyConfiguration.cpp.

{
    GUARD_LOCK();
    auto iter = KeyConfigurations.find(controlkey);

    if(iter != KeyConfigurations.end()) {

        if(!iter->second)
            throw InvalidArgument("Key with name \"" + controlkey + "\" is nullptr");

        return *iter->second;
    }

    throw InvalidArgument("Key with name \"" + controlkey + "\" not found");
}

ResolveKeyToControlName()

DLLEXPORT std::string KeyConfiguration::ResolveKeyToControlName

(

const GKey &

key

)

Checks which configuration key string matches input key

Warning

this is quite costly function

Definition at line 180 of file KeyConfiguration.cpp.

{
    GUARD_LOCK();
    // We need to loop through all the keys and see if any of them match //
    for(auto iter = KeyConfigurations.begin(); iter != KeyConfigurations.end(); ++iter) {

        for(size_t i = 0; i < iter->second->size(); i++) {
            // We'll use the partial match function //
            if(iter->second->at(i).Match(key, false))
                return iter->first;
        }
    }
    // Not found, return an empty string //
    return "";
}

Save()

DLLEXPORT void KeyConfiguration::Save

(

Lock &

guard

)

Saves current keys.

Definition at line 103 of file KeyConfiguration.cpp.

{
    if(InMemory)
        return;

    // Skip if not given a file //
    if(KeyStorageFile.size() == 0)
        return;

    // First generate a string for this //
    std::string savedata = "";

    // Loop through all keys and create string representations from them //
    for(auto iter = KeyConfigurations.begin(); iter != KeyConfigurations.end(); ++iter) {

        // Print the name //
        savedata += iter->first + " = [";

        // Create a list of data //
        for(size_t i = 0; i < iter->second->size(); i++) {

            if(i != 0)
                savedata += ", ";
            auto strrepresentation = iter->second->at(i).GenerateStringFromKey();

            savedata += "[\"" + strrepresentation + "\"]";
        }

        // Add the line end //
        savedata += "];\n";
    }


    // Save the file //
    FileSystem::WriteToFile(savedata, KeyStorageFile);
}

---

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

• KeyConfiguration.h
• KeyConfiguration.cpp