---

pointer.h

Go to the documentation of this file.

/***************************************************************************
 $RCSfile: pointer.h,v $
                             -------------------
    cvs         : $Id: pointer.h,v 1.6 2003/04/03 12:17:56 aquamaniac Exp $
    begin       : Tue Dec 13 2001
    copyright   : (C) 2001 by Martin Preuss
    email       : openhbci@aquamaniac.de

 ***************************************************************************
 *                                                                         *
 *   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  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef HBCIPOINTER_H
#define HBCIPOINTER_H

#ifdef __cplusplus
#include <stdio.h> /* DEBUG */
#include <string>

#include <openhbci/error.h>

namespace HBCI {
  class PointerBase;
/* template <class T> class DLLIMPORT Pointer; */
  class PointerObject;
  template <class T> class PointerCastBase;
  template <class T, class U> class PointerCast;
}

namespace HBCI {

#ifndef DOXYGEN_HIDE

class DLLIMPORT PointerObject {
    friend class PointerBase;
private:
    void *_object;
    int _counter;
    bool _delete;
    string _descr;

    PointerObject(void *obj, string descr=""):
        _object(obj),_counter(0)
        ,_delete(true)
        ,_descr(descr){
        };
        ~PointerObject(){
        };

        void setDescription(string descr) {
                  /* if (_descr.empty()) */
            _descr=descr;
        };

        const string &description() const {
            return _descr;
        };

public:

};


#endif /* DOXYGEN_HIDE */




class DLLIMPORT PointerBase {
#ifndef DOXYGEN_HIDE
private:
    PointerObject *_ptr;
    string _descr;

protected:
    void _attach(PointerObject &p) {
        _ptr=&p;
        if (_ptr) {
            _ptr->_counter++;
            if (_descr.empty())
                _descr=_ptr->_descr;
        }
        else
            throw HBCI::Error ("Pointer::_attach(&)",
                             ERROR_LEVEL_NORMAL,
                             0,
                             ERROR_ADVISE_DONTKNOW,
                             "No object for ."+_descr,
                             objectDescription());
    };

    void _attach(PointerObject *p) {
        _ptr=p;
        if (_ptr) {
            _ptr->_counter++;
            if (_descr.empty())
                _descr=_ptr->_descr;
        }
        else
            throw HBCI::Error ("Pointer::_attach(pt*)",
                             ERROR_LEVEL_NORMAL,
                             0,
                             ERROR_ADVISE_DONTKNOW,
                             "No object for "+_descr);
    };

    void _detach() {
        if (_ptr) {
            if (_ptr->_counter>0) {
                _ptr->_counter--;
                if (_ptr->_counter<1) {
                    if (_ptr->_delete)
                        _deleteObject(_ptr->_object);
                    delete _ptr;
                }
            }
        }
        _ptr=0;
    };

    virtual void _deleteObject(void *p) {
    };

    PointerBase(PointerBase &p): _ptr(0) {
        if (p._ptr)
            _attach(p._ptr);
    };

    PointerBase(const PointerBase &p) : _ptr(0) {
        if (p._ptr)
            _attach(p._ptr);
    };

    void operator=(PointerBase &p) {
        _detach();
        if (_descr.empty())
            _descr=p._descr;
        if (p._ptr)
            _attach(p._ptr);
    };

    void operator=(const PointerBase &p) {
        _detach();
        if (_descr.empty())
            _descr=p._descr;
        if (p._ptr)
            _attach(p._ptr);
    };

    void operator=(void* obj) {
        PointerObject *p;
        if (_ptr)
            _detach();
        _ptr=0;
        if (obj==0)
            return;
        p=new PointerObject(obj,_descr);
        _attach(p);
    };

    PointerBase(): _ptr(0) {};

    PointerBase(void *obj): _ptr(0) {
        PointerObject *p;
        p=new PointerObject(obj,_descr);
        _attach(p);
    };
#endif /* DOXYGEN_HIDE */

public:
    virtual ~PointerBase() {
    };

    void setDescription(string descr) {
        _descr=descr;
    };

    const string &description() const {
        return _descr;
    };

    void setObjectDescription(string descr) {
        if (!descr.empty())
            if (_ptr)
                _ptr->setDescription(descr);
    };

    string objectDescription() const {
        if (_ptr)
            return _ptr->description();
        else
            return "";
    };

