wvar.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  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., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_WVAR_H
#define WT_WVAR_H

#include <boost/lexical_cast.hpp>

#include <wt/wsignal.h>

namespace Wt {

/// Watched variable avoids the need for get/set methods
/*!
    A WVar watched variable is a templated attempt to
    vanquish the get set methods that accompanies object oriented
    programming.
    
    \note The WVar class is good only for arithmetic (builtin)
    types and not generic classes due to c++'s C ish background. Maybe
    later we will build a WClass class. The problem is that WVar has
    a value of VARTYPE instead of inheriting from VARTYPE. This has
    the ugly effect that VARTYPE's members cannot be accessed through
    WVar without ugly casts, and of course in C++ is not possible to
    inherit from builtin types (int, bool) etc.
    
    A WVar variable can be read through the cast operator and
    be written through the assign operator. The WVar variable
    emits a signal when it is about to change, after it
    has been changed, and when it is accessed for read.
 
    if a slot from the ones that are called during aboutToChange
    returns true then the change is aborted.    
    
    A WVar variable can be publically read/write or protected. The
    default is to be publically read/write. If you do not wish for
    your variable to be publically readable just make your damn
    variable protected/private.
    
    WVar<int> a is a read/write int variable.
    WVar<int, C> a is a publically readable and read/write for class C.
 
Example:
    see test/vars.c 
*/

template<typename VARTYPE>
class WVarBase : public sigc::trackable {
protected:
    /// Marshaler
    class Blocker {
    public:
        typedef bool result_type;
        template<typename T_iterator>
        result_type operator()(T_iterator first, T_iterator last) const {
            for (; first != last; ++first)
                if (*first)
                    return true;
            return false;
        }
    };

    class OverideValue {
    public:
        OverideValue(bool valid_ = false, const VARTYPE& value_ = VARTYPE())
                : valid_(valid_),
        value_(value_) {}

        OverideValue& operator=(VARTYPE v) {
            valid_ = true;
            value_ = v;
            return *this;
        }

        bool isValid() const {
            return valid_;
        }

        VARTYPE value() const {
            return value_;
        }

    private:
        bool valid_;
        VARTYPE value_;
    };

    typedef std::pair<bool, VARTYPE> ValidValue;
    /// Marshaler to override all values but the last
    class Overrider {
    public:
        typedef OverideValue result_type;
        template<typename T_iterator>
        result_type operator()(T_iterator first, T_iterator last) const {
            OverideValue result(false, VARTYPE());
            for (; first != last; ++first) {
                result = (*first);
            }
            return result;
        }
    };

    /// avoids emitting read signal
    const VARTYPE& getValue() const {
        return value_;
    }

    /// avoids emitting aboutToChange, changed signal
    void setValue(const VARTYPE & value) {
        value_ = value;
    }

    WVarBase& operator=(VARTYPE value) {
        if (!aboutToChange.emit(value, value_)) {
            VARTYPE old(value_);
            setValue(value);
            changed.emit(value, old);
        }
        return *this;
    }

    WVarBase& operator=(const WVarBase& value) {
        *this = static_cast<VARTYPE>(value);
        return *this;
    }

private:
    VARTYPE value_;

public:
    class RW {
    public:
    };

    WVarBase(VARTYPE value = 0) {
        value_ = value;
    }

    Signal012M<bool, VARTYPE, VARTYPE, Blocker> aboutToChange;
    Signal012<void, VARTYPE, VARTYPE> changed;
    mutable Signal01<void, VARTYPE> read;
    mutable sigc::signal1<VARTYPE, VARTYPE, Overrider> override;

    VARTYPE readValue() const {
        read.emit(value_);
        const OverideValue v = override.emit(value_);
        return (v.isValid()) ? v.value() : value_;
    }

    ///\todo get, set and other they should really
    ///use const& where possible

    /// usefull for overrides and variables connection
    VARTYPE get
        (VARTYPE ) const {
            return readValue();
        }

    void set
        (VARTYPE value) {
        *this = value;
    }

    /// connect as a proxy to another WVar
    void connect(WVarBase& var) {
        // set the real variable to the proxy value
        var = getValue();

        changed.connect(
            sigc::slot1<void, VARTYPE>(
                sigc::mem_fun(var, &WVarBase::set
                                 )));

        override.connect(sigc::mem_fun(var, &WVarBase::get
                                          ));
    }

    operator VARTYPE() const {
        return readValue();
    }

    operator const std::string() const {
        return boost::lexical_cast<std::string>(readValue());
    }

    WVarBase& operator+=(const VARTYPE& value) {
        if (value) {
            *this = getValue() + value;
        }
        return *this;
    }

    WVarBase& operator-=(const VARTYPE & value) {
        if (value) {
            *this = getValue() - value;
        }
        return *this;
    }

    /// prefix operator
    WVarBase& operator++() {
        VARTYPE other(*this);
        ++other;
        *this = other;
        return *this;
    }

    WVarBase& operator--() {
        VARTYPE other(*this);
        --other;
        *this = other;
        return *this;
    }

    /// postfix operator
    WVarBase& operator++(int) {
        VARTYPE other(*this);
        other++;
        *this = other;
        return *this;
    }

    WVarBase& operator--(int) {
        VARTYPE other(*this);
        other--;
        *this = other;
        return *this;
    }
};

#define OPERATORS \
    WVar& operator=(const VARTYPE & value) {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator=(value));\
    }\
\
    WVar& operator=(const WVarBase<VARTYPE>& value) {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator=(value));\
    }\
\
    WVar& operator+=(const VARTYPE & value) {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator+=(value));\
    }\
\
    WVar& operator-=(const VARTYPE & value) {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator-=(value));\
    }\
\
    WVar& operator++() {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator++());\
    }\
\
    WVar& operator--() {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator--());\
    }\
\
    WVar& operator++(int) {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator++(0));\
    }\
\
    WVar& operator--(int) {\
        return static_cast<WVar &>(WVarBase<VARTYPE>::operator--(0));\
    }

/// read only
template<typename VARTYPE, typename PARENT = WVarBase<int>::RW>
class WVar : public WVarBase<VARTYPE> {
public:
    WVar(VARTYPE value = 0)
            : WVarBase<VARTYPE>(value) {}

protected:
    OPERATORS

    // this wrapper bullshit here is required because g++ does
    // not compile the following simple statement
    // friend class PARENT;
#if 1
    class WrappedParent {
    public:
        typedef PARENT Parent;
    };

    friend class WrappedParent::Parent;
#else

    friend class PARENT;
#endif

};

/// read write specialization
template<>
template<typename VARTYPE>
class WVar<VARTYPE, WVarBase<int>::RW> : public WVarBase<VARTYPE> {

public:
    WVar(VARTYPE value = 0)
            : WVarBase<VARTYPE>(value) {}

    OPERATORS
};

} // namespace

#endif // WT_WVAR_H

---

Generated Fri Jul 28 19:23:01 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.