Navigation

← Previous Change
Next Change →

OSGReferenceCountPointer.h

Timestamp:

10/20/07 18:11:52 (1 year ago)

Author:

cneumann

Message:

added: RootObjectT template paremter for ReferenceCountPointer?

and ParentPointer? templates - allows use for FieldBundles?

compile fixes - but still not done

Files:

branches/Carsten_PtrWork/Source/System/FieldContainer/Base/OSGReferenceCountPointer.h (modified) (9 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

branches/Carsten_PtrWork/Source/System/FieldContainer/Base/OSGReferenceCountPointer.h

r973	r976
46	46	#include "OSGContainerPtrFuncsForwards.h"
47	47
	48	#include "OSGFieldContainer.h"
	49
48	50	#include <boost/static_assert.hpp>
49	51	#include <boost/type_traits/is_convertible.hpp>
…	…
57	59	OSG_BEGIN_NAMESPACE
58	60
59		struct InternalRefCountPolicy
60		{
61		static void
62		addRef(FieldContainerPtrConstArg pContainer);
63
64		static void
65		subRef(FieldContainerPtrConstArg pContainer);
66
67		static FieldContainerPtr
68		deref(FieldContainerPtrConstArg pContainer);
69		};
70
71		struct RefCountPolicy
72		{
73		static void
74		addRef(FieldContainerPtrConstArg pContainer);
75
76		static void
77		subRef(FieldContainerPtrConstArg pContainer);
78
79		static FieldContainerPtr
80		deref(FieldContainerPtrConstArg pContainer);
81		};
82
83		struct MTRefCountPolicy
84		{
85		static void
86		addRef(FieldContainerPtrConstArg pContainer);
87
88		static void
89		subRef(FieldContainerPtrConstArg pContainer);
90
91		static FieldContainerPtr
92		deref(FieldContainerPtrConstArg pContainer);
93		};
94
95		struct WeakRefCountPolicy
96		{
97		static void
98		addRef(FieldContainerPtrConstArg pContainer);
99
100		static void
101		subRef(FieldContainerPtrConstArg pContainer);
102
103		static FieldContainerPtr
104		deref(FieldContainerPtrConstArg pContainer);
105		}
106
107		/*! \ingroup GrpSystemFieldContainer
108		*/
109
110		template <class ContainerT, class RefCountPolicyT>
111		class ReferenceCountPointer
	61	/*! \ingroup GrpSystemFieldContainer
	62	\class InternalRefCountPolicy<RootObjectT>
	63	*/
	64
	65	template <class RootObjectT>
	66	struct OSG_SYSTEM_DLLMAPPING InternalRefCountPolicy
	67	{
	68	OSG_GEN_NAMED_CONTAINER_PTR(RootObjectT, RootObject)
	69
	70	static void addRef(RootObjectPtrConstArg rootObjectPtr);
	71	static void subRef(RootObjectPtrConstArg rootObjectPtr);
	72	static RootObjectPtr deref (RootObjectPtrConstArg rootObjectPtr);
	73	};
	74
	75	/*! \ingroup GrpSystemFieldContainer
	76	\class RefCountPolicy<RootObjectT>
	77	*/
	78
	79	template <class RootObjectT>
	80	struct OSG_SYSTEM_DLLMAPPING RefCountPolicy
	81	{
	82	OSG_GEN_NAMED_CONTAINER_PTR(RootObjectT, RootObject)
	83
	84	static void addRef(RootObjectPtrConstArg rootObjectPtr);
	85	static void subRef(RootObjectPtrConstArg rootObjectPtr);
	86	static RootObjectPtr deref (RootObjectPtrConstArg rootObjectPtr);
	87	};
	88
	89	/*! \ingroup GrpSystemFieldContainer
	90	\class MTRefCountPolicy<RootObjectT>
	91	*/
	92
	93	template <class RootObjectT>
	94	struct OSG_SYSTEM_DLLMAPPING MTRefCountPolicy
	95	{
	96	};
	97
	98	template <>
	99	struct OSG_SYSTEM_DLLMAPPING MTRefCountPolicy<FieldContainer>
	100	{
	101	OSG_GEN_NAMED_CONTAINER_PTR(FieldContainer, RootObject)
	102
	103	static void addRef(RootObjectPtrConstArg rootObjectPtr);
	104	static void subRef(RootObjectPtrConstArg rootObjectPtr);
	105	static RootObjectPtr deref (RootObjectPtrConstArg rootObjectPtr);
	106	};
	107
	108	template <>
	109	struct OSG_SYSTEM_DLLMAPPING MTRefCountPolicy<FieldBundle>
	110	{
	111	OSG_GEN_NAMED_CONTAINER_PTR(FieldBundle, RootObject)
	112
	113	static void addRef(RootObjectPtrConstArg rootObjectPtr);
	114	static void subRef(RootObjectPtrConstArg rootObjectPtr);
	115	static RootObjectPtr deref (RootObjectPtrConstArg rootObjectPtr);
	116	};
	117
	118	/*! \ingroup GrpSystemFieldContainer
	119	\class WeakRefCountPolicy<RootObjectT>
	120	*/
	121
	122	template <class RootObjectT>
	123	struct OSG_SYSTEM_DLLMAPPING WeakRefCountPolicy
	124	{
	125	OSG_GEN_NAMED_CONTAINER_PTR(RootObjectT, RootObject)
	126
	127	static void addRef(RootObjectPtrConstArg rootObjectPtr);
	128	static void subRef(RootObjectPtrConstArg rootObjectPtr);
	129	static RootObjectPtr deref (RootObjectPtrConstArg rootObjectPtr);
	130	};
	131
	132	/*! \ingroup GrpSystemFieldContainer
	133	*/
	134
	135	template <class ObjectT,
	136	class RefCountPolicyT,
	137	class RootObjectT = FieldContainer>
	138	class OSG_SYSTEM_DLLMAPPING ReferenceCountPointer
112	139	{
113	140	/========================== PUBLIC =================================/
…	…
117	144	/! \{ /
118	145
119		typedef ~~ContainerT Container~~;
	146	typedef ObjectT Object;
120	147	typedef RefCountPolicyT RefCountPolicy;
121		typedef ReferenceCountPointer<Container, RefCountPolicy> Self;
122
123		OSG_GEN_NAMED_CONTAINER_PTR(Container, Container)
124
125		template <class OtherContainerT>
	148	typedef RootObjectT RootObject;
	149	typedef ReferenceCountPointer<Object,
	150	RefCountPolicy,
	151	RootObject > Self;
	152
	153	OSG_GEN_NAMED_CONTAINER_PTR(Object, Object )
	154	OSG_GEN_NAMED_CONTAINER_PTR(RootObject, RootObject)
	155
	156	template <class OtherObjectT>
126	157	struct rebind
127	158	{
128		typedef ReferenceCountPointer<OtherContainerT,
129		RefCountPolicy > Type;
	159	typedef ReferenceCountPointer<OtherObjectT,
	160	RefCountPolicy,
	161	RootObject > Type;
130	162	};
131	163
…	…
135	167	/! \{ /
136	168
137		ReferenceCountPointer(void );
138		ReferenceCountPointer(Self const &other );
	169	ReferenceCountPointer(void );
	170	ReferenceCountPointer(Self const &other );
139	171
140	172	explicit
141		ReferenceCountPointer(~~ContainerPtrConstArg pContainer~~);
142
143		template <class Other~~ContainerT, class OtherRefCountPolicy~~>
	173	ReferenceCountPointer(ObjectPtrConstArg objectPtr );
	174
	175	template <class OtherObjectT, class OtherRefCountPolicyT>
144	176	explicit
145	177	ReferenceCountPointer(
146		Ref~~renceCountPointer<OtherContainer~~T,
147		~~OtherRefCountPolicy~~> const &refPtr );
	178	ReferenceCountPointer<OtherObjectT,
	179	OtherRefCountPolicyT> const &refPtr );
148	180
149	181	/! \} /
…	…
160	192
161	193	Self &operator=(Self const &other );
162		Self &operator=(~~ContainerPtrConstArg pContainer~~);
163
164		template <class Other~~Container~~T, class OtherRefCountPolicy>
	194	Self &operator=(ObjectPtrConstArg objectPtr );
	195
	196	template <class OtherObjectT, class OtherRefCountPolicy>
165	197	Self &operator=(
166		ReferenceCountPointer<Other~~Container~~T,
	198	ReferenceCountPointer<OtherObjectT,
167	199	OtherRefCountPolicy> const &refPtr );
168	200
…	…
172	204	/! \{ /
173	205
174		operator ~~Container~~Ptr (void) const;
	206	operator ObjectPtr (void) const;
175	207
176	208	/! \} /
…	…
179	211	/! \{ /
180	212
181		~~Container~~Ptr operator->(void ) const;
182		~~Container~~ &operator* (void ) const;
183
184		~~Container~~Ptr get (void ) const;
185		void ~~set (ContainerPtrConstArg pContainer~~);
186
187		void swap (Self &other );
	213	ObjectPtr operator->(void ) const;
	214	Object &operator* (void ) const;
	215
	216	ObjectPtr get (void ) const;
	217	void set (ObjectPtrConstArg objectPtr );
	218
	219	void swap (Self &other );
188	220
189	221	/! \} /
…	…
197	229	/! \{ /
198	230
199		static FieldContainerPtr
200		castPtrUp (ContainerPtrConstArg pContainer) const;
201		static ContainerPtr
202		castPtrDown(FieldContainerPtrConstArg pContainer) const;
203
204		void internalSet(FieldContainerPtrConstArg pNewContainer);
	231	static RootObjectPtr castPtrUp (ObjectPtrConstArg objectPtr );
	232	static ObjectPtr castPtrDown(RootObjectPtrConstArg rootObjectPtr);
	233
	234	void internalSet(RootObjectPtrConstArg rootObjectPtr);
205	235
206	236	/! \} /
…	…
209	239	/! \{ /
210	240
211		FieldContainerPtr _pContainer;
212
213		/! \} /
214		/---------------------------------------------------------------------/
215		};
216
217		template <class LHSContainerT, class LHSRefCountPolicyT,
218		class RHSContainerT, class RHSRefCountPolicyT >
	241	RootObjectPtr _rootObjectPtr;
	242
	243	/! \} /
	244	/---------------------------------------------------------------------/
	245	};
	246
	247	template <class LHSObjectT, class LHSRefCountPolicyT,
	248	class RHSObjectT, class RHSRefCountPolicyT,
	249	class RootObjectT >
