TDependentValues.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */

#ifndef _TDEPENDENTVALUES_H_
#define _TDEPENDENTVALUES_H_

#include <assert.h>

namespace mbo
{

template< typename _Ty
        , size_t   _Count
        , _Ty      _Min
        , _Ty      _Max
        , _Ty      _Step
        >
class TDependentValues
{
public:

    typedef _Ty    ValueType;
    typedef _Ty    ValueArray[_Count];

    TDependentValues()
        : m_bUpdate(false)
        , m_bFixup(true)
    {
        SetEqual();
    }

    const ValueType & operator [] (size_t nIndex) const
    {
        assert(nIndex < _Count);
        return m_vtValues[nIndex];
    }

    ValueType GetValue(size_t nIndex) const
    {
        assert(nIndex < _Count);
        return m_vtValues[nIndex];
    }

    ValueType GetSum() const
    {
        ValueType sum(0);

        for(size_t nPos = 0; nPos < _Count; ++nPos)
        {
            sum += m_vtValues[nPos];
        }
        return sum;
    }

    bool GetValuesOk() const
    {
        ValueType sum(0);

        for(size_t nPos = 0; nPos < _Count; ++nPos)
        {
            if (m_vtValues[nPos] < _Min)
            {
                return false;
            }
            sum += m_vtValues[nPos];
        }
        return sum == _Max;
    }

    void SetEqual()
    {
        if (!m_bUpdate)
        {
            m_bUpdate = true;

            // Correct the values
            for(size_t nPos = 0; nPos < _Count; ++nPos)
            {
                m_vtValues[nPos] = _Max / _Count;
            }

            FixupSum();

            // now that all values are correct again we can notify
            DoUpdateValues(-1);

            m_bUpdate = false;
        }
    }

    void SetAllValues(const ValueArray * pvtValues)
    {
        for(size_t nPos = 0; nPos < _Count; ++nPos)
        {
            m_vtValues[nPos] = (*pvtValues)[nPos];
        }
        FixupSum();
        DoUpdateValues(-1);
    }

    void SetValue(size_t nIndex, ValueType new_val)
    {
        if (!m_bUpdate)
        {
            m_bUpdate = true;

            if (!m_bFixup)
            {
                m_vtValues[nIndex] = new_val;
                DoUpdateValues(nIndex);
            }
            // check whether at least one value was changed, diff != 0
            else if (m_vtValues[nIndex] != new_val)
            {
                // if a new value was set 1000 then we need to set all other to zero
                if (new_val >= _Max)
                {
                    for(size_t nPos = 0; nPos < _Count; ++nPos)
                    {
                        m_vtValues[nPos] = nPos == nIndex ? _Max : _Min;
                    }
                }
                else
                {
                    // handle the normal case (and later the case when a value was set to zero)
                    ValueType  count_min_one = _Count - 1;
                    ValueType  diff_val  = _Step * (new_val - m_vtValues[nIndex]) / count_min_one;
                    ValueType  miss_val  = 0;
                    ValueType  max_val   = _Min;
                    size_t     nIndexMax = 0;

                    for(size_t nPos = 0; nPos < _Count; ++nPos)
                    {
                        if (nPos == nIndex)
                        {
                            m_vtValues[nPos] += diff_val * count_min_one;
                            m_vtValues[nPos] = min(m_vtValues[nPos], _Max);
                        }
                        else
                        {
                            m_vtValues[nPos] -= diff_val;
                        }

                        if (m_vtValues[nPos] < _Min)
                        {
                            miss_val += _Min - m_vtValues[nPos];
                            m_vtValues[nPos] = _Min;
                        }
                        else if (m_vtValues[nPos] >= max_val)
                        {
                            nIndexMax = nPos;
                            max_val = m_vtValues[nPos];
                        }
                    }

                    if (miss_val)
                    {
                        m_vtValues[nIndexMax] -= miss_val;
                    }

                    FixupSum();
                }

                DoUpdateValues(nIndex);
            }

            m_bUpdate = false;
        }
    }

protected:

    virtual void DoUpdateValues(size_t nIndex)
    {
        // nothing to do here
    }

    virtual void SetAutoFixup(bool bAutoFixup)
    {
        m_bFixup = bAutoFixup;
        if (m_bFixup)
        {
            FixupSum();
            DoUpdateValues(-1);
        }
    }

    virtual bool GetAutoFixup() const
    {
        return m_bFixup;
    }

private:

    void FixupSum()
    {
        if (!m_bFixup)
        {
            return;
        }

        ValueType  sum = GetSum();
        size_t     nPos;

        while (sum != _Max)
        {
            for(nPos = 0; sum < _Max && nPos < _Count; ++nPos)
            {
                if (m_vtValues[nPos] + _Step <= _Max)
                {
                    m_vtValues[nPos] += _Step;
                    sum += _Step;
                }
            }
            for(nPos = 0; sum > _Max && nPos < _Count; ++nPos)
            {
                if (m_vtValues[nPos] - _Step >= _Min)
                {
                    m_vtValues[nPos] -= _Step;
                    sum -= _Step;
                }
            }
        }
    }

    bool        m_bUpdate;
    bool        m_bFixup;
    ValueArray  m_vtValues;
};

}; // namespace mbo

#endif // _TDEPENDENTVALUES_H_

---