    virtual int refCount() const {
      if (_ptr)
        return _ptr->_counter;
      else
        return -1;
    };

    bool operator==(const PointerBase &p) const {
        if (_ptr && p._ptr)
            return _ptr->_object==p._ptr->_object;
        else
            return false;
    };

    bool sharingData(const PointerBase &p) const {
        return (_ptr==p._ptr);
    };

    bool operator!=(const PointerBase &p) const {
        if (_ptr && p._ptr)
            return _ptr->_object!=p._ptr->_object;
        else
            return true;
    };

    virtual void* voidptr() const {
        if (!_ptr)
            return 0;
        if (!(_ptr->_object))
            return 0;
        return _ptr->_object;
    };


    void setAutoDelete(bool b) {
        if (_ptr) {
            if (_ptr->_object)
                _ptr->_delete=b;
        }
        else
            throw HBCI::Error ("PointerBase::setAutoDelete()",
                             ERROR_LEVEL_NORMAL,
                             0,
                             ERROR_ADVISE_DONTKNOW,
                             "No object in pointer",
                             description());
    };

    bool isValid() const {
        if (_ptr)
            if (_ptr->_object)
                return true;
        return false;
    };


};


template <class T> class DLLIMPORT Pointer: public PointerBase {
    friend class PointerCastBase<T>;
private:
protected:
    virtual void _deleteObject(void *p) {
        delete (T*) p;
    };

    Pointer(const PointerBase &p): PointerBase(p) {
    };

public:
    Pointer(): PointerBase(){};

    Pointer(T *obj): PointerBase(obj) {
    };

    Pointer(const Pointer<T> &p) : PointerBase(p) {
    };

    virtual ~Pointer() {
        _detach();
    };

    void operator=(T* obj) {
        PointerBase::operator=(obj);
    };

    void operator=(Pointer<T> &p) {
        PointerBase::operator=(p);
    };

    void operator=(const Pointer<T> &p) {
        PointerBase::operator=(p);
    };
    T& ref() const {
        T* p;

        p=ptr();
        if (!p)
            throw HBCI::Error ("Pointer::ref()",
                             ERROR_LEVEL_NORMAL,
                             0,
                             ERROR_ADVISE_DONTKNOW,
                             "No object in pointer",
                             description());

        return *p;
    };

    T& operator*() const {
        return ref();
    };

    virtual T* ptr() const {
        return (T*)PointerBase::voidptr();
    };

    virtual int refCount() const {
      return PointerBase::refCount();
    }

    template <class U> Pointer<U> cast() const {
        return PointerCast<U,T>::cast(*this);
        /* return Pointer<U>(*this); */

    };
    bool operator==(const Pointer<T> &p) const {
        return PointerBase::operator==(p);
    };

    bool operator!=(const Pointer<T> &p) const {
        return PointerBase::operator!=(p);
    };

    bool sharingData(const Pointer<T> &p) const {
        return PointerBase::sharingData(p);
    };
};


#ifndef DOXYGEN_HIDE

template <class T> class DLLIMPORT PointerCastBase {
protected:
    PointerCastBase();
    ~PointerCastBase();

    static Pointer<T> makePointer(const PointerBase &p) {
        return Pointer<T>(p);
    };
};


template <class T, class U> class DLLIMPORT PointerCast
:public PointerCastBase<T>
{
public:
    static DLLIMPORT Pointer<T> cast(const Pointer<U> &u) {
        U *uo;
        T *t;

        /* check if given pointer is valid */
        if (!u.isValid())
            throw HBCI::Error ("PointerCast::cast",
                             ERROR_LEVEL_NORMAL,
                             0,
                             ERROR_ADVISE_DONTKNOW,
                             "No object in pointer",
                             u.description());

        /* then try to cast the pointer */
        uo=u.ptr();
        t=dynamic_cast<T*>(uo);

        /* could we cast it ? */
        if (t==0)
                  /* no, throw */
            throw HBCI::Error ("PointerCast::cast",
                             ERROR_LEVEL_NORMAL,
                             0,
                             ERROR_ADVISE_DONTKNOW,
                             "Bad cast",
                             u.description());
        /* otherwise create a new pointer */
        return makePointer(u);
    };

};

#endif /* DOXYGEN_HIDE */

} /* namespace HBCI */
#endif /* __cplusplus */
#endif /* HBCIPOINTER_H */

---