ds_live_data.h

/* Copyright (C) 2017 - 2024, Thornwave Labs Inc - All Rights Reserved.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 * Written by Razvan Turiac <razvan.turiac@thornwave.com>
*/
 
#ifndef _DS_LIVE_DATA_H
#define _DS_LIVE_DATA_H
 
 
#include <ds_view.h>
 
template<typename T, size_t S = 8>
class DsLiveData: public DsView::StateObserver
{
public:
    DsLiveData(): mIsValid(false), mScreen(nullptr)
    {
    }
 
    DsLiveData(const DsLiveData &rhs) = delete;
    DsLiveData& operator=(const DsLiveData &rhs) = delete;
 
    void observe(DsView* view, const lambda<bool(T&)> &callback)
    {
        mScreen = &view->getScreen();
 
        const int32_t index = mObservers.findIndex([view](const Observer& item)
        {
            return view == item.view;
        });
 
        if (index < 0)
        {
            Observer obs;
            obs.view = view;
            obs.callback = callback;
 
            mObservers.append(obs);
 
            view->addStateObserver(this);
 
            if (mIsValid)
            {
                if (callback(mValue))
                    mIsValid = false;
            }
        }
    }
 
    void remove(DsView* view)
    {
        view->removeStateObserver(this);
        
        const int32_t index = mObservers.find([view](const Observer &item)
        {
            return view == item.view;
        });
 
        if (index >= 0)
            mObservers.removeAtPos(index);
 
        if (mObservers.size() == 0)
            mScreen = nullptr;
    }
 
 
    void invalidate(void)
    {
        mIsValid = false;
    }
 
 
    void post(void)
    {
        mIsValid = true;
 
        if (mScreen)
        {
            if (mScreen->isUiThread())
            {
                update();
            }
            else
            {
                mScreen->queueLambda([this]()
                {
                    update();
                });
            }
        }
    }
 
    void post(const T &value)
    {
        if (&value != &mValue)
        {
            mMutex.take();
            mValue = value;
            mMutex.give();
        }
 
        post();
    }
 
 
    T& value(void)
    {
        return mValue;
    }
 
private:
    struct Observer
    {
        DsView* view;
        lambda<bool(T&)> callback;
    };
 
    bool mIsValid;
    T mValue;
    static_list<S, Observer> mObservers;
    DsScreen* mScreen;
    DsMutex mMutex;
 
    void onViewStateChange(DsView* view, bool isVisible) override final
    {
        if (mIsValid && isVisible)
        {
            //notify the observers
            for(mObservers.startFirst(); mObservers.valid(); mObservers.goNext())
            {
                Observer &obs = mObservers.current();
 
                if (obs.view == view)
                {
                    mMutex.take();
                    T value = mValue;
                    mMutex.give();
 
                    if (obs.callback(value))
                        mIsValid = false;
                    break;
                }
            }
        }
    }
 
    void update(void)
    {
        //notify the observers
        for(mObservers.startFirst(); mObservers.valid(); mObservers.goNext())
        {
            Observer &obs = mObservers.current();
            if (obs.view->isVisible())
            {
                mMutex.take();
                T value = mValue;
                mMutex.give();
 
                if (obs.callback(value))
                {
                    mIsValid = false;
                    break;
                }
            }
        }
    }
};
 
#endif