SettingGroup.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <vector>
 
#include <OnixS/CME/MDH/messaging/StrRef.h>
#include <OnixS/CME/MDH/messaging/String.h>
 
ONIXS_CMEMDH_NAMESPACE_BEGIN
 
ONIXS_CMEMDH_LTWT_CLASS_DECL(SettingGroup);

struct ONIXS_CMEMDH_LTWT SettingChangeController
{
    virtual void beginChange(const SettingGroup&, const Messaging::Char*) = 0;

    virtual void endChange() = 0;
};
 
// Default attributes and functionality.
struct ONIXS_CMEMDH_LTWT TrivialChangeController : SettingChangeController
{
    void beginChange(const SettingGroup&, const Messaging::Char*) override {}

    void endChange() override {}

    ONIXS_CMEMDH_LTWT_EXPORTED
    static SettingChangeController& self();
};

class ONIXS_CMEMDH_LTWT SettingChangeGuard
{
public:
    SettingChangeGuard(SettingChangeController& controller, const SettingGroup& group, const Messaging::Char* details)
        : controller_(controller)
    {
        controller_.beginChange(group, details);
    }

    ~SettingChangeGuard()
    {
        controller_.endChange();
    }
 
private:
    SettingChangeController& controller_;
 
    SettingChangeGuard(const SettingChangeGuard&);
 
    SettingChangeGuard& operator=(const SettingChangeGuard&);
};

class ONIXS_CMEMDH_LTWT SettingGroup
{
public:
    SettingGroup(SettingChangeController* controller = nullptr)
        : controller_(controller ? *controller : TrivialChangeController::self())
    {
    }

    ~SettingGroup() {}

    template <class Assignee, class Value>
    void controlAssignment(const Messaging::Char* description, Assignee& assignee, Value value) const
    {
        const SettingChangeGuard guard(controller_, *this, description);
        {
            assignee = value;
        }
    }

    template <class Changeable>
    void controlChange(const Messaging::Char* description, void (Changeable::*change)(), Changeable& changeable) const
    {
        const SettingChangeGuard guard(controller_, *this, description);
        {
            (changeable.*change)();
        }
    }

    template <class Change, class Changeable, class Arg>
    void controlChange(const Messaging::Char* description, Change change, Changeable& changeable, const Arg& arg) const
    {
        const SettingChangeGuard guard(controller_, *this, description);
        {
            (changeable.*change)(arg);
        }
    }

    template <class Change, class Changeable, class Arg1, class Arg2>
    void
    controlChange(const Messaging::Char* description, Change change, Changeable& changeable, const Arg1& arg1, const Arg2& arg2)
        const
    {
        const SettingChangeGuard guard(controller_, *this, description);
        {
            (changeable.*change)(arg1, arg2);
        }
    }

    ONIXS_CMEMDH_LTWT_EXPORTED
    static const SettingGroup& null();
 
private:
    // Controller for the given group of settings.
    SettingChangeController& controller_;
 
    SettingGroup(const SettingGroup&);
 
    SettingGroup& operator=(const SettingGroup&);
};

inline bool operator==(const SettingGroup& left, const SettingGroup& right)
{
    return (&left == &right);
}

inline bool operator!=(const SettingGroup& left, const SettingGroup& right)
{
    return (&left != &right);
}
 
// Pre-defined collections.

template <class Type, class Container = std::vector<Type> >
class ListSetting
{
public:
    typedef Type Item;

    typedef Container Items;

    typedef typename Items::size_type Size;

    typedef typename Items::const_iterator Iterator;

    explicit ListSetting(const SettingGroup* group = nullptr)
        : group_(group ? *group : SettingGroup::null())
    {
    }

    ListSetting(const ListSetting& other)
        : group_(SettingGroup::null())
        , items_(other.items_)
    {
    }

    template <class InputIterator>
    ListSetting(InputIterator first, InputIterator last)
        : group_(SettingGroup::null())
        , items_(first, last)
    {
    }

    operator const Items&() const
    {
        return items_;
    }

    bool empty() const
    {
        return items_.empty();
    }

    Size size() const
    {
        return items_.size();
    }

    Iterator begin() const
    {
        return items_.begin();
    }

    Iterator end() const
    {
        return items_.end();
    }

    const Item& operator[](Size index) const
    {
        return items_[index];
    }

    template <class Initializer>
    void initialize(Initializer initializer)
    {
        group_.controlChange("Initialize List", &ListSetting::initNoControl<Initializer>, *this, initializer);
    }

    void push_back(const Item& item)
    {
        group_.controlChange(
            "Append an Item", static_cast<void (Items::*)(const Item&)>(&Items::push_back), items_, item
        );
    }

    void clear()
    {
        group_.controlChange("Clear the List", &Items::clear, items_);
    }

    ListSetting& operator=(const ListSetting& other)
    {
        group_.controlChange("Assign List", &ListSetting::assignNoControl, *this, other);
 
        return *this;
    }

    template <class InputIterator>
    ListSetting& assign(InputIterator first, InputIterator last)
    {
        group_.controlChange("Assign List", &Items::assign, items_, first, last);
 
        return *this;
    }

    ListSetting& assignNoControl(const ListSetting& other)
    {
        items_ = other.items_;
 
        return *this;
    }
 
private:
    const SettingGroup& group_;
 
    Container items_;
 
    template <class Initializer>
    void initNoControl(Initializer initializer)
    {
        items_.clear();
 
        initializer(items_);
    }
};

template <class Type>
void toStr(std::string& str, const ListSetting<Type>& list, Messaging::Char delimiter = ',')
{
    const typename ListSetting<Type>::Iterator endOfList = list.end();
 
    typename ListSetting<Type>::Iterator item = list.begin();
 
    while (true)
    {
        Messaging::toStr(str, *item);
 
        if (++item == endOfList)
        {
            break;
        }
 
        str += delimiter;
    }
}
 
ONIXS_CMEMDH_NAMESPACE_END