tetengo::property Namespace Reference

A property set library. More...

Classes
class	file_storage
	A file storage. More...
class	file_storage_loader
	A file storage loader. More...
class	memory_storage
	A memory storage. More...
class	memory_storage_loader
	A memory storage loader. More...
class	property_set
	A property set. More...
class	storage
	A storage. More...
class	storage_loader
	A storage loader. More...
class	storage_loader_proxy
	A storage loader proxy. More...
class	storage_proxy
	A storage proxy. More...
class	windows_registry_storage
	A Windows registry storage. More...
class	windows_registry_storage_loader
	A Windows registry storage loader. More...

Detailed Description

A property set library.

Usage

Saving and Loading Settings

C++

#include <cassert>
#include <cstdlib>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
 
#include <tetengo/property/file_storage.hpp>
#include <tetengo/property/property_set.hpp>
#include <tetengo/property/storage.hpp>
 
 
namespace usage_tetengo::property
{
    const std::filesystem::path& setting_file_path();
 
    void save_load()
    {
        assert(!std::filesystem::exists(setting_file_path()));
 
        // Creates separate property sets with the same path for illustration purpose.
        // Uses the one for setting and the other for getting.
        tetengo::property::property_set props_for_setting{ std::make_unique<tetengo::property::file_storage_loader>(),
                                                           "tetengo_property_sample" };
        tetengo::property::property_set props_for_getting{ std::make_unique<tetengo::property::file_storage_loader>(),
                                                           "tetengo_property_sample" };
 
        // On Windows, by using tetengo::property::windows_registry_storage_loader, the values will be stored into the
        // Windows registry.
        // tetengo::property::property_set props_for_setting{
        //    std::make_unique<tetengo::property::windows_registry_storage_loader>(), "tetengo_property_sample"
        //};
        // tetengo::property::property_set props_for_getting{
        //    std::make_unique<tetengo::property::windows_registry_storage_loader>(), "tetengo_property_sample"
        //};
 
        // Sets a string value "bar" for the key "foo".
        props_for_setting.set_string("foo", "bar");
 
        // The value cannot be yet obtained from the property set for getting.
        const auto loaded_value1 = props_for_getting.get_string("foo");
        assert(!loaded_value1);
 
        // Saves the values of the property set for setting to the file.
        props_for_setting.commit();
        assert(std::filesystem::exists(setting_file_path()));
 
        // The value cannot be yet obtained from the property set for getting.
        const auto loaded_value2 = props_for_getting.get_string("foo");
        assert(!loaded_value2);
 
        // Loads the property set values from the file.
        props_for_getting.update();
 
        // The value can now be obtained from the property set for getting.
        const auto loaded_value3 = props_for_getting.get_string("foo");
        assert(*loaded_value3 == "bar");
 
        std::filesystem::remove(setting_file_path());
    }
 
    const std::filesystem::path& setting_file_path()
    {
        // When specifying the path "tetengo_property_sample" (with no path delimiter),
#if defined(_WIN32)
        // in the usual case on Windows, the path of the setting file will be
        // "C:\Users\USER_NAME\AppData\Roaming\tetengo_property_sample\tetengo_property_sample.json".
        static const std::filesystem::path path_{ std::filesystem::path{ std::getenv("APPDATA") } /
                                                  "tetengo_property_sample" / "tetengo_property_sample.json" };
#else
        // in the usual case on UNIX, the path of the setting file will be
        // "/home/USER_NAME/.tetengo_property_sample.json".
        static const std::filesystem::path path_{ std::filesystem::path{ std::getenv("HOME") } /
                                                  ".tetengo_property_sample.json" };
#endif
        return path_;
    }
}

C

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <sys/stat.h>
#include <tetengo/property/propertySet.h>
#include <tetengo/property/storage.h>
 
 
static const char* setting_file_path();
 
static int file_exists(const char* path);
 
