gensref.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_GENSREF_HPP_SENTRY
#define INTELIB_GENSREF_HPP_SENTRY

#include "iexcept.hpp"
#include "sexpress.hpp"


template<class Tp, class X_wrongtype> 
class GenericSReference : public SReference {
public:
    GenericSReference() : SReference() {}
    GenericSReference(const Tp *ts)
       : SReference((const SExpression*)ts) {}
    GenericSReference(const GenericSReference<Tp, X_wrongtype> &other)
       : SReference(other) {}

    GenericSReference(const SReference &other, bool ignore_type = false) 
       : SReference(other)
    {
        if(!ignore_type && other.GetPtr() &&
           !other->TermType().IsSubtypeOf(Tp::TypeId))
        {
            throw X_wrongtype(other);
        }
    }
    ~GenericSReference() {}
 
    Tp* GetPtr() const
        { return static_cast<Tp*>(SReference::GetPtr()); }

    Tp& operator*() const { return *GetPtr(); }
    Tp* operator->() const { return GetPtr(); }
    GenericSReference<Tp,X_wrongtype>&
    operator =(const GenericSReference<Tp,X_wrongtype>& ref)
        { SReference::operator=(ref); return *this; }
    GenericSReference<Tp,X_wrongtype>& operator =(Tp *lt)
        { SReference::operator=(lt); return *this; }
    GenericSReference<Tp,X_wrongtype>& operator =(Tp &lt)
        { SReference::operator=(lt); return *this; }
private:
    // made private to prevent the user from mistakes and
    //   to make sure this always points to an object of Tp.
    void operator =(const SReference& ref) {}
};


#endif // sentry

---