219	250	bool
220		operator==(ReferenceCountPointer<LHSContainerT, LHSRefCountPolicyT> const &lhs,
221		ReferenceCountPointer<RHSContainerT, RHSRefCountPolicyT> const &rhs);
222
223
224		template <class LHSContainerT, class LHSRefCountPolicyT,
225		class RHSContainerT, class RHSRefCountPolicyT >
	251	operator==(ReferenceCountPointer<LHSObjectT,
	252	LHSRefCountPolicyT,
	253	RootObjectT > const &lhs,
	254	ReferenceCountPointer<RHSObjectT,
	255	RHSRefCountPolicyT,
	256	RootObjectT > const &rhs);
	257
	258
	259	template <class LHSObjectT, class LHSRefCountPolicyT,
	260	class RHSObjectT, class RHSRefCountPolicyT,
	261	class RootObjectT >
226	262	bool
227		operator!=(ReferenceCountPointer<LHSContainerT, LHSRefCountPolicyT> const &lhs,
228		ReferenceCountPointer<RHSContainerT, RHSRefCountPolicyT> const &rhs)
	263	operator!=(ReferenceCountPointer<LHSObjectT,
	264	LHSRefCountPolicyT,
	265	RootObjectT > const &lhs,
	266	ReferenceCountPointer<RHSObjectT,
	267	RHSRefCountPolicyT,
	268	RootObjectT > const &rhs);
