* Moved Referenceable.cpp to src/kits/support (private libbe API), and its header to

private/shared.
* Made AddReference() and CountReferences() inlines.
* The registrar is now using the private Referenceable version in libbe.so.
* Minor cleanup.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@21767 a95241bf-73f2-0310-859d-f6bbb57e9c96

headers/private/shared/Referenceable.h

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2004-2007, Ingo Weinhold, [email protected]. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef _REFERENCEABLE_H
+#define _REFERENCEABLE_H
+
+
+#include <SupportDefs.h>
+
+
+namespace BPrivate {
+
+class Referenceable {
+public:
+								Referenceable(
+									bool deleteWhenUnreferenced = true);
+	virtual						~Referenceable();
+
+			void				AddReference()
+									{ atomic_add(&fReferenceCount, 1); }
+
+			bool				RemoveReference();	// returns true after last
+
+			int32				CountReferences() const
+									{ return fReferenceCount; }
+
+protected:
+			vint32				fReferenceCount;
+			bool				fDeleteWhenUnreferenced;
+};
+
+// Reference
+template<typename Type = BPrivate::Referenceable>
+class Reference {
+public:
+	Reference()
+		: fObject(NULL)
+	{
+	}
+
+	Reference(Type* object, bool alreadyHasReference = false)
+		: fObject(NULL)
+	{
+		SetTo(object, alreadyHasReference);
+	}
+
+	Reference(const Reference<Type>& other)
+		: fObject(NULL)
+	{
+		SetTo(other.fObject);
+	}
+
+	~Reference()
+	{
+		Unset();
+	}
+
+	void SetTo(Type* object, bool alreadyHasReference = false)
+	{
+		Unset();
+		fObject = object;
+		if (fObject && !alreadyHasReference)
+			fObject->AddReference();
+	}
+
+	void Unset()
+	{
+		if (fObject) {
+			fObject->RemoveReference();
+			fObject = NULL;
+		}
+	}
+
+	Type* Get() const
+	{
+		return fObject;
+	}
+
+	Type* Detach()
+	{
+		Type* object = fObject;
+		fObject = NULL;
+		return object;
+	}
+
+	Type& operator*() const
+	{
+		return *fObject;
+	}
+
+	Type* operator->() const
+	{
+		return fObject;
+	}
+
+	Reference& operator=(const Reference<Type>& other)
+	{
+		SetTo(other.fObject);
+		return *this;
+	}
+
+	bool operator==(const Reference<Type>& other) const
+	{
+		return (fObject == other.fObject);
+	}
+
+	bool operator!=(const Reference<Type>& other) const
+	{
+		return (fObject != other.fObject);
+	}
+
+private:
+	Type*	fObject;
+};
+
+}	// namespace BPrivate
+
+using BPrivate::Referenceable;
+using BPrivate::Reference;
+
+#endif	// _REFERENCEABLE_H