Changeset 11008 in vbox

Timestamp:

Jul 30, 2008 6:04:09 PM (16 years ago)

Author:

vboxsync

Message:

iprt: Moved RTMemAutoPtr into iprt/mem.h.

Location:

trunk/include/iprt

Files:

• autores.h (modified) (1 diff)
• mem.h (modified) (4 diffs)

trunk/include/iprt/autores.h

@@ -194 +194 @@
 };
 
-
-/**
- * Template function wrapping RTMemFree to get the correct Destruct
- * signature for RTAutoRes.
- *
- * We can't use a more complex template here, because the g++ on RHEL 3
- * chokes on it with an internal compiler error.
- *
- * @param   T           The data type that's being managed.
- * @param   aMem        Pointer to the memory that should be free.
- */
-template <class T>
-void RTMemAutoFree(T *aMem)
-{
-    RTMemFree(aMem);
-}
-
-
-/**
- * Template function wrapping NULL to get the correct NilRes signature
- * for RTAutoRes.
- *
- * @param   T           The data type that's being managed.
- * @returns NULL with the right type.
- */
-template <class T>
-T *RTMemAutoNil(void)
-{
-    return (T *)(NULL);
-}
-
-
-/**
- * An auto pointer-type template class for managing memory allocating
- * via C APIs like RTMem (the default).
- *
- * The main purpose of this class is to automatically free memory that
- * isn't explicitly used (released()) when the object goes out of scope.
- *
- * As an additional service it can also make the allocations and
- * reallocations for you if you like, but it can also take of memory
- * you hand it.
- *
- * @param   T           The data type to manage allocations for.
- * @param   Destruct    The function to be used to free the resource.
- *                      This will default to RTMemFree.
- * @param   Allocator   The function to be used to allocate or reallocate
- *                      the managed memory.
- *                      This is standard realloc() like stuff, so it's possible
- *                      to support simple allocation without actually having
- *                      to support reallocating memory if that's a problem.
- *                      This will default to RTMemRealloc.
- */
-template <class T, void Destruct(T *) = RTMemAutoFree<T>, void *Allocator(void *, size_t) = RTMemRealloc >
-class RTMemAutoPtr
-    : public RTAutoRes<T *, Destruct, RTMemAutoNil<T> >
-{
-public:
-    /**
-     * Constructor.
-     *
-     * @param   aPtr    Memory pointer to manage. Defaults to NULL.
-     */
-    RTMemAutoPtr(T *aPtr = NULL)
-        : RTAutoRes<T *, Destruct, RTMemAutoNil<T> >(aPtr)
-    {
-    }
-
-    /**
-     * Free current memory and start managing aPtr.
-     *
-     * @param   aPtr    Memory pointer to manage.
-     */
-    RTMemAutoPtr &operator=(T *aPtr)
-    {
-        this->RTAutoRes<T *, Destruct, RTMemAutoNil<T> >::operator=(aPtr);
-        return *this;
-     }
-
-    /**
-     * Dereference with * operator.
-     */
-    T &operator*()
-    {
-         return *this->get();
-    }
-
-    /**
-     * Dereference with -> operator.
-     */
-    T *operator->()
-    {
-        return this->get();
-    }
-
-    /**
-     * Accessed with the subscript operator ([]).
-     *
-     * @returns Reference to the element.
-     * @param   a_i     The element to access.
-     */
-    T &operator[](size_t a_i)
-    {
-        return this->get()[a_i];
-    }
-
-    /**
-     * Allocates memory and start manage it.
-     *
-     * Any previously managed memory will be freed before making
-     * the new allocation.
-     *
-     * The content of the new memory is undefined when using
-     * the default allocator.
-     *
-     * @returns Success indicator.
-     * @retval  true if the new allocation succeeds.
-     * @retval  false on failure, no memory is associated with the object.
-     *
-     * @param   cElements   The new number of elements (of the data type) to allocate.
-     *                      This defaults to 1.
-     */
-    bool alloc(size_t a_cElements = 1)
-    {
-        this->reset(NULL);
-        T *aNewValue = (T *)(Allocator(NULL, a_cElements * sizeof(T)));
-        this->reset(aNewValue);
-        return aNewValue != NULL;
-    }
-
-    /**
-     * Reallocate or allocates the memory resource.
-     *
-     * Free the old value if allocation fails.
-     *
-     * The content of any additional memory that was allocated is
-     * undefined when using the default allocator.
-     *
-     * @returns Success indicator.
-     * @retval  true if the new allocation succeeds.
-     * @retval  false on failure, no memory is associated with the object.
-     *
-     * @param   cElements   The new number of elements (of the data type) to allocate.
-     *                      The size of the allocation is the number of elements times
-     *                      the size of the data type - this is currently what's passed
-     *                      down to the Allocator.
-     *                      This defaults to 1.
-     */
-    bool realloc(size_t a_cElements = 1)
-    {
-        T *aNewValue = (T *)(Allocator(this->get(), a_cElements * sizeof(T)));
-        if (aNewValue != NULL)
-            this->release();
-        /* We want this both if aNewValue is non-NULL and if it is NULL. */
-        this->reset(aNewValue);
-        return aNewValue != NULL;
-    }
-};
-
 #endif
 

trunk/include/iprt/mem.h

@@ -34 +34 @@
 #include <iprt/cdefs.h>
 #include <iprt/types.h>
+#ifdef __cplusplus
+# include <iprt/autores.h>
+#endif
+
 
 #ifdef IN_GC
