Serialiser.cpp

Go to the documentation of this file.

namespace krotos
{
 
    const Identifier Serialiser::PSTags::Version{"serialiser_version"};
    const Identifier Serialiser::PSTags::Actions{"actions"};
    const Identifier Serialiser::PSTags::Action{"action"};
    const Identifier Serialiser::PSTags::Priority{"priority"};
    const Identifier Serialiser::PSTags::Done{"done"};
    const Identifier Serialiser::PSTags::ExecutedAt{"executedAt"};
    const Identifier Serialiser::PSTags::Output{"output"};
 
    const String Serialiser::DEFAULT_FORMAT{"{"
                                            "\"serialiser_version\": \"1\","
                                            "\"actions\" : []}"};
 
    Serialiser::Serialiser(File serialiserFile) : JsonFile(serialiserFile, PSTags::Version, DEFAULT_FORMAT) {}
 
    void Serialiser::addAction(std::unique_ptr<Action> action)
    {
        m_actionMap.insert({action->name, std::move(action)});
    }
 
    void Serialiser::executeActions()
    {
        m_executedActions.clear();
 
        createActionQueue();
 
        for (auto& action : m_actionQueue)
        {
            // Execute the action
            action->done = action->execute();
 
            m_executedActions.push_back(action);
        }
 
        // clear the queue now it's been executed
        m_actionQueue.clear();
 
        writeActionData();
    }
 
    bool Serialiser::isActionDone(String name)
    {
        if (m_actionMap.find(name) != m_actionMap.end())
        {
            return m_actionMap[name]->done;
        }
        else
        {
            return false;
        }
    }
 
    void Serialiser::createActionQueue()
    {
        var actionArray = m_data.getProperty(PSTags::Actions, var());
        jassert(!actionArray.isVoid());
 
        m_actionQueue.clear();
 
        // Check if the action has been done already
        for (int i = 0; i < actionArray.size(); ++i)
        {
            auto name = actionArray[i][PSTags::Action].toString();
 
            if (actionArray[i][PSTags::Done].equals(true))
            {
                if (m_actionMap.find(name) != m_actionMap.end())
                {
                    // Update the action object with it's status from file.
                    m_actionMap[name]->done = true;
                }
            }
        }
 
        // Add the action to the queue if it hasn't been done.
        for (auto& action : m_actionMap)
        {
            if (!action.second->done)
            {
                m_actionQueue.push_back(action.second.get());
            }
        }
 
        // Sort the queue by priority
        std::sort(m_actionQueue.begin(), m_actionQueue.end(),
                  [](Action* a, Action* b) { return a->priority < b->priority; });
    }
 
    void Serialiser::writeActionData()
    {
        for (int i = 0; i < m_executedActions.size(); ++i)
        {
            // Create a new action object with the updated data
            // DynamicObject is reference counted, var takes ownership of it
            auto actionObject = new DynamicObject();
            var actionData(actionObject);
 
            // Re-create the action object with the new data
            actionObject->setProperty(PSTags::Priority, m_executedActions[i]->priority);
            actionObject->setProperty(PSTags::Action, m_executedActions[i]->name);
            actionObject->setProperty(PSTags::Done, m_executedActions[i]->done);
            actionObject->setProperty(PSTags::ExecutedAt, Time::getCurrentTime().toString(true, true, true, true));
            actionObject->setProperty(PSTags::Output, m_executedActions[i]->output);
 
            // Update the data
            var actionArray = m_data.getProperty(PSTags::Actions, var());
            jassert(!actionArray.isVoid());
 
            // find existing and update
            bool updatedExisting(false);
            for (int j = 0; j < actionArray.size(); j++)
            {
                if (actionArray[j][PSTags::Action] == m_executedActions[i]->name)
                {
                    actionArray[j].swapWith(actionData);
                    updatedExisting = true;
                }
            }
 
            // action didn't exist in the file, write it in
            if (!updatedExisting)
            {
                actionArray.append(actionData);
            }
        }
 
        int executedActionCount = m_executedActions.size();
        m_executedActions.clear();
 
        // Write to json file
        if (executedActionCount > 0)
        {
            save();
        }
    }
} // namespace krotos