MNAttr.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MN_ATTR_H
#define MN_ATTR_H

#include <config.h>

#include "mnstream.h"

#include "dictionary.h"

class AttrBase;

/**********************************************************************/
/* AttributeStore                                                     */
/**********************************************************************/

class AttributeStore
{
    dictionary<int,void*> _attribute_store;

public:
    void register_attribute( int idx, void* attr );

    /* Set function for all attributes.
     * <BR>
     * Since constructors for stream handlers should always have
     * identical calling conventions, parameters that concern only
     * a single stream handler must be managed differently. The
     * specific solution is the use of set functions. They specify
     * an attribute that can be private to the stream handler. If
     * it is an unknown attribute, it is silently ignored.
     * These parameters are stored by the stream handler and used
     * in the init function for initializing internal data structures
     * @note attribute
     *        A value indicating the modified attribute to the
     *        stream handler.
     * @param value
     *        The new value.
     * @return True if the set function was evaluated, false if it
     *         was not evaluated by the stream handler or any parent
     *         class.
     * @warning These set functions are very dangerous. Since the xlC 3.1.4
     *       does not support ANSI C++, it is impossible to make these
     *       templates typesafe. The typecast to an Attr<ValueType> that
     *       is used within this set function is not protected. The
     *       caller must take care of his types.
     */
    // template <unsigned int Index, class ValueType>
    // int set( const ValueType& value );

    void* get_attribute( int idx );

    template <class A> bool set( const A& value )
    {
        void* item = get_attribute( A::Value );
        if( item == NULL )
        {
            return false;
        }

        A* attr = (A*)item;
        return attr->set( value );
    }
};

/**********************************************************************/
/* Attr<ValueType>                                                    */
/**********************************************************************/

template <unsigned int Index, class ValueType> class Attr
{
public:
    enum { Value = Index };

private:
    bool      _set;
    ValueType _val;

    Attr( const Attr& );

    Attr& operator=( const Attr& );

protected:
    friend class AttributeStore;

public:
    explicit Attr( const ValueType& v )
        : _set(false)
        , _val(v)
    { }

public:
    Attr( AttributeStore* valueStore )
        : _set(false)
    {
        valueStore->register_attribute( Index, this );
    }

    virtual ~Attr( )
    { }

    bool set( const ValueType& v ) {
        if ( _set ) return false;
        _set = true;
        _val = v;
        return true;
    }

    bool set( const Attr& v ) {
        if( _set ) return false;
        _set = true;
        _val = v._val;
        return true;
    }

    operator ValueType() const {
        return _val;
    }

    Attr& operator=( const ValueType& newval ) {
        _val = newval;
        return *this;
    }

    ValueType& operator->() {
        return _val;
    }

    bool isSet( ) const {
        return _set;
    }
};

template <class T, class U> struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

template <class TList, unsigned int index> struct TypeAt;

template <class Head, class Tail>
struct TypeAt<Typelist<Head, Tail>, 0>
{
    typedef Head Result;
};

template <class Head, class Tail, unsigned int i>
struct TypeAt<Typelist<Head, Tail>, i>
{
    typedef typename TypeAt<Tail,i-1>::Result Result;
};

#endif /* MN_ATTR_H */

---