@@ -39 +43 @@
 #endif
 
-__BEGIN_DECLS
 
 /** @defgroup grp_rt_mem    RTMem - Memory Management and Manipulation
@@ -45 +48 @@
  * @{
  */
+
+__BEGIN_DECLS
 
 /** @def RTMEM_ALIGNMENT
@@ -361 +366 @@
 /** @} */
 
+__END_DECLS
+
+
+#ifdef __cplusplus
+
+/**
+ * Template function wrapping RTMemFree to get the correct Destruct
+ * signature for RTAutoRes.
+ *
+ * We can't use a more complex template here, because the g++ on RHEL 3
+ * chokes on it with an internal compiler error.
+ *
+ * @param   T           The data type that's being managed.
+ * @param   aMem        Pointer to the memory that should be free.
+ */
+template <class T>
+void RTMemAutoFree(T *aMem)
+{
+    RTMemFree(aMem);
+}
+
+
+/**
+ * Template function wrapping NULL to get the correct NilRes signature
+ * for RTAutoRes.
+ *
+ * @param   T           The data type that's being managed.
+ * @returns NULL with the right type.
+ */
+template <class T>
+T *RTMemAutoNil(void)
+{
+    return (T *)(NULL);
+}
+
+
+/**
+ * An auto pointer-type template class for managing memory allocating
+ * via C APIs like RTMem (the default).
+ *
+ * The main purpose of this class is to automatically free memory that
+ * isn't explicitly used (released()) when the object goes out of scope.
+ *
+ * As an additional service it can also make the allocations and
+ * reallocations for you if you like, but it can also take of memory
+ * you hand it.
+ *
+ * @param   T           The data type to manage allocations for.
+ * @param   Destruct    The function to be used to free the resource.
+ *                      This will default to RTMemFree.
+ * @param   Allocator   The function to be used to allocate or reallocate
+ *                      the managed memory.
+ *                      This is standard realloc() like stuff, so it's possible
+ *                      to support simple allocation without actually having
+ *                      to support reallocating memory if that's a problem.
+ *                      This will default to RTMemRealloc.
+ */
+template <class T, void Destruct(T *) = RTMemAutoFree<T>, void *Allocator(void *, size_t) = RTMemRealloc >
+class RTMemAutoPtr
+    : public RTAutoRes<T *, Destruct, RTMemAutoNil<T> >
+{
+public:
+    /**
+     * Constructor.
+     *
+     * @param   aPtr    Memory pointer to manage. Defaults to NULL.
+     */
+    RTMemAutoPtr(T *aPtr = NULL)
+        : RTAutoRes<T *, Destruct, RTMemAutoNil<T> >(aPtr)
+    {
+    }
+
+    /**
+     * Free current memory and start managing aPtr.
+     *
+     * @param   aPtr    Memory pointer to manage.
+     */
+    RTMemAutoPtr &operator=(T *aPtr)
+    {
+        this->RTAutoRes<T *, Destruct, RTMemAutoNil<T> >::operator=(aPtr);
+        return *this;
+     }
+
+    /**
+     * Dereference with * operator.
+     */
+    T &operator*()
+    {
+         return *this->get();
+    }
+
+    /**
+     * Dereference with -> operator.
+     */
+    T *operator->()
+    {
+        return this->get();
+    }
+
+    /**
+     * Accessed with the subscript operator ([]).
+     *
+     * @returns Reference to the element.
+     * @param   a_i     The element to access.
+     */
+    T &operator[](size_t a_i)
+    {
+        return this->get()[a_i];
+    }
+
+    /**
+     * Allocates memory and start manage it.
+     *
+     * Any previously managed memory will be freed before making
+     * the new allocation.
+     *
+     * The content of the new memory is undefined when using
+     * the default allocator.
+     *
+     * @returns Success indicator.
+     * @retval  true if the new allocation succeeds.
+     * @retval  false on failure, no memory is associated with the object.
+     *
+     * @param   cElements   The new number of elements (of the data type) to allocate.
+     *                      This defaults to 1.
+     */
+    bool alloc(size_t a_cElements = 1)
+    {
+        this->reset(NULL);
+        T *aNewValue = (T *)(Allocator(NULL, a_cElements * sizeof(T)));
+        this->reset(aNewValue);
+        return aNewValue != NULL;
+    }
+
+    /**
+     * Reallocate or allocates the memory resource.
+     *
+     * Free the old value if allocation fails.
+     *
+     * The content of any additional memory that was allocated is
+     * undefined when using the default allocator.
+     *
+     * @returns Success indicator.
+     * @retval  true if the new allocation succeeds.
+     * @retval  false on failure, no memory is associated with the object.
+     *
+     * @param   cElements   The new number of elements (of the data type) to allocate.
+     *                      The size of the allocation is the number of elements times
+     *                      the size of the data type - this is currently what's passed
+     *                      down to the Allocator.
+     *                      This defaults to 1.
+     */
+    bool realloc(size_t a_cElements = 1)
+    {
+        T *aNewValue = (T *)(Allocator(this->get(), a_cElements * sizeof(T)));
+        if (aNewValue != NULL)
+            this->release();
+        /* We want this both if aNewValue is non-NULL and if it is NULL. */
+        this->reset(aNewValue);
+        return aNewValue != NULL;
+    }
+};
+
+#endif /* __cplusplus */
+
+
 /** @} */
 
-__END_DECLS
 
 #endif