void usage_tetengo_property_saveLoad()
{
    assert(!file_exists(setting_file_path()));
 
    // Creates separate property sets with the same path for illustration purpose.
    // Uses the one for setting and the other for getting.
    tetengo_property_propertySet_t* const p_props_for_setting = tetengo_property_propertySet_create(
        tetengo_property_storageLoader_createFileStorageLoader(), "tetengo_property_sample");
    tetengo_property_propertySet_t* const p_props_for_getting = tetengo_property_propertySet_create(
        tetengo_property_storageLoader_createFileStorageLoader(), "tetengo_property_sample");
 
    /*
        On Windows, by using tetengo_property_storageLoader_createWindowsRegistoryStorageLoader(), the values will
        be stored into the Windows registry.
    */
    /*
    tetengo_property_propertySet_t* const p_props_for_setting = tetengo_property_propertySet_create(
        tetengo_property_storageLoader_createWindowsRegistoryStorageLoader(), "tetengo_property_sample");
    tetengo_property_propertySet_t* const p_props_for_getting = tetengo_property_propertySet_create(
        tetengo_property_storageLoader_createWindowsRegistoryStorageLoader(), "tetengo_property_sample");
    */
 
    // Sets a string value "bar" for the key "foo".
    tetengo_property_propertySet_setString(p_props_for_setting, "foo", "bar");
 
    // The value cannot be yet obtained from the property set for getting.
    const size_t value_length1 = tetengo_property_propertySet_getString(p_props_for_getting, "foo", NULL, 0);
    (void)value_length1;
    assert(value_length1 == (size_t)-1);
 
    // Saves the values of the property set for setting to the file.
    tetengo_property_propertySet_commit(p_props_for_setting);
    assert(file_exists(setting_file_path()));
 
    // The value cannot be yet obtained from the property set for getting.
    const size_t value_length2 = tetengo_property_propertySet_getString(p_props_for_getting, "foo", NULL, 0);
    (void)value_length2;
    assert(value_length2 == (size_t)-1);
 
    // Loads the property set values from the file.
    tetengo_property_propertySet_update(p_props_for_getting);
 
    // The value can now be obtained from the property set for getting.
    const size_t value_length3 = tetengo_property_propertySet_getString(p_props_for_getting, "foo", NULL, 0);
    assert(value_length3 != (size_t)-1);
    char* const value = (char*)malloc((value_length3 + 1) * sizeof(char));
    if (!value)
    {
        assert(0);
        return;
    }
    value[value_length3] = '\0';
    tetengo_property_propertySet_getString(p_props_for_getting, "foo", value, value_length3 + 1);
    assert(strcmp(value, "bar") == 0);
    free((void*)value);
 
    remove(setting_file_path());
 
    tetengo_property_propertySet_destroy(p_props_for_getting);
    tetengo_property_propertySet_destroy(p_props_for_setting);
}
 
static const char* setting_file_path()
{
    static char path[4096] = { '\0' };
    if (path[0] == '\0')
    {
        /*
            When specifying the path "tetengo_property_sample" (with no path delimiter),
        */
#if defined(_WIN32)
        /*
            in the usual case on Windows, the path of the setting file will be
            "C:\Users\USER_NAME\AppData\Roaming\tetengo_property_sample\tetengo_property_sample.json".
        */
        strcat(path, getenv("APPDATA"));
        strcat(path, "\\tetengo_property_sample\\tetengo_property_sample.json");
#else
        /*
            in the usual case on UNIX, the path of the setting file will be
            "/home/USER_NAME/.tetengo_property_sample.json".
        */
        strcat(path, getenv("HOME"));
        strcat(path, "/.tetengo_property_sample.json");
#endif
    }
    return path;
}
 
static int file_exists(const char* const path)
{
#if defined(_WIN32)
    struct _stat buffer;
    return _stat(path, &buffer) == 0;
#else
    struct stat buffer;
    return stat(path, &buffer) == 0;
#endif
}