229	269
230	270
231		template <class LHSContainerT, class LHSRefCountPolicyT,
232		class RHSContainerT, class RHSRefCountPolicyT >
	271	template <class LHSObjectT, class LHSRefCountPolicyT,
	272	class RHSObjectT, class RHSRefCountPolicyT,
	273	class RootObjectT >
233	274	bool
234		operator<(ReferenceCountPointer<LHSContainerT, LHSRefCountPolicyT> const &lhs,
235		ReferenceCountPointer<RHSContainerT, RHSRefCountPolicyT> const &rhs);
236
237
238		template <class ContainerT>
239		struct InternalRefCountPtrBuilder
240		{
241		typedef ReferenceCountPointer<ContainerT,
242		InternalRefCountPolicy> Ptr;
243		typedef ReferenceCountPointer<ContainerT,
244		InternalRefCountPolicy> const PtrConst;
245		typedef ReferenceCountPointer<ContainerT const,
246		InternalRefCountPolicy> ConstPtr;
247		typedef ReferenceCountPointer<ContainerT const,
248		InternalRefCountPolicy> const ConstPtrConst;
249		};
250
251		template <class ContainerT>
252		struct RefCountPtrBuilder
253		{
254		typedef ReferenceCountPointer<ContainerT,
255		RefCountPolicy > Ptr;
256		typedef ReferenceCountPointer<ContainerT,
257		RefCountPolicy > const PtrConst;
258		typedef ReferenceCountPointer<ContainerT const,
259		RefCountPolicy > ConstPtr;
260		typedef ReferenceCountPointer<ContainerT const,
261		RefCountPolicy > const ConstPtrConst;
262		};
263
264		template <class ContainerT>
265		struct MTRefCountPtrBuilder
266		{
267		typedef ReferenceCountPointer<ContainerT,
268		MTRefCountPolicy > Ptr;
269		typedef ReferenceCountPointer<ContainerT,
270		MTRefCountPolicy > const PtrConst;
271		typedef ReferenceCountPointer<ContainerT const,
272		MTRefCountPolicy > ConstPtr;
273		typedef ReferenceCountPointer<ContainerT const,
274		MTRefCountPolicy > const ConstPtrConst;
275		};
276
277		template <class ContainerT>
278		struct WeakRefCountPtrBuilder
279		{
280		typedef ReferenceCountPointer<ContainerT,
281		WeakRefCountPolicy> Ptr;
282		typedef ReferenceCountPointer<ContainerT,
283		WeakRefCountPolicy> const PtrConst;
284		typedef ReferenceCountPointer<ContainerT const,
285		WeakRefCountPolicy> ConstPtr;
286		typedef ReferenceCountPointer<ContainerT const,
287		WeakRefCountPolicy> const ConstPtrConst;
288		};
	275	operator<(ReferenceCountPointer<LHSObjectT,
	276	LHSRefCountPolicyT,
	277	RootObjectT > const &lhs,
	278	ReferenceCountPointer<RHSObjectT,
	279	RHSRefCountPolicyT,
	280	RootObjectT > const &rhs);
