aboutsummaryrefslogtreecommitdiff
path: root/externals/g3dlite/G3D/Pointer.h
diff options
context:
space:
mode:
Diffstat (limited to 'externals/g3dlite/G3D/Pointer.h')
-rw-r--r--externals/g3dlite/G3D/Pointer.h292
1 files changed, 0 insertions, 292 deletions
diff --git a/externals/g3dlite/G3D/Pointer.h b/externals/g3dlite/G3D/Pointer.h
deleted file mode 100644
index 6e35062a746..00000000000
--- a/externals/g3dlite/G3D/Pointer.h
+++ /dev/null
@@ -1,292 +0,0 @@
-/**
- @file Pointer.h
-
- @maintainer Morgan McGuire, http://graphics.cs.williams.edu
-
- @created 2007-05-16
- @edited 2009-03-26
-
- Copyright 2000-2009, Morgan McGuire.
- All rights reserved.
- */
-#ifndef G3D_Pointer_h
-#define G3D_Pointer_h
-
-#include "G3D/debugAssert.h"
-#include "G3D/ReferenceCount.h"
-
-namespace G3D {
-
-/**
- Acts like a pointer to a value of type ValueType (i.e.,
- ValueType*), but can operate through accessor methods as well as on
- a value in memory. This is useful for implementing scripting
- languages and other applications that need to connect existing APIs
- by reference.
-
- Because the accessors require values to be passed by value (instead of by reference)
- this is primarily useful for objects whose memory size is small.
-
- <pre>
- class Foo {
- public:
- void setEnabled(bool b);
- bool getEnabled() const;
- };
-
- Foo f;
- bool b;
-
- Pointer<bool> p1(&b);
- Pointer<bool> p2(&f, &Foo::getEnabled, &Foo::setEnabled);
-
- *p1 = true;
- *p2 = false;
- *p2 = *p1; \/\/ Value assignment
- p2 = p1; \/\/ Pointer aliasing
-
- \/\/ Or, equivalently:
- p1.setValue(true);
- p2.setValue(false);
-
- p2.setValue(p1.getValue());
- p2 = p1;
- </pre>
-
- <i>Note:</i> Because of the way that dereference is implemented, you cannot pass <code>*p</code> through a function
- that takes varargs (...), e.g., <code>printf("%d", *p)</code> will produce a compile-time error. Instead use
- <code>printf("%d",(bool)*p)</code> or <code>printf("%d", p.getValue())</code>.
-
- */
-template<class ValueType>
-class Pointer {
-private:
-
- class Interface {
- public:
- virtual ~Interface() {};
- virtual void set(ValueType b) = 0;
- virtual ValueType get() const = 0;
- virtual Interface* clone() const = 0;
- virtual bool isNull() const = 0;
- };
-
- class Memory : public Interface {
- private:
-
- ValueType* value;
-
- public:
-
- Memory(ValueType* value) : value(value) {
- //debugAssert(value != NULL);
- }
-
- virtual void set(ValueType v) {
- *value = v;
- }
-
- virtual ValueType get() const {
- return *value;
- }
-
- virtual Interface* clone() const {
- return new Memory(value);
- }
-
- virtual bool isNull() const {
- return value == NULL;
- }
- };
-
- template<class T, typename GetMethod, typename SetMethod>
- class Accessor : public Interface {
- private:
-
- T* object;
- GetMethod getMethod;
- SetMethod setMethod;
-
- public:
-
- Accessor(T* object,
- GetMethod getMethod,
- SetMethod setMethod) : object(object), getMethod(getMethod), setMethod(setMethod) {
- debugAssert(object != NULL);
- }
-
- virtual void set(ValueType v) {
- (object->*setMethod)(v);
- }
-
- virtual ValueType get() const {
- return (object->*getMethod)();
- }
-
- virtual Interface* clone() const {
- return new Accessor(object, getMethod, setMethod);
- }
-
- virtual bool isNull() const {
- return object == NULL;
- }
- };
-
-
- template<class T, typename GetMethod, typename SetMethod>
- class RefAccessor : public Interface {
- private:
-
- ReferenceCountedPointer<T> object;
- GetMethod getMethod;
- SetMethod setMethod;
-
- public:
-
- RefAccessor(
- const ReferenceCountedPointer<T>& object,
- GetMethod getMethod,
- SetMethod setMethod) : object(object), getMethod(getMethod), setMethod(setMethod) {
-
- debugAssert(object != NULL);
- }
-
- virtual void set(ValueType v) {
- (object.pointer()->*setMethod)(v);
- }
-
- virtual ValueType get() const {
- return (object.pointer()->*getMethod)();
- }
-
- virtual Interface* clone() const {
- return new RefAccessor(object, getMethod, setMethod);
- }
-
- virtual bool isNull() const {
- return object.isNull();
- }
- };
-
-
- Interface* m_interface;
-
-public:
-
- Pointer() : m_interface(NULL) {};
-
- /** Allows implicit cast from real pointer */
- Pointer(ValueType* v) : m_interface(new Memory(v)) {}
-
- inline bool isNull() const {
- return (m_interface == NULL) || m_interface->isNull();
- }
-
- // Assignment
- inline Pointer& operator=(const Pointer& r) {
- delete m_interface;
- if (r.m_interface != NULL) {
- m_interface = r.m_interface->clone();
- } else {
- m_interface = NULL;
- }
- return this[0];
- }
-
- Pointer(const Pointer& p) : m_interface(NULL) {
- this[0] = p;
- }
-
- template<class Class>
- Pointer(const ReferenceCountedPointer<Class>& object,
- ValueType (Class::*getMethod)() const,
- void (Class::*setMethod)(ValueType)) :
- m_interface(new RefAccessor<Class, ValueType (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(const ReferenceCountedPointer<Class>& object,
- const ValueType& (Class::*getMethod)() const,
- void (Class::*setMethod)(ValueType)) :
- m_interface(new RefAccessor<Class, const ValueType& (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(const ReferenceCountedPointer<Class>& object,
- ValueType (Class::*getMethod)() const,
- void (Class::*setMethod)(const ValueType&)) :
- m_interface(new RefAccessor<Class, ValueType (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(const ReferenceCountedPointer<Class>& object,
- const ValueType& (Class::*getMethod)() const,
- void (Class::*setMethod)(const ValueType&)) :
- m_interface(new RefAccessor<Class, const ValueType& (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(Class* object,
- const ValueType& (Class::*getMethod)() const,
- void (Class::*setMethod)(const ValueType&)) :
- m_interface(new Accessor<Class, const ValueType& (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(Class* object,
- ValueType (Class::*getMethod)() const,
- void (Class::*setMethod)(const ValueType&)) :
- m_interface(new Accessor<Class, ValueType (Class::*)() const, void (Class::*)(const ValueType&)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(Class* object,
- const ValueType& (Class::*getMethod)() const,
- void (Class::*setMethod)(ValueType)) :
- m_interface(new Accessor<Class, const ValueType& (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
-
- template<class Class>
- Pointer(Class* object,
- ValueType (Class::*getMethod)() const,
- void (Class::*setMethod)(ValueType)) :
- m_interface(new Accessor<Class, ValueType (Class::*)() const, void (Class::*)(ValueType)>(object, getMethod, setMethod)) {}
-
- ~Pointer() {
- delete m_interface;
- }
-
- inline const ValueType getValue() const {
- debugAssert(m_interface != NULL);
- return m_interface->get();
- }
-
- inline void setValue(const ValueType& v) {
- debugAssert(m_interface != NULL);
- m_interface->set(v);
- }
-
- class IndirectValue {
- private:
-
- friend class Pointer;
- Pointer* pointer;
- IndirectValue(Pointer* p) : pointer(p) {}
-
- public:
-
- void operator=(const ValueType& v) {
- pointer->setValue(v);
- }
-
- operator ValueType() const {
- return pointer->getValue();
- }
-
- };
-
- inline IndirectValue operator*() {
- return IndirectValue(this);
- }
-
- inline const ValueType operator*() const {
- return getValue();
- }
-};
-
-}
-
-#endif