1998-12-17 22:12:45 +03:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
2001-09-29 00:14:13 +04:00
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-18 18:21:17 +04:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
2004-04-18 18:21:17 +04:00
|
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
|
|
* the License. You may obtain a copy of the License at
|
|
|
|
* http://www.mozilla.org/MPL/
|
1998-12-17 22:12:45 +03:00
|
|
|
*
|
2001-09-29 00:14:13 +04:00
|
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
|
|
* for the specific language governing rights and limitations under the
|
|
|
|
* License.
|
1998-12-17 22:12:45 +03:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-18 18:21:17 +04:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-29 00:14:13 +04:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 06:43:54 +03:00
|
|
|
*
|
1999-11-08 14:43:11 +03:00
|
|
|
* Contributor(s):
|
2000-12-09 07:45:43 +03:00
|
|
|
* Scott Collins <scc@mozilla.org> (original author)
|
2003-01-02 02:53:20 +03:00
|
|
|
* L. David Baron <dbaron@dbaron.org>
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-18 18:21:17 +04:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2001-09-29 00:14:13 +04:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-18 18:21:17 +04:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-29 00:14:13 +04:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-18 18:21:17 +04:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-29 00:14:13 +04:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1998-12-17 22:12:45 +03:00
|
|
|
|
|
|
|
#ifndef nsCOMPtr_h___
|
|
|
|
#define nsCOMPtr_h___
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
/*
|
|
|
|
Having problems?
|
|
|
|
|
|
|
|
See the User Manual at:
|
2000-06-10 13:58:13 +04:00
|
|
|
http://www.mozilla.org/projects/xpcom/nsCOMPtr.html
|
2000-03-18 08:17:46 +03:00
|
|
|
|
|
|
|
|
|
|
|
nsCOMPtr
|
|
|
|
better than a raw pointer
|
|
|
|
for owning objects
|
|
|
|
-- scc
|
1999-11-08 14:43:11 +03:00
|
|
|
*/
|
1998-12-17 22:12:45 +03:00
|
|
|
|
|
|
|
|
|
|
|
// Wrapping includes can speed up compiles (see "Large Scale C++ Software Design")
|
|
|
|
#ifndef nsDebug_h___
|
1999-06-04 00:36:53 +04:00
|
|
|
#include "nsDebug.h"
|
|
|
|
// for |NS_PRECONDITION|
|
1998-12-17 22:12:45 +03:00
|
|
|
#endif
|
|
|
|
|
2002-09-17 06:32:00 +04:00
|
|
|
#ifndef nsISupportsUtils_h__
|
|
|
|
#include "nsISupportsUtils.h"
|
1999-11-08 14:43:11 +03:00
|
|
|
// for |nsresult|, |NS_ADDREF|, |NS_GET_IID| et al
|
1998-12-17 22:12:45 +03:00
|
|
|
#endif
|
|
|
|
|
2001-10-02 07:18:12 +04:00
|
|
|
#ifndef nscore_h___
|
1999-11-08 14:43:11 +03:00
|
|
|
#include "nscore.h"
|
2004-10-29 23:43:51 +04:00
|
|
|
// for |NS_..._CAST|, |NS_COM_GLUE|
|
1999-11-08 14:43:11 +03:00
|
|
|
#endif
|
1998-12-17 22:12:45 +03:00
|
|
|
|
1999-02-11 04:34:07 +03:00
|
|
|
|
1998-12-18 06:45:44 +03:00
|
|
|
/*
|
|
|
|
WARNING:
|
|
|
|
This file defines several macros for internal use only. These macros begin with the
|
|
|
|
prefix |NSCAP_|. Do not use these macros in your own code. They are for internal use
|
|
|
|
only for cross-platform compatibility, and are subject to change without notice.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
1999-03-03 02:08:54 +03:00
|
|
|
#ifdef _MSC_VER
|
1999-06-02 05:59:28 +04:00
|
|
|
#define NSCAP_FEATURE_INLINE_STARTASSIGNMENT
|
|
|
|
// under VC++, we win by inlining StartAssignment
|
1999-11-08 14:43:11 +03:00
|
|
|
|
|
|
|
// Also under VC++, at the highest warning level, we are overwhelmed with warnings
|
|
|
|
// about (unused) inline functions being removed. This is to be expected with
|
|
|
|
// templates, so we disable the warning.
|
1999-11-05 06:31:04 +03:00
|
|
|
#pragma warning( disable: 4514 )
|
1998-12-17 22:12:45 +03:00
|
|
|
#endif
|
|
|
|
|
2003-10-23 03:29:00 +04:00
|
|
|
#define NSCAP_FEATURE_USE_BASE
|
1999-05-05 14:37:05 +04:00
|
|
|
|
1999-06-30 01:09:59 +04:00
|
|
|
#ifdef NS_DEBUG
|
1999-08-23 14:07:16 +04:00
|
|
|
#define NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
2003-10-23 03:29:00 +04:00
|
|
|
#undef NSCAP_FEATURE_USE_BASE
|
2000-02-07 00:17:51 +03:00
|
|
|
//#define NSCAP_FEATURE_TEST_NONNULL_QUERY_SUCCEEDS
|
1999-07-15 07:59:09 +04:00
|
|
|
#endif
|
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
/*
|
|
|
|
|...TEST_DONTQUERY_CASES| and |...DEBUG_PTR_TYPES| introduce some code that is
|
|
|
|
problematic on a select few of our platforms, e.g., QNX. Therefore, I'm providing
|
|
|
|
a mechanism by which these features can be explicitly disabled from the command-line.
|
|
|
|
*/
|
1999-07-23 01:09:49 +04:00
|
|
|
|
|
|
|
#ifdef NSCAP_DISABLE_TEST_DONTQUERY_CASES
|
1999-08-23 14:07:16 +04:00
|
|
|
#undef NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
1999-07-23 01:09:49 +04:00
|
|
|
#endif
|
|
|
|
|
2003-11-13 10:37:14 +03:00
|
|
|
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
|
|
|
|
// Our use of nsCOMPtr_base::mRawPtr violates the C++ standard's aliasing
|
|
|
|
// rules. Mark it with the may_alias attribute so that gcc 3.3 and higher
|
|
|
|
// don't reorder instructions based on aliasing assumptions for
|
|
|
|
// this variable. Fortunately, gcc versions < 3.3 do not do any
|
|
|
|
// optimizations that break nsCOMPtr.
|
|
|
|
|
|
|
|
#define NS_MAY_ALIAS_PTR(t) t* __attribute__((__may_alias__))
|
|
|
|
#else
|
|
|
|
#define NS_MAY_ALIAS_PTR(t) t*
|
2003-09-25 09:43:42 +04:00
|
|
|
#endif
|
|
|
|
|
2003-10-23 06:29:47 +04:00
|
|
|
#if defined(NSCAP_DISABLE_DEBUG_PTR_TYPES)
|
2003-10-23 03:29:00 +04:00
|
|
|
#define NSCAP_FEATURE_USE_BASE
|
1999-06-30 01:09:59 +04:00
|
|
|
#endif
|
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
|
1999-05-06 03:36:38 +04:00
|
|
|
#ifdef HAVE_CPP_BOOL
|
1999-06-02 05:59:28 +04:00
|
|
|
typedef bool NSCAP_BOOL;
|
1999-05-05 14:37:05 +04:00
|
|
|
#else
|
1999-06-02 05:59:28 +04:00
|
|
|
typedef PRBool NSCAP_BOOL;
|
1999-05-05 14:37:05 +04:00
|
|
|
#endif
|
|
|
|
|
2000-06-08 08:52:39 +04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
The following three macros (|NSCAP_ADDREF|, |NSCAP_RELEASE|, and |NSCAP_LOG_ASSIGNMENT|)
|
|
|
|
allow external clients the ability to add logging or other interesting debug facilities.
|
2000-06-10 13:58:13 +04:00
|
|
|
In fact, if you want |nsCOMPtr| to participate in the standard logging facility, you
|
|
|
|
provide (e.g., in "nsTraceRefcnt.h") suitable definitions
|
|
|
|
|
|
|
|
#define NSCAP_ADDREF(this, ptr) NS_ADDREF(ptr)
|
|
|
|
#define NSCAP_RELEASE(this, ptr) NS_RELEASE(ptr)
|
2000-06-08 08:52:39 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef NSCAP_ADDREF
|
2000-06-10 13:58:13 +04:00
|
|
|
#define NSCAP_ADDREF(this, ptr) (ptr)->AddRef()
|
2000-06-08 08:52:39 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef NSCAP_RELEASE
|
2000-06-10 13:58:13 +04:00
|
|
|
#define NSCAP_RELEASE(this, ptr) (ptr)->Release()
|
2000-06-08 08:52:39 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
// Clients can define |NSCAP_LOG_ASSIGNMENT| to perform logging.
|
|
|
|
#ifdef NSCAP_LOG_ASSIGNMENT
|
|
|
|
// Remember that |NSCAP_LOG_ASSIGNMENT| was defined by some client so that we know
|
|
|
|
// to instantiate |~nsGetterAddRefs| in turn to note the external assignment into
|
|
|
|
// the |nsCOMPtr|.
|
|
|
|
#define NSCAP_LOG_EXTERNAL_ASSIGNMENT
|
1998-12-22 02:26:39 +03:00
|
|
|
#else
|
2000-06-10 13:58:13 +04:00
|
|
|
// ...otherwise, just strip it out of the code
|
2003-02-25 18:53:36 +03:00
|
|
|
#define NSCAP_LOG_ASSIGNMENT(this, ptr)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef NSCAP_LOG_RELEASE
|
|
|
|
#define NSCAP_LOG_RELEASE(this, ptr)
|
1998-12-22 02:26:39 +03:00
|
|
|
#endif
|
|
|
|
|
2000-06-10 13:58:13 +04:00
|
|
|
|
|
|
|
|
|
|
|
|
1999-02-17 04:58:25 +03:00
|
|
|
/*
|
|
|
|
WARNING:
|
|
|
|
VC++4.2 is very picky. To compile under VC++4.2, the classes must be defined
|
|
|
|
in an order that satisfies:
|
|
|
|
|
|
|
|
nsDerivedSafe < nsCOMPtr
|
2000-03-18 02:08:18 +03:00
|
|
|
already_AddRefed < nsCOMPtr
|
1999-02-17 04:58:25 +03:00
|
|
|
nsCOMPtr < nsGetterAddRefs
|
1998-12-18 06:45:44 +03:00
|
|
|
|
1999-02-17 04:58:25 +03:00
|
|
|
The other compilers probably won't complain, so please don't reorder these
|
|
|
|
classes, on pain of breaking 4.2 compatibility.
|
|
|
|
*/
|
1998-12-18 06:45:44 +03:00
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
|
|
|
|
template <class T>
|
|
|
|
class nsDerivedSafe : public T
|
|
|
|
/*
|
|
|
|
No client should ever see or have to type the name of this class. It is the
|
|
|
|
artifact that makes it a compile-time error to call |AddRef| and |Release|
|
1999-05-04 13:37:35 +04:00
|
|
|
on a |nsCOMPtr|. DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.
|
1998-12-17 22:12:45 +03:00
|
|
|
|
|
|
|
See |nsCOMPtr::operator->|, |nsCOMPtr::operator*|, et al.
|
1999-08-03 11:21:39 +04:00
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
This type should be a nested class inside |nsCOMPtr<T>|.
|
1998-12-17 22:12:45 +03:00
|
|
|
*/
|
|
|
|
{
|
|
|
|
private:
|
2000-06-05 04:46:37 +04:00
|
|
|
#ifdef HAVE_CPP_ACCESS_CHANGING_USING
|
1998-12-17 22:12:45 +03:00
|
|
|
using T::AddRef;
|
|
|
|
using T::Release;
|
|
|
|
#else
|
2003-02-22 03:32:13 +03:00
|
|
|
nsrefcnt AddRef(void);
|
|
|
|
nsrefcnt Release(void);
|
1998-12-17 22:12:45 +03:00
|
|
|
#endif
|
|
|
|
|
2003-07-22 22:38:01 +04:00
|
|
|
#if !defined(AIX) && !defined(IRIX)
|
1999-06-02 05:59:28 +04:00
|
|
|
void operator delete( void*, size_t ); // NOT TO BE IMPLEMENTED
|
1999-02-17 04:58:25 +03:00
|
|
|
// declaring |operator delete| private makes calling delete on an interface pointer a compile error
|
2000-06-14 04:26:52 +04:00
|
|
|
#endif
|
1998-12-18 06:45:44 +03:00
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
nsDerivedSafe<T>& operator=( const T& ); // NOT TO BE IMPLEMENTED
|
1999-02-17 04:58:25 +03:00
|
|
|
// you may not call |operator=()| through a dereferenced |nsCOMPtr|, because you'd get the wrong one
|
1999-07-23 00:03:42 +04:00
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
/*
|
|
|
|
Compiler warnings and errors: nsDerivedSafe operator=() hides inherited operator=().
|
2000-02-07 00:17:51 +03:00
|
|
|
If you see that, that means somebody checked in a [XP]COM interface class that declares an
|
1999-08-23 14:07:16 +04:00
|
|
|
|operator=()|, and that's _bad_. So bad, in fact, that this declaration exists explicitly
|
|
|
|
to stop people from doing it.
|
|
|
|
*/
|
2003-06-19 22:21:39 +04:00
|
|
|
|
|
|
|
protected:
|
|
|
|
nsDerivedSafe(); // NOT TO BE IMPLEMENTED
|
|
|
|
/*
|
|
|
|
This ctor exists to avoid compile errors and warnings about nsDeriviedSafe using the
|
|
|
|
default ctor but inheriting classes without an empty ctor. See bug 209667.
|
|
|
|
*/
|
1998-12-17 22:12:45 +03:00
|
|
|
};
|
|
|
|
|
2000-06-05 04:46:37 +04:00
|
|
|
#if !defined(HAVE_CPP_ACCESS_CHANGING_USING) && defined(NEED_CPP_UNUSED_IMPLEMENTATIONS)
|
1998-12-17 22:12:45 +03:00
|
|
|
template <class T>
|
|
|
|
nsrefcnt
|
|
|
|
nsDerivedSafe<T>::AddRef()
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
nsrefcnt
|
|
|
|
nsDerivedSafe<T>::Release()
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2000-03-18 02:08:18 +03:00
|
|
|
|
|
|
|
template <class T>
|
|
|
|
struct already_AddRefed
|
|
|
|
/*
|
|
|
|
...cooperates with |nsCOMPtr| to allow you to assign in a pointer _without_
|
|
|
|
|AddRef|ing it. You might want to use this as a return type from a function
|
|
|
|
that produces an already |AddRef|ed pointer as a result.
|
|
|
|
|
|
|
|
See also |getter_AddRefs()|, |dont_AddRef()|, and |class nsGetterAddRefs|.
|
|
|
|
|
|
|
|
This type should be a nested class inside |nsCOMPtr<T>|.
|
|
|
|
|
|
|
|
Yes, |already_AddRefed| could have been implemented as an |nsCOMPtr_helper| to
|
|
|
|
avoid adding specialized machinery to |nsCOMPtr| ... but this is the simplest
|
|
|
|
case, and perhaps worth the savings in time and space that its specific
|
|
|
|
implementation affords over the more general solution offered by
|
|
|
|
|nsCOMPtr_helper|.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
already_AddRefed( T* aRawPtr )
|
|
|
|
: mRawPtr(aRawPtr)
|
|
|
|
{
|
|
|
|
// nothing else to do here
|
|
|
|
}
|
|
|
|
|
2001-05-03 14:15:09 +04:00
|
|
|
T* get() const { return mRawPtr; }
|
2000-03-18 02:08:18 +03:00
|
|
|
|
|
|
|
T* mRawPtr;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
const already_AddRefed<T>
|
|
|
|
getter_AddRefs( T* aRawPtr )
|
|
|
|
/*
|
|
|
|
...makes typing easier, because it deduces the template type, e.g.,
|
|
|
|
you write |dont_AddRef(fooP)| instead of |already_AddRefed<IFoo>(fooP)|.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
return already_AddRefed<T>(aRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
const already_AddRefed<T>
|
2003-02-25 18:53:36 +03:00
|
|
|
getter_AddRefs( const already_AddRefed<T> aAlreadyAddRefedPtr )
|
2000-03-18 02:08:18 +03:00
|
|
|
{
|
|
|
|
return aAlreadyAddRefedPtr;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
const already_AddRefed<T>
|
|
|
|
dont_AddRef( T* aRawPtr )
|
|
|
|
{
|
|
|
|
return already_AddRefed<T>(aRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
const already_AddRefed<T>
|
|
|
|
dont_AddRef( const already_AddRefed<T> aAlreadyAddRefedPtr )
|
|
|
|
{
|
|
|
|
return aAlreadyAddRefedPtr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
1999-10-31 03:35:48 +03:00
|
|
|
class nsCOMPtr_helper
|
1999-11-08 14:43:11 +03:00
|
|
|
/*
|
|
|
|
An |nsCOMPtr_helper| transforms commonly called getters into typesafe forms
|
|
|
|
that are more convenient to call, and more efficient to use with |nsCOMPtr|s.
|
|
|
|
Good candidates for helpers are |QueryInterface()|, |CreateInstance()|, etc.
|
|
|
|
|
|
|
|
Here are the rules for a helper:
|
2000-01-30 01:29:08 +03:00
|
|
|
- it implements |operator()| to produce an interface pointer
|
|
|
|
- (except for its name) |operator()| is a valid [XP]COM `getter'
|
|
|
|
- the interface pointer that it returns is already |AddRef()|ed (as from any good getter)
|
1999-11-08 14:43:11 +03:00
|
|
|
- it matches the type requested with the supplied |nsIID| argument
|
|
|
|
- its constructor provides an optional |nsresult*| that |operator()| can fill
|
|
|
|
in with an error when it is executed
|
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
See |class nsGetInterface| for an example.
|
1999-11-08 14:43:11 +03:00
|
|
|
*/
|
|
|
|
{
|
|
|
|
public:
|
2004-07-15 02:14:34 +04:00
|
|
|
virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const = 0;
|
1999-11-08 14:43:11 +03:00
|
|
|
};
|
1999-10-31 03:35:48 +03:00
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
/*
|
|
|
|
|nsQueryInterface| could have been implemented as an |nsCOMPtr_helper| to
|
|
|
|
avoid adding specialized machinery in |nsCOMPtr|, But |do_QueryInterface|
|
|
|
|
is called often enough that the codesize savings are big enough to
|
|
|
|
warrant the specialcasing.
|
|
|
|
*/
|
|
|
|
|
2004-10-29 23:43:51 +04:00
|
|
|
class NS_COM_GLUE nsQueryInterface
|
2004-03-05 02:04:27 +03:00
|
|
|
{
|
|
|
|
public:
|
2004-10-26 01:45:00 +04:00
|
|
|
explicit
|
2004-03-05 02:04:27 +03:00
|
|
|
nsQueryInterface( nsISupports* aRawPtr )
|
|
|
|
: mRawPtr(aRawPtr)
|
|
|
|
{
|
|
|
|
// nothing else to do here
|
|
|
|
}
|
|
|
|
|
2004-07-15 02:14:34 +04:00
|
|
|
nsresult NS_FASTCALL operator()( const nsIID& aIID, void** ) const;
|
2004-03-05 02:04:27 +03:00
|
|
|
|
|
|
|
private:
|
|
|
|
nsISupports* mRawPtr;
|
|
|
|
};
|
|
|
|
|
2004-10-29 23:43:51 +04:00
|
|
|
class NS_COM_GLUE nsQueryInterfaceWithError
|
1999-11-08 14:43:11 +03:00
|
|
|
{
|
|
|
|
public:
|
2004-03-05 02:04:27 +03:00
|
|
|
nsQueryInterfaceWithError( nsISupports* aRawPtr, nsresult* error )
|
1999-11-08 14:43:11 +03:00
|
|
|
: mRawPtr(aRawPtr),
|
|
|
|
mErrorPtr(error)
|
|
|
|
{
|
|
|
|
// nothing else to do here
|
|
|
|
}
|
|
|
|
|
2004-07-15 02:14:34 +04:00
|
|
|
nsresult NS_FASTCALL operator()( const nsIID& aIID, void** ) const;
|
1999-11-08 14:43:11 +03:00
|
|
|
|
|
|
|
private:
|
|
|
|
nsISupports* mRawPtr;
|
1999-11-20 11:19:24 +03:00
|
|
|
nsresult* mErrorPtr;
|
1999-11-08 14:43:11 +03:00
|
|
|
};
|
1999-02-17 04:58:25 +03:00
|
|
|
|
|
|
|
inline
|
2004-03-05 02:04:27 +03:00
|
|
|
nsQueryInterface
|
|
|
|
do_QueryInterface( nsISupports* aRawPtr )
|
1999-02-17 04:58:25 +03:00
|
|
|
{
|
2004-03-05 02:04:27 +03:00
|
|
|
return nsQueryInterface(aRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
|
|
nsQueryInterfaceWithError
|
|
|
|
do_QueryInterface( nsISupports* aRawPtr, nsresult* error )
|
|
|
|
{
|
|
|
|
return nsQueryInterfaceWithError(aRawPtr, error);
|
1999-02-17 04:58:25 +03:00
|
|
|
}
|
|
|
|
|
2000-03-18 02:08:18 +03:00
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
void
|
2000-03-23 01:52:17 +03:00
|
|
|
do_QueryInterface( already_AddRefed<T>& )
|
2000-03-18 02:08:18 +03:00
|
|
|
{
|
|
|
|
// This signature exists soley to _stop_ you from doing the bad thing.
|
2000-03-23 01:52:17 +03:00
|
|
|
// Saying |do_QueryInterface()| on a pointer that is not otherwise owned by
|
|
|
|
// someone else is an automatic leak. See <http://bugzilla.mozilla.org/show_bug.cgi?id=8221>.
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
void
|
|
|
|
do_QueryInterface( already_AddRefed<T>&, nsresult* )
|
|
|
|
{
|
|
|
|
// This signature exists soley to _stop_ you from doing the bad thing.
|
|
|
|
// Saying |do_QueryInterface()| on a pointer that is not otherwise owned by
|
|
|
|
// someone else is an automatic leak. See <http://bugzilla.mozilla.org/show_bug.cgi?id=8221>.
|
2000-03-18 02:08:18 +03:00
|
|
|
}
|
|
|
|
|
1999-08-03 11:21:39 +04:00
|
|
|
|
2004-11-25 01:48:45 +03:00
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Using servicemanager with COMPtrs
|
|
|
|
class NS_COM_GLUE nsGetServiceByCID
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsGetServiceByCID(const nsCID& aCID)
|
|
|
|
: mCID(aCID)
|
|
|
|
{
|
|
|
|
// nothing else to do
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
const nsCID& mCID;
|
|
|
|
};
|
|
|
|
|
|
|
|
class NS_COM_GLUE nsGetServiceByCIDWithError
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsGetServiceByCIDWithError( const nsCID& aCID, nsresult* aErrorPtr )
|
|
|
|
: mCID(aCID),
|
|
|
|
mErrorPtr(aErrorPtr)
|
|
|
|
{
|
|
|
|
// nothing else to do
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
const nsCID& mCID;
|
|
|
|
nsresult* mErrorPtr;
|
|
|
|
};
|
|
|
|
|
|
|
|
class NS_COM_GLUE nsGetServiceByContractID
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsGetServiceByContractID(const char* aContractID)
|
|
|
|
: mContractID(aContractID)
|
|
|
|
{
|
|
|
|
// nothing else to do
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
const char* mContractID;
|
|
|
|
};
|
|
|
|
|
|
|
|
class NS_COM_GLUE nsGetServiceByContractIDWithError
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
nsGetServiceByContractIDWithError(const char* aContractID, nsresult* aErrorPtr)
|
|
|
|
: mContractID(aContractID),
|
|
|
|
mErrorPtr(aErrorPtr)
|
|
|
|
{
|
|
|
|
// nothing else to do
|
|
|
|
}
|
|
|
|
|
|
|
|
nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
const char* mContractID;
|
|
|
|
nsresult* mErrorPtr;
|
|
|
|
};
|
1999-08-03 11:21:39 +04:00
|
|
|
|
1999-02-17 04:58:25 +03:00
|
|
|
class nsCOMPtr_base
|
1999-06-02 05:59:28 +04:00
|
|
|
/*
|
|
|
|
...factors implementation for all template versions of |nsCOMPtr|.
|
1999-08-03 11:21:39 +04:00
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
This should really be an |nsCOMPtr<nsISupports>|, but this wouldn't work
|
|
|
|
because unlike the
|
1999-08-03 11:21:39 +04:00
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
Here's the way people normally do things like this
|
|
|
|
|
|
|
|
template <class T> class Foo { ... };
|
|
|
|
template <> class Foo<void*> { ... };
|
|
|
|
template <class T> class Foo<T*> : private Foo<void*> { ... };
|
1999-06-02 05:59:28 +04:00
|
|
|
*/
|
1999-02-17 04:58:25 +03:00
|
|
|
{
|
|
|
|
public:
|
1998-12-17 22:12:45 +03:00
|
|
|
|
1999-02-17 04:58:25 +03:00
|
|
|
nsCOMPtr_base( nsISupports* rawPtr = 0 )
|
|
|
|
: mRawPtr(rawPtr)
|
|
|
|
{
|
|
|
|
// nothing else to do here
|
|
|
|
}
|
1998-12-22 02:26:39 +03:00
|
|
|
|
2004-10-29 23:43:51 +04:00
|
|
|
NS_COM_GLUE NS_FASTCALL ~nsCOMPtr_base();
|
1999-05-11 00:48:43 +04:00
|
|
|
|
2004-10-29 23:43:51 +04:00
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_with_AddRef( nsISupports* );
|
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_qi( const nsQueryInterface, const nsIID& );
|
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_qi_with_error( const nsQueryInterfaceWithError&, const nsIID& );
|
2004-11-25 01:48:45 +03:00
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_gs_cid( const nsGetServiceByCID, const nsIID& );
|
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_gs_cid_with_error( const nsGetServiceByCIDWithError&, const nsIID& );
|
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_gs_contractid( const nsGetServiceByContractID, const nsIID& );
|
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_gs_contractid_with_error( const nsGetServiceByContractIDWithError&, const nsIID& );
|
2004-10-29 23:43:51 +04:00
|
|
|
NS_COM_GLUE void NS_FASTCALL assign_from_helper( const nsCOMPtr_helper&, const nsIID& );
|
|
|
|
NS_COM_GLUE void** NS_FASTCALL begin_assignment();
|
1999-02-17 04:58:25 +03:00
|
|
|
|
|
|
|
protected:
|
2003-11-13 10:37:14 +03:00
|
|
|
NS_MAY_ALIAS_PTR(nsISupports) mRawPtr;
|
1999-11-20 11:19:24 +03:00
|
|
|
|
2001-10-23 07:50:24 +04:00
|
|
|
void
|
2000-01-30 01:29:08 +03:00
|
|
|
assign_assuming_AddRef( nsISupports* newPtr )
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
|AddRef()|ing the new value (before entering this function) before
|
|
|
|
|Release()|ing the old lets us safely ignore the self-assignment case.
|
|
|
|
We must, however, be careful only to |Release()| _after_ doing the
|
|
|
|
assignment, in case the |Release()| leads to our _own_ destruction,
|
|
|
|
which would, in turn, cause an incorrect second |Release()| of our old
|
2000-03-18 08:17:46 +03:00
|
|
|
pointer. Thank <waterson@netscape.com> for discovering this.
|
2000-01-30 01:29:08 +03:00
|
|
|
*/
|
|
|
|
nsISupports* oldPtr = mRawPtr;
|
|
|
|
mRawPtr = newPtr;
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, newPtr);
|
2003-02-25 18:53:36 +03:00
|
|
|
NSCAP_LOG_RELEASE(this, oldPtr);
|
2000-01-30 01:29:08 +03:00
|
|
|
if ( oldPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_RELEASE(this, oldPtr);
|
2000-01-30 01:29:08 +03:00
|
|
|
}
|
1999-02-17 04:58:25 +03:00
|
|
|
};
|
1998-12-22 02:26:39 +03:00
|
|
|
|
1999-08-03 14:44:12 +04:00
|
|
|
// template <class T> class nsGetterAddRefs;
|
1998-12-22 02:26:39 +03:00
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
template <class T>
|
1999-07-15 07:59:09 +04:00
|
|
|
class nsCOMPtr
|
2003-10-23 03:29:00 +04:00
|
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
1999-08-23 14:07:16 +04:00
|
|
|
: private nsCOMPtr_base
|
1999-07-15 07:59:09 +04:00
|
|
|
#endif
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
2000-03-18 08:17:46 +03:00
|
|
|
|
2003-10-23 03:29:00 +04:00
|
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
|
|
|
#define NSCAP_CTOR_BASE(x) nsCOMPtr_base(x)
|
|
|
|
#else
|
|
|
|
#define NSCAP_CTOR_BASE(x) mRawPtr(x)
|
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
private:
|
|
|
|
void assign_with_AddRef( nsISupports* );
|
2004-03-05 02:04:27 +03:00
|
|
|
void assign_from_qi( const nsQueryInterface, const nsIID& );
|
|
|
|
void assign_from_qi_with_error( const nsQueryInterfaceWithError&, const nsIID& );
|
2004-11-25 01:48:45 +03:00
|
|
|
void assign_from_gs_cid( const nsGetServiceByCID, const nsIID& );
|
|
|
|
void assign_from_gs_cid_with_error( const nsGetServiceByCIDWithError&, const nsIID& );
|
|
|
|
void assign_from_gs_contractid( const nsGetServiceByContractID, const nsIID& );
|
|
|
|
void assign_from_gs_contractid_with_error( const nsGetServiceByContractIDWithError&, const nsIID& );
|
1999-11-08 14:43:11 +03:00
|
|
|
void assign_from_helper( const nsCOMPtr_helper&, const nsIID& );
|
1999-08-23 14:07:16 +04:00
|
|
|
void** begin_assignment();
|
1999-07-15 07:59:09 +04:00
|
|
|
|
1999-11-20 11:19:24 +03:00
|
|
|
void
|
|
|
|
assign_assuming_AddRef( T* newPtr )
|
|
|
|
{
|
|
|
|
T* oldPtr = mRawPtr;
|
|
|
|
mRawPtr = newPtr;
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, newPtr);
|
2003-02-25 18:53:36 +03:00
|
|
|
NSCAP_LOG_RELEASE(this, oldPtr);
|
1999-11-20 11:19:24 +03:00
|
|
|
if ( oldPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_RELEASE(this, oldPtr);
|
1999-11-20 11:19:24 +03:00
|
|
|
}
|
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
private:
|
|
|
|
T* mRawPtr;
|
1999-07-15 07:59:09 +04:00
|
|
|
#endif
|
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
public:
|
|
|
|
typedef T element_type;
|
1999-06-30 01:09:59 +04:00
|
|
|
|
2003-10-23 03:29:00 +04:00
|
|
|
#ifndef NSCAP_FEATURE_USE_BASE
|
1999-06-02 05:59:28 +04:00
|
|
|
~nsCOMPtr()
|
|
|
|
{
|
2003-02-25 18:53:36 +03:00
|
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
1999-06-02 05:59:28 +04:00
|
|
|
if ( mRawPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_RELEASE(this, mRawPtr);
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-11 00:48:43 +04:00
|
|
|
#endif
|
|
|
|
|
1999-06-30 01:09:59 +04:00
|
|
|
#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
1999-08-23 14:07:16 +04:00
|
|
|
void
|
|
|
|
Assert_NoQueryNeeded()
|
|
|
|
{
|
1999-07-15 07:59:09 +04:00
|
|
|
if ( mRawPtr )
|
1999-08-23 14:07:16 +04:00
|
|
|
{
|
2000-06-10 13:58:13 +04:00
|
|
|
nsCOMPtr<T> query_result( do_QueryInterface(mRawPtr) );
|
|
|
|
NS_ASSERTION(query_result.get() == mRawPtr, "QueryInterface needed");
|
1999-08-23 14:07:16 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-07-31 23:05:34 +04:00
|
|
|
#define NSCAP_ASSERT_NO_QUERY_NEEDED() Assert_NoQueryNeeded();
|
1999-07-15 07:59:09 +04:00
|
|
|
#else
|
2001-07-31 23:05:34 +04:00
|
|
|
#define NSCAP_ASSERT_NO_QUERY_NEEDED()
|
1999-06-30 01:09:59 +04:00
|
|
|
#endif
|
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
// Constructors
|
1999-07-15 07:59:09 +04:00
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsCOMPtr()
|
|
|
|
: NSCAP_CTOR_BASE(0)
|
|
|
|
// default constructor
|
|
|
|
{
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
1999-02-17 04:58:25 +03:00
|
|
|
}
|
1998-12-22 02:26:39 +03:00
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
nsCOMPtr( const nsCOMPtr<T>& aSmartPtr )
|
1999-11-08 14:43:11 +03:00
|
|
|
: NSCAP_CTOR_BASE(aSmartPtr.mRawPtr)
|
|
|
|
// copy-constructor
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
|
|
|
if ( mRawPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_ADDREF(this, mRawPtr);
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
|
1998-12-17 22:12:45 +03:00
|
|
|
}
|
|
|
|
|
1999-06-02 05:59:28 +04:00
|
|
|
nsCOMPtr( T* aRawPtr )
|
1999-11-08 14:43:11 +03:00
|
|
|
: NSCAP_CTOR_BASE(aRawPtr)
|
|
|
|
// construct from a raw pointer (of the right type)
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
|
|
|
if ( mRawPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_ADDREF(this, mRawPtr);
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, aRawPtr);
|
1999-08-23 14:07:16 +04:00
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
2000-03-18 02:08:18 +03:00
|
|
|
nsCOMPtr( const already_AddRefed<T>& aSmartPtr )
|
1999-11-08 14:43:11 +03:00
|
|
|
: NSCAP_CTOR_BASE(aSmartPtr.mRawPtr)
|
|
|
|
// construct from |dont_AddRef(expr)|
|
|
|
|
{
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
|
1999-11-08 14:43:11 +03:00
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
|
|
}
|
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
nsCOMPtr( const nsQueryInterface qi )
|
1999-11-08 14:43:11 +03:00
|
|
|
: NSCAP_CTOR_BASE(0)
|
2004-03-05 02:04:27 +03:00
|
|
|
// construct from |do_QueryInterface(expr)|
|
1999-11-08 14:43:11 +03:00
|
|
|
{
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
2004-03-05 02:04:27 +03:00
|
|
|
assign_from_qi(qi, NS_GET_IID(T));
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
nsCOMPtr( const nsQueryInterfaceWithError& qi )
|
2000-01-30 01:29:08 +03:00
|
|
|
: NSCAP_CTOR_BASE(0)
|
2004-03-05 02:04:27 +03:00
|
|
|
// construct from |do_QueryInterface(expr, &rv)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_qi_with_error(qi, NS_GET_IID(T));
|
|
|
|
}
|
|
|
|
|
2004-11-25 01:48:45 +03:00
|
|
|
nsCOMPtr( const nsGetServiceByCID gs )
|
|
|
|
: NSCAP_CTOR_BASE(0)
|
|
|
|
// construct from |do_GetService(cid_expr)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_cid(gs, NS_GET_IID(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsGetServiceByCIDWithError& gs )
|
|
|
|
: NSCAP_CTOR_BASE(0)
|
|
|
|
// construct from |do_GetService(cid_expr, &rv)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_cid_with_error(gs, NS_GET_IID(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsGetServiceByContractID gs )
|
|
|
|
: NSCAP_CTOR_BASE(0)
|
|
|
|
// construct from |do_GetService(contractid_expr)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_contractid(gs, NS_GET_IID(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsGetServiceByContractIDWithError& gs )
|
|
|
|
: NSCAP_CTOR_BASE(0)
|
|
|
|
// construct from |do_GetService(contractid_expr, &rv)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_contractid_with_error(gs, NS_GET_IID(T));
|
|
|
|
}
|
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
nsCOMPtr( const nsCOMPtr_helper& helper )
|
|
|
|
: NSCAP_CTOR_BASE(0)
|
|
|
|
// ...and finally, anything else we might need to construct from
|
|
|
|
// can exploit the |nsCOMPtr_helper| facility
|
2000-01-30 01:29:08 +03:00
|
|
|
{
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
2000-01-30 01:29:08 +03:00
|
|
|
assign_from_helper(helper, NS_GET_IID(T));
|
2004-03-05 02:04:27 +03:00
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
2000-01-30 01:29:08 +03:00
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
|
|
|
|
// Assignment operators
|
|
|
|
|
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( const nsCOMPtr<T>& rhs )
|
|
|
|
// copy assignment operator
|
|
|
|
{
|
|
|
|
assign_with_AddRef(rhs.mRawPtr);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
1999-05-05 14:37:05 +04:00
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( T* rhs )
|
1999-11-08 14:43:11 +03:00
|
|
|
// assign from a raw pointer (of the right type)
|
1999-05-05 14:37:05 +04:00
|
|
|
{
|
|
|
|
assign_with_AddRef(rhs);
|
1999-08-23 14:07:16 +04:00
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
1999-05-05 14:37:05 +04:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
1999-02-17 04:58:25 +03:00
|
|
|
nsCOMPtr<T>&
|
2000-03-18 02:08:18 +03:00
|
|
|
operator=( const already_AddRefed<T>& rhs )
|
1999-11-08 14:43:11 +03:00
|
|
|
// assign from |dont_AddRef(expr)|
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
2000-01-30 01:29:08 +03:00
|
|
|
assign_assuming_AddRef(rhs.mRawPtr);
|
1999-08-23 14:07:16 +04:00
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
1998-12-17 22:12:45 +03:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
1999-02-17 04:58:25 +03:00
|
|
|
nsCOMPtr<T>&
|
2004-03-05 02:04:27 +03:00
|
|
|
operator=( const nsQueryInterface rhs )
|
|
|
|
// assign from |do_QueryInterface(expr)|
|
1999-02-17 04:58:25 +03:00
|
|
|
{
|
2004-03-05 02:04:27 +03:00
|
|
|
assign_from_qi(rhs, NS_GET_IID(T));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( const nsQueryInterfaceWithError& rhs )
|
|
|
|
// assign from |do_QueryInterface(expr, &rv)|
|
|
|
|
{
|
|
|
|
assign_from_qi_with_error(rhs, NS_GET_IID(T));
|
1999-02-17 04:58:25 +03:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2004-11-25 01:48:45 +03:00
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( const nsGetServiceByCID rhs )
|
|
|
|
// assign from |do_GetService(cid_expr)|
|
|
|
|
{
|
|
|
|
assign_from_gs_cid(rhs, NS_GET_IID(T));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( const nsGetServiceByCIDWithError& rhs )
|
|
|
|
// assign from |do_GetService(cid_expr, &rv)|
|
|
|
|
{
|
|
|
|
assign_from_gs_cid_with_error(rhs, NS_GET_IID(T));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( const nsGetServiceByContractID rhs )
|
|
|
|
// assign from |do_GetService(contractid_expr)|
|
|
|
|
{
|
|
|
|
assign_from_gs_contractid(rhs, NS_GET_IID(T));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<T>&
|
|
|
|
operator=( const nsGetServiceByContractIDWithError& rhs )
|
|
|
|
// assign from |do_GetService(contractid_expr, &rv)|
|
|
|
|
{
|
|
|
|
assign_from_gs_contractid_with_error(rhs, NS_GET_IID(T));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2000-01-30 01:29:08 +03:00
|
|
|
nsCOMPtr<T>&
|
2004-03-05 02:04:27 +03:00
|
|
|
operator=( const nsCOMPtr_helper& rhs )
|
|
|
|
// ...and finally, anything else we might need to assign from
|
|
|
|
// can exploit the |nsCOMPtr_helper| facility.
|
2000-01-30 01:29:08 +03:00
|
|
|
{
|
|
|
|
assign_from_helper(rhs, NS_GET_IID(T));
|
2004-03-05 02:04:27 +03:00
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
2000-01-30 01:29:08 +03:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2003-02-25 18:53:36 +03:00
|
|
|
void
|
|
|
|
swap( nsCOMPtr<T>& rhs )
|
|
|
|
// ...exchange ownership with |rhs|; can save a pair of refcount operations
|
|
|
|
{
|
2003-10-23 03:29:00 +04:00
|
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
2003-02-25 18:53:36 +03:00
|
|
|
nsISupports* temp = rhs.mRawPtr;
|
2003-10-23 03:29:00 +04:00
|
|
|
#else
|
|
|
|
T* temp = rhs.mRawPtr;
|
2003-02-25 18:53:36 +03:00
|
|
|
#endif
|
|
|
|
NSCAP_LOG_ASSIGNMENT(&rhs, mRawPtr);
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
|
|
NSCAP_LOG_RELEASE(&rhs, temp);
|
|
|
|
rhs.mRawPtr = mRawPtr;
|
|
|
|
mRawPtr = temp;
|
|
|
|
// |rhs| maintains the same invariants, so we don't need to |NSCAP_ASSERT_NO_QUERY_NEEDED|
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
swap( T*& rhs )
|
|
|
|
// ...exchange ownership with |rhs|; can save a pair of refcount operations
|
|
|
|
{
|
2003-10-23 03:29:00 +04:00
|
|
|
#ifdef NSCAP_FEATURE_USE_BASE
|
2003-02-25 18:53:36 +03:00
|
|
|
nsISupports* temp = rhs;
|
2003-10-23 03:29:00 +04:00
|
|
|
#else
|
|
|
|
T* temp = rhs;
|
2003-02-25 18:53:36 +03:00
|
|
|
#endif
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
2003-02-25 22:43:41 +03:00
|
|
|
rhs = NS_REINTERPRET_CAST(T*, mRawPtr);
|
2003-02-25 18:53:36 +03:00
|
|
|
mRawPtr = temp;
|
|
|
|
NSCAP_ASSERT_NO_QUERY_NEEDED();
|
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
|
|
|
|
// Other pointer operators
|
1999-02-17 04:58:25 +03:00
|
|
|
|
|
|
|
nsDerivedSafe<T>*
|
|
|
|
get() const
|
1999-11-08 14:43:11 +03:00
|
|
|
/*
|
2000-01-30 01:29:08 +03:00
|
|
|
Prefer the implicit conversion provided automatically by |operator nsDerivedSafe<T>*() const|.
|
1999-11-08 14:43:11 +03:00
|
|
|
Use |get()| _only_ to resolve ambiguity.
|
|
|
|
|
|
|
|
Returns a |nsDerivedSafe<T>*| to deny clients the use of |AddRef| and |Release|.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
return NS_REINTERPRET_CAST(nsDerivedSafe<T>*, mRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
operator nsDerivedSafe<T>*() const
|
|
|
|
/*
|
|
|
|
...makes an |nsCOMPtr| act like its underlying raw pointer type (except against |AddRef()|, |Release()|,
|
|
|
|
and |delete|) whenever it is used in a context where a raw pointer is expected. It is this operator
|
|
|
|
that makes an |nsCOMPtr| substitutable for a raw pointer.
|
|
|
|
|
|
|
|
Prefer the implicit use of this operator to calling |get()|, except where necessary to resolve ambiguity.
|
|
|
|
*/
|
1999-02-17 04:58:25 +03:00
|
|
|
{
|
1999-11-08 14:43:11 +03:00
|
|
|
return get();
|
1999-02-17 04:58:25 +03:00
|
|
|
}
|
1998-12-17 22:12:45 +03:00
|
|
|
|
|
|
|
nsDerivedSafe<T>*
|
|
|
|
operator->() const
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator->().");
|
|
|
|
return get();
|
|
|
|
}
|
|
|
|
|
2000-12-10 06:13:53 +03:00
|
|
|
#ifdef CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
// broken version for IRIX
|
|
|
|
|
|
|
|
nsCOMPtr<T>*
|
|
|
|
get_address() const
|
2001-02-04 22:57:29 +03:00
|
|
|
// This is not intended to be used by clients. See |address_of|
|
|
|
|
// below.
|
2000-12-10 06:13:53 +03:00
|
|
|
{
|
|
|
|
return NS_CONST_CAST(nsCOMPtr<T>*, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else // CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
2000-12-09 07:45:43 +03:00
|
|
|
nsCOMPtr<T>*
|
|
|
|
get_address()
|
2001-02-04 22:57:29 +03:00
|
|
|
// This is not intended to be used by clients. See |address_of|
|
|
|
|
// below.
|
2000-12-09 07:45:43 +03:00
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
const nsCOMPtr<T>*
|
|
|
|
get_address() const
|
2001-02-04 22:57:29 +03:00
|
|
|
// This is not intended to be used by clients. See |address_of|
|
|
|
|
// below.
|
2000-12-09 07:45:43 +03:00
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2000-12-10 06:13:53 +03:00
|
|
|
#endif // CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
2001-02-04 22:57:29 +03:00
|
|
|
public:
|
1998-12-17 22:12:45 +03:00
|
|
|
nsDerivedSafe<T>&
|
|
|
|
operator*() const
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator*().");
|
|
|
|
return *get();
|
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
#if 0
|
|
|
|
private:
|
|
|
|
friend class nsGetterAddRefs<T>;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
T**
|
|
|
|
StartAssignment()
|
|
|
|
{
|
|
|
|
#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
|
|
|
|
return NS_REINTERPRET_CAST(T**, begin_assignment());
|
|
|
|
#else
|
1999-11-20 11:19:24 +03:00
|
|
|
assign_assuming_AddRef(0);
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_REINTERPRET_CAST(T**, &mRawPtr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2000-01-30 01:29:08 +03:00
|
|
|
Specializing |nsCOMPtr| for |nsISupports| allows us to use |nsCOMPtr<nsISupports>| the
|
|
|
|
same way people use |nsISupports*| and |void*|, i.e., as a `catch-all' pointer pointing
|
|
|
|
to any valid [XP]COM interface. Otherwise, an |nsCOMPtr<nsISupports>| would only be able
|
|
|
|
to point to the single [XP]COM-correct |nsISupports| instance within an object; extra
|
|
|
|
querying ensues. Clients need to be able to pass around arbitrary interface pointers,
|
|
|
|
without hassles, through intermediary code that doesn't know the exact type.
|
1999-11-08 14:43:11 +03:00
|
|
|
*/
|
|
|
|
|
2000-01-13 08:48:47 +03:00
|
|
|
NS_SPECIALIZE_TEMPLATE
|
1999-11-08 14:43:11 +03:00
|
|
|
class nsCOMPtr<nsISupports>
|
|
|
|
: private nsCOMPtr_base
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
typedef nsISupports element_type;
|
|
|
|
|
|
|
|
// Constructors
|
|
|
|
|
|
|
|
nsCOMPtr()
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// default constructor
|
|
|
|
{
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsCOMPtr<nsISupports>& aSmartPtr )
|
|
|
|
: nsCOMPtr_base(aSmartPtr.mRawPtr)
|
|
|
|
// copy constructor
|
|
|
|
{
|
|
|
|
if ( mRawPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_ADDREF(this, mRawPtr);
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( nsISupports* aRawPtr )
|
|
|
|
: nsCOMPtr_base(aRawPtr)
|
|
|
|
// construct from a raw pointer (of the right type)
|
|
|
|
{
|
|
|
|
if ( mRawPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_ADDREF(this, mRawPtr);
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, aRawPtr);
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
2000-03-18 02:08:18 +03:00
|
|
|
nsCOMPtr( const already_AddRefed<nsISupports>& aSmartPtr )
|
1999-11-08 14:43:11 +03:00
|
|
|
: nsCOMPtr_base(aSmartPtr.mRawPtr)
|
|
|
|
// construct from |dont_AddRef(expr)|
|
|
|
|
{
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
nsCOMPtr( const nsQueryInterface qi )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// assign from |do_QueryInterface(expr)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_qi(qi, NS_GET_IID(nsISupports));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsQueryInterfaceWithError& qi )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// assign from |do_QueryInterface(expr, &rv)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_qi_with_error(qi, NS_GET_IID(nsISupports));
|
|
|
|
}
|
|
|
|
|
2004-11-25 01:48:45 +03:00
|
|
|
nsCOMPtr( const nsGetServiceByCID gs )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// assign from |do_GetService(cid_expr)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_cid(gs, NS_GET_IID(nsISupports));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsGetServiceByCIDWithError& gs )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// assign from |do_GetService(cid_expr, &rv)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_cid_with_error(gs, NS_GET_IID(nsISupports));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsGetServiceByContractID gs )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// assign from |do_GetService(contractid_expr)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_contractid(gs, NS_GET_IID(nsISupports));
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr( const nsGetServiceByContractIDWithError& gs )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// assign from |do_GetService(contractid_expr, &rv)|
|
|
|
|
{
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
|
|
|
assign_from_gs_contractid_with_error(gs, NS_GET_IID(nsISupports));
|
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsCOMPtr( const nsCOMPtr_helper& helper )
|
|
|
|
: nsCOMPtr_base(0)
|
|
|
|
// ...and finally, anything else we might need to construct from
|
|
|
|
// can exploit the |nsCOMPtr_helper| facility
|
|
|
|
{
|
2000-06-10 13:58:13 +04:00
|
|
|
NSCAP_LOG_ASSIGNMENT(this, 0);
|
1999-11-08 15:25:11 +03:00
|
|
|
assign_from_helper(helper, NS_GET_IID(nsISupports));
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Assignment operators
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsCOMPtr<nsISupports>& rhs )
|
|
|
|
// copy assignment operator
|
|
|
|
{
|
|
|
|
assign_with_AddRef(rhs.mRawPtr);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( nsISupports* rhs )
|
|
|
|
// assign from a raw pointer (of the right type)
|
|
|
|
{
|
|
|
|
assign_with_AddRef(rhs);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
2000-03-18 02:08:18 +03:00
|
|
|
operator=( const already_AddRefed<nsISupports>& rhs )
|
1999-11-08 14:43:11 +03:00
|
|
|
// assign from |dont_AddRef(expr)|
|
|
|
|
{
|
1999-11-20 11:19:24 +03:00
|
|
|
assign_assuming_AddRef(rhs.mRawPtr);
|
1999-11-08 14:43:11 +03:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsQueryInterface rhs )
|
|
|
|
// assign from |do_QueryInterface(expr)|
|
|
|
|
{
|
|
|
|
assign_from_qi(rhs, NS_GET_IID(nsISupports));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsQueryInterfaceWithError& rhs )
|
|
|
|
// assign from |do_QueryInterface(expr, &rv)|
|
|
|
|
{
|
|
|
|
assign_from_qi_with_error(rhs, NS_GET_IID(nsISupports));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2004-11-25 01:48:45 +03:00
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsGetServiceByCID rhs )
|
|
|
|
// assign from |do_GetService(cid_expr)|
|
|
|
|
{
|
|
|
|
assign_from_gs_cid(rhs, NS_GET_IID(nsISupports));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsGetServiceByCIDWithError& rhs )
|
|
|
|
// assign from |do_GetService(cid_expr, &rv)|
|
|
|
|
{
|
|
|
|
assign_from_gs_cid_with_error(rhs, NS_GET_IID(nsISupports));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsGetServiceByContractID rhs )
|
|
|
|
// assign from |do_GetService(contractid_expr)|
|
|
|
|
{
|
|
|
|
assign_from_gs_contractid(rhs, NS_GET_IID(nsISupports));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsGetServiceByContractIDWithError& rhs )
|
|
|
|
// assign from |do_GetService(contractid_expr, &rv)|
|
|
|
|
{
|
|
|
|
assign_from_gs_contractid_with_error(rhs, NS_GET_IID(nsISupports));
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsCOMPtr<nsISupports>&
|
|
|
|
operator=( const nsCOMPtr_helper& rhs )
|
|
|
|
// ...and finally, anything else we might need to assign from
|
|
|
|
// can exploit the |nsCOMPtr_helper| facility.
|
|
|
|
{
|
1999-11-08 15:25:11 +03:00
|
|
|
assign_from_helper(rhs, NS_GET_IID(nsISupports));
|
1999-11-08 14:43:11 +03:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2003-02-25 18:53:36 +03:00
|
|
|
void
|
|
|
|
swap( nsCOMPtr<nsISupports>& rhs )
|
|
|
|
// ...exchange ownership with |rhs|; can save a pair of refcount operations
|
|
|
|
{
|
|
|
|
nsISupports* temp = rhs.mRawPtr;
|
|
|
|
NSCAP_LOG_ASSIGNMENT(&rhs, mRawPtr);
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
|
|
NSCAP_LOG_RELEASE(&rhs, temp);
|
|
|
|
rhs.mRawPtr = mRawPtr;
|
|
|
|
mRawPtr = temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
swap( nsISupports*& rhs )
|
|
|
|
// ...exchange ownership with |rhs|; can save a pair of refcount operations
|
|
|
|
{
|
|
|
|
nsISupports* temp = rhs;
|
|
|
|
NSCAP_LOG_ASSIGNMENT(this, temp);
|
|
|
|
NSCAP_LOG_RELEASE(this, mRawPtr);
|
|
|
|
rhs = mRawPtr;
|
|
|
|
mRawPtr = temp;
|
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
|
|
|
|
// Other pointer operators
|
|
|
|
|
|
|
|
nsDerivedSafe<nsISupports>*
|
|
|
|
get() const
|
|
|
|
/*
|
2000-01-30 01:29:08 +03:00
|
|
|
Prefer the implicit conversion provided automatically by |operator nsDerivedSafe<nsISupports>*() const|.
|
1999-11-08 14:43:11 +03:00
|
|
|
Use |get()| _only_ to resolve ambiguity.
|
|
|
|
|
2000-01-30 01:29:08 +03:00
|
|
|
Returns a |nsDerivedSafe<nsISupports>*| to deny clients the use of |AddRef| and |Release|.
|
1999-11-08 14:43:11 +03:00
|
|
|
*/
|
|
|
|
{
|
|
|
|
return NS_REINTERPRET_CAST(nsDerivedSafe<nsISupports>*, mRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
operator nsDerivedSafe<nsISupports>*() const
|
|
|
|
/*
|
|
|
|
...makes an |nsCOMPtr| act like its underlying raw pointer type (except against |AddRef()|, |Release()|,
|
|
|
|
and |delete|) whenever it is used in a context where a raw pointer is expected. It is this operator
|
|
|
|
that makes an |nsCOMPtr| substitutable for a raw pointer.
|
|
|
|
|
|
|
|
Prefer the implicit use of this operator to calling |get()|, except where necessary to resolve ambiguity.
|
|
|
|
*/
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
|
|
|
return get();
|
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsDerivedSafe<nsISupports>*
|
|
|
|
operator->() const
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator->().");
|
|
|
|
return get();
|
|
|
|
}
|
|
|
|
|
2000-12-10 06:13:53 +03:00
|
|
|
#ifdef CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
// broken version for IRIX
|
|
|
|
|
|
|
|
nsCOMPtr<nsISupports>*
|
|
|
|
get_address() const
|
2001-02-04 22:57:29 +03:00
|
|
|
// This is not intended to be used by clients. See |address_of|
|
|
|
|
// below.
|
2000-12-10 06:13:53 +03:00
|
|
|
{
|
|
|
|
return NS_CONST_CAST(nsCOMPtr<nsISupports>*, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else // CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
2000-12-09 07:45:43 +03:00
|
|
|
nsCOMPtr<nsISupports>*
|
|
|
|
get_address()
|
2001-02-04 22:57:29 +03:00
|
|
|
// This is not intended to be used by clients. See |address_of|
|
|
|
|
// below.
|
2000-12-09 07:45:43 +03:00
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
const nsCOMPtr<nsISupports>*
|
|
|
|
get_address() const
|
2001-02-04 22:57:29 +03:00
|
|
|
// This is not intended to be used by clients. See |address_of|
|
|
|
|
// below.
|
2000-12-09 07:45:43 +03:00
|
|
|
{
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2000-12-10 06:13:53 +03:00
|
|
|
#endif // CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
2001-02-04 22:57:29 +03:00
|
|
|
public:
|
2000-12-09 07:45:43 +03:00
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsDerivedSafe<nsISupports>&
|
|
|
|
operator*() const
|
|
|
|
{
|
|
|
|
NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator*().");
|
|
|
|
return *get();
|
|
|
|
}
|
|
|
|
|
1999-08-03 14:44:12 +04:00
|
|
|
#if 0
|
1998-12-17 22:12:45 +03:00
|
|
|
private:
|
1999-11-08 14:43:11 +03:00
|
|
|
friend class nsGetterAddRefs<nsISupports>;
|
1999-08-03 14:44:12 +04:00
|
|
|
#endif
|
1998-12-17 22:12:45 +03:00
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsISupports**
|
1999-02-17 04:58:25 +03:00
|
|
|
StartAssignment()
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
1999-03-23 23:35:49 +03:00
|
|
|
#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_REINTERPRET_CAST(nsISupports**, begin_assignment());
|
1999-03-23 23:35:49 +03:00
|
|
|
#else
|
1999-11-20 11:19:24 +03:00
|
|
|
assign_assuming_AddRef(0);
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_REINTERPRET_CAST(nsISupports**, &mRawPtr);
|
1999-03-23 23:35:49 +03:00
|
|
|
#endif
|
1998-12-17 22:12:45 +03:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2003-10-23 03:29:00 +04:00
|
|
|
#ifndef NSCAP_FEATURE_USE_BASE
|
1999-07-15 07:59:09 +04:00
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_with_AddRef( nsISupports* rawPtr )
|
1999-08-23 14:07:16 +04:00
|
|
|
{
|
1999-07-15 07:59:09 +04:00
|
|
|
if ( rawPtr )
|
2000-06-08 08:52:39 +04:00
|
|
|
NSCAP_ADDREF(this, rawPtr);
|
1999-11-20 11:19:24 +03:00
|
|
|
assign_assuming_AddRef(NS_REINTERPRET_CAST(T*, rawPtr));
|
1999-08-23 14:07:16 +04:00
|
|
|
}
|
1999-07-15 07:59:09 +04:00
|
|
|
|
2004-03-05 02:04:27 +03:00
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_from_qi( const nsQueryInterface qi, const nsIID& aIID )
|
|
|
|
{
|
|
|
|
T* newRawPtr;
|
|
|
|
if ( NS_FAILED( qi(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
|
|
|
newRawPtr = 0;
|
|
|
|
assign_assuming_AddRef(newRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_from_qi_with_error( const nsQueryInterfaceWithError& qi, const nsIID& aIID )
|
|
|
|
{
|
|
|
|
T* newRawPtr;
|
|
|
|
if ( NS_FAILED( qi(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
|
|
|
newRawPtr = 0;
|
|
|
|
assign_assuming_AddRef(newRawPtr);
|
|
|
|
}
|
|
|
|
|
2004-11-25 01:48:45 +03:00
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_from_gs_cid( const nsGetServiceByCID gs, const nsIID& aIID )
|
|
|
|
{
|
|
|
|
T* newRawPtr;
|
|
|
|
if ( NS_FAILED( gs(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
|
|
|
newRawPtr = 0;
|
|
|
|
assign_assuming_AddRef(newRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_from_gs_cid_with_error( const nsGetServiceByCIDWithError& gs, const nsIID& aIID )
|
|
|
|
{
|
|
|
|
T* newRawPtr;
|
|
|
|
if ( NS_FAILED( gs(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
|
|
|
newRawPtr = 0;
|
|
|
|
assign_assuming_AddRef(newRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_from_gs_contractid( const nsGetServiceByContractID gs, const nsIID& aIID )
|
|
|
|
{
|
|
|
|
T* newRawPtr;
|
|
|
|
if ( NS_FAILED( gs(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
|
|
|
newRawPtr = 0;
|
|
|
|
assign_assuming_AddRef(newRawPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
void
|
|
|
|
nsCOMPtr<T>::assign_from_gs_contractid_with_error( const nsGetServiceByContractIDWithError& gs, const nsIID& aIID )
|
|
|
|
{
|
|
|
|
T* newRawPtr;
|
|
|
|
if ( NS_FAILED( gs(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
|
|
|
newRawPtr = 0;
|
|
|
|
assign_assuming_AddRef(newRawPtr);
|
|
|
|
}
|
|
|
|
|
1999-07-15 07:59:09 +04:00
|
|
|
template <class T>
|
|
|
|
void
|
1999-10-31 03:35:48 +03:00
|
|
|
nsCOMPtr<T>::assign_from_helper( const nsCOMPtr_helper& helper, const nsIID& aIID )
|
1999-11-08 14:43:11 +03:00
|
|
|
{
|
|
|
|
T* newRawPtr;
|
2001-11-22 18:12:51 +03:00
|
|
|
if ( NS_FAILED( helper(aIID, NS_REINTERPRET_CAST(void**, &newRawPtr)) ) )
|
1999-11-08 14:43:11 +03:00
|
|
|
newRawPtr = 0;
|
1999-11-20 11:19:24 +03:00
|
|
|
assign_assuming_AddRef(newRawPtr);
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
1999-08-03 11:21:39 +04:00
|
|
|
|
1999-07-15 07:59:09 +04:00
|
|
|
template <class T>
|
|
|
|
void**
|
|
|
|
nsCOMPtr<T>::begin_assignment()
|
|
|
|
{
|
1999-11-20 11:19:24 +03:00
|
|
|
assign_assuming_AddRef(0);
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_REINTERPRET_CAST(void**, &mRawPtr);
|
1999-07-15 07:59:09 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-12-10 06:13:53 +03:00
|
|
|
#ifdef CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
|
|
|
// This is the broken version for IRIX, which can't handle the version below.
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
nsCOMPtr<T>*
|
|
|
|
address_of( const nsCOMPtr<T>& aPtr )
|
|
|
|
{
|
|
|
|
return aPtr.get_address();
|
|
|
|
}
|
|
|
|
|
|
|
|
#else // CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
2000-12-09 07:45:43 +03:00
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
nsCOMPtr<T>*
|
|
|
|
address_of( nsCOMPtr<T>& aPtr )
|
|
|
|
{
|
|
|
|
return aPtr.get_address();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
const nsCOMPtr<T>*
|
|
|
|
address_of( const nsCOMPtr<T>& aPtr )
|
|
|
|
{
|
|
|
|
return aPtr.get_address();
|
|
|
|
}
|
1998-12-17 22:12:45 +03:00
|
|
|
|
2000-12-10 06:13:53 +03:00
|
|
|
#endif // CANT_RESOLVE_CPP_CONST_AMBIGUITY
|
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
template <class T>
|
|
|
|
class nsGetterAddRefs
|
|
|
|
/*
|
|
|
|
...
|
|
|
|
|
|
|
|
This class is designed to be used for anonymous temporary objects in the
|
|
|
|
argument list of calls that return COM interface pointers, e.g.,
|
|
|
|
|
|
|
|
nsCOMPtr<IFoo> fooP;
|
|
|
|
...->QueryInterface(iid, getter_AddRefs(fooP))
|
|
|
|
|
1999-06-02 05:59:28 +04:00
|
|
|
DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE. Use |getter_AddRefs()| instead.
|
1999-05-04 13:37:35 +04:00
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
When initialized with a |nsCOMPtr|, as in the example above, it returns
|
2000-01-30 01:29:08 +03:00
|
|
|
a |void**|, a |T**|, or an |nsISupports**| as needed, that the outer call (|QueryInterface| in this
|
1999-02-26 22:50:46 +03:00
|
|
|
case) can fill in.
|
1999-07-15 07:59:09 +04:00
|
|
|
|
1999-08-23 14:07:16 +04:00
|
|
|
This type should be a nested class inside |nsCOMPtr<T>|.
|
1998-12-17 22:12:45 +03:00
|
|
|
*/
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit
|
|
|
|
nsGetterAddRefs( nsCOMPtr<T>& aSmartPtr )
|
1999-02-17 04:58:25 +03:00
|
|
|
: mTargetSmartPtr(aSmartPtr)
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
|
|
|
// nothing else to do
|
|
|
|
}
|
|
|
|
|
2000-06-08 08:52:39 +04:00
|
|
|
#if defined(NSCAP_FEATURE_TEST_DONTQUERY_CASES) || defined(NSCAP_LOG_EXTERNAL_ASSIGNMENT)
|
1999-11-08 14:43:11 +03:00
|
|
|
~nsGetterAddRefs()
|
2000-06-08 08:52:39 +04:00
|
|
|
{
|
|
|
|
#ifdef NSCAP_LOG_EXTERNAL_ASSIGNMENT
|
2000-12-09 07:45:43 +03:00
|
|
|
NSCAP_LOG_ASSIGNMENT(NS_REINTERPRET_CAST(void *, address_of(mTargetSmartPtr)), mTargetSmartPtr.get());
|
2000-06-08 08:52:39 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
|
|
|
|
mTargetSmartPtr.Assert_NoQueryNeeded();
|
|
|
|
#endif
|
|
|
|
}
|
1999-10-31 03:35:48 +03:00
|
|
|
#endif
|
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
operator void**()
|
|
|
|
{
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_REINTERPRET_CAST(void**, mTargetSmartPtr.StartAssignment());
|
|
|
|
}
|
|
|
|
|
2000-01-30 01:29:08 +03:00
|
|
|
operator nsISupports**()
|
1999-11-08 14:43:11 +03:00
|
|
|
{
|
2000-01-30 01:29:08 +03:00
|
|
|
return NS_REINTERPRET_CAST(nsISupports**, mTargetSmartPtr.StartAssignment());
|
1999-11-08 14:43:11 +03:00
|
|
|
}
|
|
|
|
|
2000-01-30 01:29:08 +03:00
|
|
|
operator T**()
|
1999-11-08 14:43:11 +03:00
|
|
|
{
|
2000-01-30 01:29:08 +03:00
|
|
|
return mTargetSmartPtr.StartAssignment();
|
1998-12-17 22:12:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
T*&
|
|
|
|
operator*()
|
|
|
|
{
|
1999-02-17 04:58:25 +03:00
|
|
|
return *(mTargetSmartPtr.StartAssignment());
|
1998-12-17 22:12:45 +03:00
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
private:
|
|
|
|
nsCOMPtr<T>& mTargetSmartPtr;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2000-01-13 08:48:47 +03:00
|
|
|
NS_SPECIALIZE_TEMPLATE
|
1999-11-08 14:43:11 +03:00
|
|
|
class nsGetterAddRefs<nsISupports>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit
|
|
|
|
nsGetterAddRefs( nsCOMPtr<nsISupports>& aSmartPtr )
|
|
|
|
: mTargetSmartPtr(aSmartPtr)
|
|
|
|
{
|
|
|
|
// nothing else to do
|
|
|
|
}
|
|
|
|
|
2000-06-08 08:52:39 +04:00
|
|
|
#ifdef NSCAP_LOG_EXTERNAL_ASSIGNMENT
|
|
|
|
~nsGetterAddRefs()
|
|
|
|
{
|
2000-12-09 07:45:43 +03:00
|
|
|
NSCAP_LOG_ASSIGNMENT(NS_REINTERPRET_CAST(void *, address_of(mTargetSmartPtr)), mTargetSmartPtr.get());
|
2000-06-08 08:52:39 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
operator void**()
|
|
|
|
{
|
|
|
|
return NS_REINTERPRET_CAST(void**, mTargetSmartPtr.StartAssignment());
|
|
|
|
}
|
|
|
|
|
|
|
|
operator nsISupports**()
|
1998-12-17 22:12:45 +03:00
|
|
|
{
|
1999-02-17 04:58:25 +03:00
|
|
|
return mTargetSmartPtr.StartAssignment();
|
1998-12-17 22:12:45 +03:00
|
|
|
}
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
nsISupports*&
|
|
|
|
operator*()
|
|
|
|
{
|
|
|
|
return *(mTargetSmartPtr.StartAssignment());
|
|
|
|
}
|
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
private:
|
1999-11-08 14:43:11 +03:00
|
|
|
nsCOMPtr<nsISupports>& mTargetSmartPtr;
|
1998-12-17 22:12:45 +03:00
|
|
|
};
|
|
|
|
|
1999-11-08 14:43:11 +03:00
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
nsGetterAddRefs<T>
|
|
|
|
getter_AddRefs( nsCOMPtr<T>& aSmartPtr )
|
|
|
|
/*
|
|
|
|
Used around a |nsCOMPtr| when
|
|
|
|
...makes the class |nsGetterAddRefs<T>| invisible.
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
return nsGetterAddRefs<T>(aSmartPtr);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
|
|
|
|
// Comparing two |nsCOMPtr|s
|
1999-06-30 01:09:59 +04:00
|
|
|
|
1999-05-05 14:37:05 +04:00
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator==( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_STATIC_CAST(const T*, lhs.get()) == NS_STATIC_CAST(const U*, rhs.get());
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
2000-05-14 04:05:24 +04:00
|
|
|
|
1999-05-05 14:37:05 +04:00
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2000-02-13 02:30:52 +03:00
|
|
|
operator!=( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_STATIC_CAST(const T*, lhs.get()) != NS_STATIC_CAST(const U*, rhs.get());
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
2000-02-13 02:30:52 +03:00
|
|
|
|
|
|
|
|
|
|
|
// Comparing an |nsCOMPtr| to a raw pointer
|
|
|
|
|
1999-05-05 14:37:05 +04:00
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2001-04-07 19:29:39 +04:00
|
|
|
operator==( const nsCOMPtr<T>& lhs, const U* rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_STATIC_CAST(const T*, lhs.get()) == rhs;
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
template <class T, class U>
|
1999-06-02 05:29:55 +04:00
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2001-04-07 19:29:39 +04:00
|
|
|
operator==( const U* lhs, const nsCOMPtr<T>& rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return lhs == NS_STATIC_CAST(const T*, rhs.get());
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-06-02 05:29:55 +04:00
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
template <class T, class U>
|
1999-06-02 05:29:55 +04:00
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2001-04-07 19:29:39 +04:00
|
|
|
operator!=( const nsCOMPtr<T>& lhs, const U* rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_STATIC_CAST(const T*, lhs.get()) != rhs;
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-06-02 05:29:55 +04:00
|
|
|
|
1999-05-05 14:37:05 +04:00
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2001-04-07 19:29:39 +04:00
|
|
|
operator!=( const U* lhs, const nsCOMPtr<T>& rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return lhs != NS_STATIC_CAST(const T*, rhs.get());
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
2001-04-07 19:29:39 +04:00
|
|
|
// To avoid ambiguities caused by the presence of builtin |operator==|s
|
|
|
|
// creating a situation where one of the |operator==| defined above
|
|
|
|
// has a better conversion for one argument and the builtin has a
|
|
|
|
// better conversion for the other argument, define additional
|
|
|
|
// |operator==| without the |const| on the raw pointer.
|
|
|
|
// See bug 65664 for details.
|
2001-04-07 21:25:16 +04:00
|
|
|
|
|
|
|
// This is defined by an autoconf test, but VC++ also has a bug that
|
|
|
|
// prevents us from using these. (It also, fortunately, has the bug
|
|
|
|
// that we don't need them either.)
|
2003-06-05 22:50:16 +04:00
|
|
|
#if defined(_MSC_VER) && (_MSC_VER < 1310)
|
2001-04-07 21:25:16 +04:00
|
|
|
#define NSCAP_DONT_PROVIDE_NONCONST_OPEQ
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
|
2001-04-07 19:29:39 +04:00
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator==( const nsCOMPtr<T>& lhs, U* rhs )
|
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_STATIC_CAST(const T*, lhs.get()) == NS_CONST_CAST(const U*, rhs);
|
2001-04-07 19:29:39 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator==( U* lhs, const nsCOMPtr<T>& rhs )
|
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_CONST_CAST(const U*, lhs) == NS_STATIC_CAST(const T*, rhs.get());
|
2001-04-07 19:29:39 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator!=( const nsCOMPtr<T>& lhs, U* rhs )
|
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_STATIC_CAST(const T*, lhs.get()) != NS_CONST_CAST(const U*, rhs);
|
2001-04-07 19:29:39 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class T, class U>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator!=( U* lhs, const nsCOMPtr<T>& rhs )
|
|
|
|
{
|
2003-10-08 00:43:34 +04:00
|
|
|
return NS_CONST_CAST(const U*, lhs) != NS_STATIC_CAST(const T*, rhs.get());
|
2001-04-07 19:29:39 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
|
|
|
|
|
|
|
|
// Comparing an |nsCOMPtr| to |0|
|
|
|
|
|
|
|
|
class NSCAP_Zero;
|
|
|
|
|
|
|
|
template <class T>
|
1999-05-05 14:37:05 +04:00
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2000-02-13 02:30:52 +03:00
|
|
|
operator==( const nsCOMPtr<T>& lhs, NSCAP_Zero* rhs )
|
|
|
|
// specifically to allow |smartPtr == 0|
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2000-02-13 02:30:52 +03:00
|
|
|
return NS_STATIC_CAST(const void*, lhs.get()) == NS_REINTERPRET_CAST(const void*, rhs);
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
template <class T>
|
1999-05-05 14:37:05 +04:00
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
2000-02-13 02:30:52 +03:00
|
|
|
operator==( NSCAP_Zero* lhs, const nsCOMPtr<T>& rhs )
|
|
|
|
// specifically to allow |0 == smartPtr|
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
2000-02-13 02:30:52 +03:00
|
|
|
return NS_REINTERPRET_CAST(const void*, lhs) == NS_STATIC_CAST(const void*, rhs.get());
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
1999-06-02 05:29:55 +04:00
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
1999-06-30 01:09:59 +04:00
|
|
|
operator!=( const nsCOMPtr<T>& lhs, NSCAP_Zero* rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
// specifically to allow |smartPtr != 0|
|
|
|
|
{
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_STATIC_CAST(const void*, lhs.get()) != NS_REINTERPRET_CAST(const void*, rhs);
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-06-02 05:29:55 +04:00
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
1999-06-30 01:09:59 +04:00
|
|
|
operator!=( NSCAP_Zero* lhs, const nsCOMPtr<T>& rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
// specifically to allow |0 != smartPtr|
|
|
|
|
{
|
1999-11-08 14:43:11 +03:00
|
|
|
return NS_REINTERPRET_CAST(const void*, lhs) != NS_STATIC_CAST(const void*, rhs.get());
|
1999-06-02 05:59:28 +04:00
|
|
|
}
|
1999-06-02 05:29:55 +04:00
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
|
2000-05-13 04:05:29 +04:00
|
|
|
#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
|
|
|
|
|
|
|
|
// We need to explicitly define comparison operators for `int'
|
|
|
|
// because the compiler is lame.
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator==( const nsCOMPtr<T>& lhs, int rhs )
|
|
|
|
// specifically to allow |smartPtr == 0|
|
|
|
|
{
|
|
|
|
return NS_STATIC_CAST(const void*, lhs.get()) == NS_REINTERPRET_CAST(const void*, rhs);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
operator==( int lhs, const nsCOMPtr<T>& rhs )
|
|
|
|
// specifically to allow |0 == smartPtr|
|
|
|
|
{
|
|
|
|
return NS_REINTERPRET_CAST(const void*, lhs) == NS_STATIC_CAST(const void*, rhs.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
|
2000-02-13 02:30:52 +03:00
|
|
|
|
|
|
|
// Comparing any two [XP]COM objects for identity
|
|
|
|
|
1999-05-05 14:37:05 +04:00
|
|
|
inline
|
|
|
|
NSCAP_BOOL
|
|
|
|
SameCOMIdentity( nsISupports* lhs, nsISupports* rhs )
|
1999-06-02 05:59:28 +04:00
|
|
|
{
|
|
|
|
return nsCOMPtr<nsISupports>( do_QueryInterface(lhs) ) == nsCOMPtr<nsISupports>( do_QueryInterface(rhs) );
|
|
|
|
}
|
1999-05-05 14:37:05 +04:00
|
|
|
|
2000-02-13 02:30:52 +03:00
|
|
|
|
|
|
|
|
1999-12-08 04:44:06 +03:00
|
|
|
template <class SourceType, class DestinationType>
|
1999-12-07 17:09:29 +03:00
|
|
|
inline
|
|
|
|
nsresult
|
1999-12-08 04:44:06 +03:00
|
|
|
CallQueryInterface( nsCOMPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr )
|
2000-01-30 01:29:08 +03:00
|
|
|
{
|
|
|
|
return CallQueryInterface(aSourcePtr.get(), aDestPtr);
|
|
|
|
}
|
1999-12-07 17:09:29 +03:00
|
|
|
|
1998-12-17 22:12:45 +03:00
|
|
|
#endif // !defined(nsCOMPtr_h___)
|