289	281
290	282	OSG_END_NAMESPACE
	283
	284	namespace boost
	285	{
	286
	287	template <class TargetObjectT, class SourceObjectT,
	288	class RefCountPolicyT, class RootObjectT >
	289	OSG::ReferenceCountPointer<TargetObjectT, RefCountPolicyT, RootObjectT>
	290	dynamic_pointer_cast(OSG::ReferenceCountPointer<SourceObjectT,
	291	RefCountPolicyT,
	292	RootObjectT > const &source)
	293	{
	294	TargetObjectT targetPtr = dynamic_cast<TargetObjectT >(source.get());
	295	OSG::ReferenceCountPointer<TargetObjectT,
	296	RefCountPolicyT,
	297	RootObjectT > returnValue();
	298
	299	if(targetPtr != NULL)
	300	{
	301	returnValue.set(targetPtr);
	302	}
	303
	304	return returnValue;
	305	}
	306
	307	} // namespace boost
291	308
292	309	#endif // _OSGREFERENCECOUNTPOINTER_H_

Navigation

Changeset 976 for branches/Carsten_PtrWork/Source/System/FieldContainer/Base/OSGReferenceCountPointer.h

Legend:

branches/Carsten_PtrWork/Source/System/FieldContainer/Base/OSGReferenceCountPointer.h

Download in other formats: