oaCommonSPtr.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaCommonSPtr.h
//
// This file contains the definitions of the SPtr smart pointer class, the SQPtr
// smart query pointer class and the SRef smart reference class.
//
// SPtr
//      This class is a smart pointer class. It has behavior that is similar to
//      a raw C++ pointer and it manages the reference count of the actual C++
//      pointer. It also has many useful utility functions.
//
// SQPtr
//      This class is an extension of the SPtr smart pointer. The Q stands for 
//      Query Interface, and the smart pointer is responsible for querying for 
//      the proper interface if an interface that isn't of type 'T' is passed 
//      in. This interface must derive from IBase for the query to take place, 
//      otherwise a compile time error will occur.
//
// SRef
//      This class is a smart reference that can be used as a return value to
//      pass referenced interfaces. If used, have your interface function return
//      an SRef<I> by value, where I is the interface you're returning.
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2005 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: icftcm $
//  $Revision: #1 $
//  $Date: 2010/08/09 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaCommonSPtr_P)
#define oaCommonSPtr_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaCommonPlugInBase.h"



// *****************************************************************************
// Declare and define types in the oaCommon namespace
// *****************************************************************************
BEGIN_OA_COMMON_NAMESPACE



// *****************************************************************************
// Forward declarations
// *****************************************************************************
template<class T>
class SRef;
class NString;


// *****************************************************************************
// SPtr
// *****************************************************************************
template<class T>
class SPtr {
public:
                            SPtr();
                            SPtr(T *in);
                            SPtr(const char *classID,
                                 bool       factory = false);
    explicit                SPtr(const SRef<T> &in);
                            SPtr(const SPtr<T> &in);

                            ~SPtr();

    void                    release();
    void                    createInstance(const char   *classID,
                                           IBase        *reserved = NULL);

                            operator T*&() const;
    T                       &operator*() const;
    T                       *operator->() const;

    T                       *operator=(T *in);
    T                       *operator=(const SPtr<T> &in);
    T                       *operator=(const SRef<T> &in);
    bool                    operator<(const SPtr<T> &in) const;
    template<class U>
             bool           operator==(const SPtr<U> &in) const;
    template<class U>
             bool           operator!=(const SPtr<U> &in) const;

    T                       *detach();
    T                       *getRef();
    T                       *ptr() const;

protected:
    void                    addRef();

    mutable T               *obj;
};



// *****************************************************************************
// SQPtr
// *****************************************************************************
template<class T>
class SQPtr : public SPtr<T> {
public:
                            SQPtr();
                            SQPtr(T *in);
                            SQPtr(const char    *clsid,
                                  bool          factory = false);

    explicit                SQPtr(const SPtr<T> &in);
    explicit                SQPtr(const SQPtr<T> &in);
    explicit                SQPtr(const SRef<T> &in);

    template<class U>
             explicit       SQPtr(SPtr<U>   in,
                                  bool      successRequired = true);

    template<class U>
        explicit            SQPtr(U     *in,
                                  bool  successRequired = true);

    template<class U>
             explicit       SQPtr(const SRef<U> &in,
                                  bool          successRequired = true);

    T                       *operator=(const SQPtr<T> &in);
    T                       *operator=(IBase *in);
    T                       *operator=(T *in);
    T                       *operator=(const SPtr<T> &in);
    T                       *operator=(const SRef<T> &in);
};



// *****************************************************************************
// SRef<T>
// *****************************************************************************
template<class T>
class SRef {
public:
                            SRef(T *in);
                            SRef(const SPtr<T> &in);
                            SRef(const SRef<T> &in);
                            ~SRef();

    T                       *detach() const;

    T                       *operator=(T *in);
                            operator T*();
    bool                    operator!() const;

    T                       *operator->() const;

    bool                    operator==(const SRef<T> &other) const;
    bool                    operator==(const SPtr<T> &other) const;
    bool                    operator!=(const SRef<T> &other) const;
    bool                    operator!=(const SPtr<T> &other) const;

private:
    mutable T               *obj;
    SRef<T>                 &operator=(const SRef<T> &in);
};



// *****************************************************************************
// SRef<IString>
// *****************************************************************************
template<>
class SRef<IString> {
public:
                            SRef(IString *in);
                            SRef(const SPtr<IString> &in);
                            SRef(const SRef<IString> &in);
                            SRef(const NString &in);
                            ~SRef();

    IString                 *detach() const;

    IString                 *operator=(IString *in);
                            operator IString*();
    bool                    operator!() const;

    IString                 *operator->() const;

    bool                    operator==(const SRef<IString> &other) const;
    bool                    operator==(const SPtr<IString> &other) const;
    bool                    operator!=(const SRef<IString> &other) const;
    bool                    operator!=(const SPtr<IString> &other) const;

                            operator const char*() const;

private:
    mutable IString         *obj;
    SRef<IString>           &operator=(const SRef<IString> &in);
};



END_OA_COMMON_NAMESPACE

#endif

Return to top of page

Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.