Remove UniquePtr.h copy
This was copied from libcore/include quite a while ago, but the canonical version has since moved out to a generic library called libnativehelper. All users of this header should already have libnativehelper on their include path, so switching to the canonical version is as easy as removing the "utils/" part. Change-Id: Iae8e59bf3eee573bfa78381866989934e5bbf19d
This commit is contained in:
Kenny Root
parent
3aed2cf04f
commit
d975f37294
1 changed files with 0 additions and 239 deletions
|
|
@ -1,239 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 2010 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/* === NOTE === NOTE === NOTE === NOTE === NOTE === NOTE === NOTE === NOTE ===
|
||||
*
|
||||
* THIS IS A COPY OF libcore/include/UniquePtr.h AND AS SUCH THAT IS THE
|
||||
* CANONICAL SOURCE OF THIS FILE. PLEASE KEEP THEM IN SYNC.
|
||||
*
|
||||
* === NOTE === NOTE === NOTE === NOTE === NOTE === NOTE === NOTE === NOTE ===
|
||||
*/
|
||||
|
||||
#ifndef UNIQUE_PTR_H_included
|
||||
#define UNIQUE_PTR_H_included
|
||||
|
||||
#include <cstdlib> // For NULL.
|
||||
|
||||
// Default deleter for pointer types.
|
||||
template <typename T>
|
||||
struct DefaultDelete {
|
||||
enum { type_must_be_complete = sizeof(T) };
|
||||
DefaultDelete() {}
|
||||
void operator()(T* p) const {
|
||||
delete p;
|
||||
}
|
||||
};
|
||||
|
||||
// Default deleter for array types.
|
||||
template <typename T>
|
||||
struct DefaultDelete<T[]> {
|
||||
enum { type_must_be_complete = sizeof(T) };
|
||||
void operator()(T* p) const {
|
||||
delete[] p;
|
||||
}
|
||||
};
|
||||
|
||||
// A smart pointer that deletes the given pointer on destruction.
|
||||
// Equivalent to C++0x's std::unique_ptr (a combination of boost::scoped_ptr
|
||||
// and boost::scoped_array).
|
||||
// Named to be in keeping with Android style but also to avoid
|
||||
// collision with any other implementation, until we can switch over
|
||||
// to unique_ptr.
|
||||
// Use thus:
|
||||
// UniquePtr<C> c(new C);
|
||||
template <typename T, typename D = DefaultDelete<T> >
|
||||
class UniquePtr {
|
||||
public:
|
||||
// Construct a new UniquePtr, taking ownership of the given raw pointer.
|
||||
explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) {
|
||||
}
|
||||
|
||||
~UniquePtr() {
|
||||
reset();
|
||||
}
|
||||
|
||||
// Accessors.
|
||||
T& operator*() const { return *mPtr; }
|
||||
T* operator->() const { return mPtr; }
|
||||
T* get() const { return mPtr; }
|
||||
|
||||
// Returns the raw pointer and hands over ownership to the caller.
|
||||
// The pointer will not be deleted by UniquePtr.
|
||||
T* release() __attribute__((warn_unused_result)) {
|
||||
T* result = mPtr;
|
||||
mPtr = NULL;
|
||||
return result;
|
||||
}
|
||||
|
||||
// Takes ownership of the given raw pointer.
|
||||
// If this smart pointer previously owned a different raw pointer, that
|
||||
// raw pointer will be freed.
|
||||
void reset(T* ptr = NULL) {
|
||||
if (ptr != mPtr) {
|
||||
D()(mPtr);
|
||||
mPtr = ptr;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
// The raw pointer.
|
||||
T* mPtr;
|
||||
|
||||
// Comparing unique pointers is probably a mistake, since they're unique.
|
||||
template <typename T2> bool operator==(const UniquePtr<T2>& p) const;
|
||||
template <typename T2> bool operator!=(const UniquePtr<T2>& p) const;
|
||||
|
||||
// Disallow copy and assignment.
|
||||
UniquePtr(const UniquePtr&);
|
||||
void operator=(const UniquePtr&);
|
||||
};
|
||||
|
||||
// Partial specialization for array types. Like std::unique_ptr, this removes
|
||||
// operator* and operator-> but adds operator[].
|
||||
template <typename T, typename D>
|
||||
class UniquePtr<T[], D> {
|
||||
public:
|
||||
explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) {
|
||||
}
|
||||
|
||||
~UniquePtr() {
|
||||
reset();
|
||||
}
|
||||
|
||||
T& operator[](size_t i) const {
|
||||
return mPtr[i];
|
||||
}
|
||||
T* get() const { return mPtr; }
|
||||
|
||||
T* release() __attribute__((warn_unused_result)) {
|
||||
T* result = mPtr;
|
||||
mPtr = NULL;
|
||||
return result;
|
||||
}
|
||||
|
||||
void reset(T* ptr = NULL) {
|
||||
if (ptr != mPtr) {
|
||||
D()(mPtr);
|
||||
mPtr = ptr;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
T* mPtr;
|
||||
|
||||
// Disallow copy and assignment.
|
||||
UniquePtr(const UniquePtr&);
|
||||
void operator=(const UniquePtr&);
|
||||
};
|
||||
|
||||
#if UNIQUE_PTR_TESTS
|
||||
|
||||
// Run these tests with:
|
||||
// g++ -g -DUNIQUE_PTR_TESTS -x c++ UniquePtr.h && ./a.out
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
static void assert(bool b) {
|
||||
if (!b) {
|
||||
fprintf(stderr, "FAIL\n");
|
||||
abort();
|
||||
}
|
||||
fprintf(stderr, "OK\n");
|
||||
}
|
||||
static int cCount = 0;
|
||||
struct C {
|
||||
C() { ++cCount; }
|
||||
~C() { --cCount; }
|
||||
};
|
||||
static bool freed = false;
|
||||
struct Freer {
|
||||
void operator()(int* p) {
|
||||
assert(*p == 123);
|
||||
free(p);
|
||||
freed = true;
|
||||
}
|
||||
};
|
||||
|
||||
int main(int argc, char* argv[]) {
|
||||
//
|
||||
// UniquePtr<T> tests...
|
||||
//
|
||||
|
||||
// Can we free a single object?
|
||||
{
|
||||
UniquePtr<C> c(new C);
|
||||
assert(cCount == 1);
|
||||
}
|
||||
assert(cCount == 0);
|
||||
// Does release work?
|
||||
C* rawC;
|
||||
{
|
||||
UniquePtr<C> c(new C);
|
||||
assert(cCount == 1);
|
||||
rawC = c.release();
|
||||
}
|
||||
assert(cCount == 1);
|
||||
delete rawC;
|
||||
// Does reset work?
|
||||
{
|
||||
UniquePtr<C> c(new C);
|
||||
assert(cCount == 1);
|
||||
c.reset(new C);
|
||||
assert(cCount == 1);
|
||||
}
|
||||
assert(cCount == 0);
|
||||
|
||||
//
|
||||
// UniquePtr<T[]> tests...
|
||||
//
|
||||
|
||||
// Can we free an array?
|
||||
{
|
||||
UniquePtr<C[]> cs(new C[4]);
|
||||
assert(cCount == 4);
|
||||
}
|
||||
assert(cCount == 0);
|
||||
// Does release work?
|
||||
{
|
||||
UniquePtr<C[]> c(new C[4]);
|
||||
assert(cCount == 4);
|
||||
rawC = c.release();
|
||||
}
|
||||
assert(cCount == 4);
|
||||
delete[] rawC;
|
||||
// Does reset work?
|
||||
{
|
||||
UniquePtr<C[]> c(new C[4]);
|
||||
assert(cCount == 4);
|
||||
c.reset(new C[2]);
|
||||
assert(cCount == 2);
|
||||
}
|
||||
assert(cCount == 0);
|
||||
|
||||
//
|
||||
// Custom deleter tests...
|
||||
//
|
||||
assert(!freed);
|
||||
{
|
||||
UniquePtr<int, Freer> i(reinterpret_cast<int*>(malloc(sizeof(int))));
|
||||
*i = 123;
|
||||
}
|
||||
assert(freed);
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // UNIQUE_PTR_H_included
|
||||
Loading…
Reference in a new issue