JsonFile.cpp

Go to the documentation of this file.

#include "JsonFile.h"
 
namespace krotos
{
    JsonFile::JsonFile(File file, const Identifier& defaultProperty, const String& defaultFormat)
        : m_jsonFile(file), m_defaultProperty(defaultProperty), m_defaultFormat(defaultFormat)
    {
        try
        {
            initialise();
        }
        catch (std::exception& ex)
        {
#if UNIT_TEST
            // Don't print to std out in unit tests
            static std::once_flag flag;
            std::call_once(flag, [ex] {
                std::cout << "JsonFile Error: " << ex.what() << "\n" << std::endl;
                std::cout
                        << "\t UnitTest detected. Silencing additional JsonFile exception logging to prevent nuisance "
                           "log spamming"
                        << std::endl;
            });
#else
            // Uh oh, something went wrong. Disable saving. Output error msg to the log.
            std::cout << "JsonFile Error: " << ex.what() << "\n";
#endif
            try
            {
                const bool deleteSuccess = m_jsonFile.deleteFile();
 
                if (deleteSuccess)
                {
                    createJsonFromDefaultFormat();
                }
                else
                {
                    throw JsonException("Failed to delete file: " + m_jsonFile.getFullPathName(),
                                        "On using fallback default JSON format.");
                }
            }
            catch (std::exception& ex)
            {
#if UNIT_TEST
                // Don't print to std out in unit tests
                static std::once_flag flag;
                std::call_once(flag, [ex] {
                    std::cout << "JsonFile Error: " << ex.what() << "\n" << std::endl;
                    std::cout << "\t UnitTest detected. Silencing additional JsonFile exception logging to prevent "
                                 "nuisance log spamming"
                              << std::endl;
                });
#else
                // Uh oh, something went wrong. Disable saving. Output error msg to the log.
                std::cout << "JsonFile Error: " << ex.what() << "\n";
#endif
            }
        }
    }
 
    void JsonFile::initialise()
    {
        // You must specify a file path!
        jassert(m_jsonFile.getFullPathName().isNotEmpty());
 
        if (m_jsonFile.existsAsFile())
        {
            m_data = JSON::parse(m_jsonFile);
 
            if (!m_data.hasProperty(m_defaultProperty))
            {
                throw JsonException("File is invalid or empty and could not be initialised",
                                    "On parsing the JSON file.");
            }
        }
        else
        {
            createJsonFromDefaultFormat();
        }
    }
 
    void JsonFile::createJsonFromDefaultFormat()
    {
        // Default format must be valid json
        jassert(!JSON::fromString(m_defaultFormat).isVoid());
 
        m_data = JSON::fromString(m_defaultFormat);
 
        save();
    }
 
    void JsonFile::saveInternal()
    {
        TemporaryFile tempFile{m_jsonFile, TemporaryFile::OptionFlags::useHiddenFile};
 
        if (auto fileOutputStream = std::unique_ptr<FileOutputStream>(tempFile.getFile().createOutputStream()))
        {
            // Erase the contents of the file
            fileOutputStream->setPosition(0);
            fileOutputStream->truncate();
 
            // Write registry to file
            JSON::writeToStream(*fileOutputStream, m_data);
 
            // Finished writing
            fileOutputStream.reset();
 
            const bool success = tempFile.overwriteTargetFileWithTemporary();
 
            // File overwriting should be successful.
            if (!success)
            {
                throw JsonException("Failed to overwrite " + m_jsonFile.getFullPathName().toStdString() +
                                            "\t with temporary file.",
                                    "When saving JSON file");
            }
        }
        else
        {
            auto result = m_jsonFile.create();
            if (result.failed())
            {
                throw JsonException("Failed to save file to " + m_jsonFile.getFullPathName().toStdString() +
                                            "\t Reason: " + result.getErrorMessage().toStdString(),
                                    "When creating JSON file");
            }
            else
            {
                saveInternal();
            }
        }
    }
 
    void JsonFile::save()
    {
        try
        {
            saveInternal();
        }
        catch (std::exception& ex)
        {
#if UNIT_TEST
            // Don't print to std out in unit tests
            static std::once_flag flag;
            std::call_once(flag, [ex] {
                std::cout << "JsonFile Error: " << ex.what() << "\n" << std::endl;
                std::cout
                        << "\t UnitTest detected. Silencing additional JsonFile exception logging to prevent nuisance "
                           "log spamming"
                        << std::endl;
            });
#else
            // Uh oh, something went wrong. Disable saving. Output error msg to the log.
            std::cout << "JsonFile Error: " << ex.what() << "\n";
#endif
        }
    }
 
    JsonException::JsonException(const juce::String& whatHappened, const juce::String& whenDidItHappen)
        : std::runtime_error(whatHappened.getCharPointer())
    {
        this->m_whenDidItHappen = whenDidItHappen;
    }
 
    char const* JsonException::what() const noexcept { return runtime_error::what(); }
 
    String JsonException::when() const { return m_whenDidItHappen; };
} // namespace krotos