tracktion_ConstrainedCachedValue.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
namespace tracktion { inline namespace engine
{
 
//==============================================================================
template <typename Type>
class ConstrainedCachedValue    : private juce::ValueTree::Listener
{
public:
    //==============================================================================
    ConstrainedCachedValue();
 
    ConstrainedCachedValue (juce::ValueTree& tree, const juce::Identifier& propertyID,
                            juce::UndoManager* undoManager);
 
    ConstrainedCachedValue (juce::ValueTree& tree, const juce::Identifier& propertyID,
                            juce::UndoManager* undoManager, const Type& defaultToUse);
 
    void setConstrainer (std::function<Type (Type)> constrainerToUse);
 
    //==============================================================================
    operator Type() const noexcept                   { return cachedValue; }
 
    Type get() const noexcept                        { return cachedValue; }
 
    Type& operator*() noexcept                       { return cachedValue; }
 
    Type* operator->() noexcept                      { return &cachedValue; }
 
    template <typename OtherType>
    bool operator== (const OtherType& other) const   { return cachedValue == other; }
 
    template <typename OtherType>
    bool operator!= (const OtherType& other) const   { return cachedValue != other; }
 
    //==============================================================================
    juce::Value getPropertyAsValue();
 
    bool isUsingDefault() const;
 
    Type getDefault() const                          { return defaultValue; }
 
    //==============================================================================
    ConstrainedCachedValue& operator= (const Type& newValue);
 
    void setValue (const Type& newValue, juce::UndoManager* undoManagerToUse);
 
    void resetToDefault();
 
    void resetToDefault (juce::UndoManager* undoManagerToUse);
 
    void setDefault (const Type& value)                { defaultValue = constrainer (value); }
 
    //==============================================================================
    void referTo (juce::ValueTree& tree, const juce::Identifier& property, juce::UndoManager*);
 
    void referTo (juce::ValueTree& tree, const juce::Identifier& property, juce::UndoManager*, const Type& defaultVal);
 
    void forceUpdateOfCachedValue();
 
    //==============================================================================
    juce::ValueTree& getValueTree() noexcept                { return targetTree; }
 
    const juce::Identifier& getPropertyID() const noexcept  { return targetProperty; }
 
private:
    //==============================================================================
    juce::ValueTree targetTree;
    juce::Identifier targetProperty;
    juce::UndoManager* undoManager;
    Type defaultValue = Type();
    Type cachedValue = Type();
    std::function<Type (Type)> constrainer;
 
    //==============================================================================
    void referToWithDefault (juce::ValueTree&, const juce::Identifier&, juce::UndoManager*, const Type&);
    Type getTypedValue() const;
 
    void valueTreePropertyChanged (juce::ValueTree& changedTree, const juce::Identifier& changedProperty) override;
    void valueTreeChildAdded (juce::ValueTree&, juce::ValueTree&) override {}
    void valueTreeChildRemoved (juce::ValueTree&, juce::ValueTree&, int) override {}
    void valueTreeChildOrderChanged (juce::ValueTree&, int, int) override {}
    void valueTreeParentChanged (juce::ValueTree&) override {}
 
    JUCE_DECLARE_NON_COPYABLE (ConstrainedCachedValue)
};
 
 
//==============================================================================
template <typename Type>
inline ConstrainedCachedValue<Type>::ConstrainedCachedValue()  : undoManager (nullptr) {}
 
template <typename Type>
inline ConstrainedCachedValue<Type>::ConstrainedCachedValue (juce::ValueTree& v, const juce::Identifier& i, juce::UndoManager* um)
    : targetTree (v), targetProperty (i), undoManager (um),
      defaultValue(), cachedValue (getTypedValue())
{
    targetTree.addListener (this);
}
 
template <typename Type>
inline ConstrainedCachedValue<Type>::ConstrainedCachedValue (juce::ValueTree& v, const juce::Identifier& i, juce::UndoManager* um, const Type& defaultToUse)
    : targetTree (v), targetProperty (i), undoManager (um),
      defaultValue (defaultToUse), cachedValue (getTypedValue())
{
    targetTree.addListener (this);
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::setConstrainer (std::function<Type (Type)> constrainerToUse)
{
    constrainer = std::move (constrainerToUse);
    jassert (constrainer);
 
    if (targetTree.isValid())
    {
        setValue (constrainer (cachedValue), undoManager);
        jassert (defaultValue == constrainer (defaultValue));
    }
}
 
template <typename Type>
inline juce::Value ConstrainedCachedValue<Type>::getPropertyAsValue()
{
    return targetTree.getPropertyAsValue (targetProperty, undoManager);
}
 
template <typename Type>
inline bool ConstrainedCachedValue<Type>::isUsingDefault() const
{
    return ! targetTree.hasProperty (targetProperty);
}
 
template <typename Type>
inline ConstrainedCachedValue<Type>& ConstrainedCachedValue<Type>::operator= (const Type& newValue)
{
    setValue (newValue, undoManager);
    return *this;
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::setValue (const Type& newValue, juce::UndoManager* undoManagerToUse)
{
    jassert (constrainer);
    auto constrainedValue = constrainer (newValue);
 
    if (cachedValue != constrainedValue || isUsingDefault())
    {
        cachedValue = constrainedValue;
        targetTree.setProperty (targetProperty, juce::VariantConverter<Type>::toVar (constrainedValue), undoManagerToUse);
    }
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::resetToDefault()
{
    resetToDefault (undoManager);
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::resetToDefault (juce::UndoManager* undoManagerToUse)
{
    targetTree.removeProperty (targetProperty, undoManagerToUse);
    forceUpdateOfCachedValue();
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::referTo (juce::ValueTree& v, const juce::Identifier& i, juce::UndoManager* um)
{
    referToWithDefault (v, i, um, Type());
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::referTo (juce::ValueTree& v, const juce::Identifier& i, juce::UndoManager* um, const Type& defaultVal)
{
    referToWithDefault (v, i, um, defaultVal);
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::forceUpdateOfCachedValue()
{
    cachedValue = getTypedValue();
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::referToWithDefault (juce::ValueTree& v, const juce::Identifier& i, juce::UndoManager* um, const Type& defaultVal)
{
    jassert (constrainer);
    targetTree.removeListener (this);
    targetTree = v;
    targetProperty = i;
    undoManager = um;
    defaultValue = constrainer (defaultVal);
    cachedValue = getTypedValue();
    targetTree.addListener (this);
}
 
template <typename Type>
inline Type ConstrainedCachedValue<Type>::getTypedValue() const
{
    jassert (constrainer);
 
    if (const juce::var* property = targetTree.getPropertyPointer (targetProperty))
        return constrainer (juce::VariantConverter<Type>::fromVar (*property));
 
    return defaultValue;
}
 
template <typename Type>
inline void ConstrainedCachedValue<Type>::valueTreePropertyChanged (juce::ValueTree& changedTree, const juce::Identifier& changedProperty)
{
    if (changedProperty == targetProperty && targetTree == changedTree)
        forceUpdateOfCachedValue();
}
 
}} // namespace tracktion { inline namespace engine