AbstractValue.h

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#ifndef UTILS__ABSTRACT_VALUE_H
#define UTILS__ABSTRACT_VALUE_H

#include "Imports.h"

namespace Utils {


template <typename AbstractType,
          typename NullObjectType,
          typename HierarchyRoot = AbstractType>
class AbstractValue
{
public:

    AbstractValue()
    : object_ (new NullObjectType())
    {}


    AbstractValue (const AbstractType &object)
    : object_ (object.copy())
    {}


    AbstractValue (const AbstractValue &other)
    : object_ (other.object_->copy())
    {}


    AbstractValue & operator= (const AbstractValue &other)
    {
        object_ = other.object_->copy();
        return *this;
    }


    bool operator== (const AbstractValue &other) const
    {
        return typeid (*object_) == typeid (*other.object_)
                && object_->isEqualTo (*other.object_);
    }


    bool operator!= (const AbstractValue &other) const
    {
        return !(*this == other);
    }

    AbstractType & operator*()
    {
        // We need the cast because we store an auto_ptr <HierarchyRoot>:
        return static_cast <AbstractType &> (*object_);
    }

    const AbstractType & operator*() const
    {
        // We need the cast because we store an auto_ptr <HierarchyRoot>:
        return static_cast <const AbstractType &> (*object_);
    }

    AbstractType * operator->()
    {
        // We need the cast because we store an auto_ptr <HierarchyRoot>:
        return static_cast <AbstractType *> (object_.get());
    }

    const AbstractType * operator->() const
    {
        // We need the cast because we store an auto_ptr <HierarchyRoot>:
        return static_cast <const AbstractType *> (object_.get());
    }


    template <typename RelatedAbstractType, typename RelatedNullType>
    operator AbstractValue <RelatedAbstractType,
                            RelatedNullType,
                            HierarchyRoot>() const
    {
        // The dynamic_cast would allow us to always perform a safe "up-cast" or
        // "down-cast" to AbstractValue instantiation for a related type.
        return AbstractValue <RelatedAbstractType,
                              RelatedNullType,
                              HierarchyRoot>
            (dynamic_cast <const RelatedAbstractType &> (*object_.get()));
    }

private:
    auto_ptr <HierarchyRoot>        object_;
};

} // namespace Utils

#endif // UTILS__ABSTRACT_VALUE_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.