1 files changed, 49 insertions, 49 deletions
diff --git a/src/stable/singleton.h b/src/stable/singleton.h
index 6fe2777..27d907d 100644
--- a/src/stable/singleton.h
+++ b/src/stable/singleton.h
@@ -12,57 +12,57 @@
 namespace Bu
 {
-        /**
+    /**
-         * Provides singleton functionality in a modular sort of way.  Make this the
+     * Provides singleton functionality in a modular sort of way.  Make this the
-         * base class of any other class and you immediately gain singleton
+     * base class of any other class and you immediately gain singleton
-         * functionality.  Be sure to make your constructor and various functions use
+     * functionality.  Be sure to make your constructor and various functions use
-         * intellegent scoping.  Cleanup and instantiation are performed automatically
+     * intellegent scoping.  Cleanup and instantiation are performed automatically
-         * for you at first use and program exit.  There are two things that you must
+     * for you at first use and program exit.  There are two things that you must
-         * do when using this template, first is to inherit from it with the name of
+     * do when using this template, first is to inherit from it with the name of
-         * your class filling in for T and then make this class a friend of your class.
+     * your class filling in for T and then make this class a friend of your class.
-         *@code
+     *@code
-         * // Making the Single Singleton:
+     * // Making the Single Singleton:
-         * class Single : public Singleton<Single>
+     * class Single : public Singleton<Single>
-         * {
+     * {
-         *              friend class Singleton<Single>;
+     *      friend class Singleton<Single>;
-         *      protected:
+     *  protected:
-         *              Single();
+     *      Single();
-         *              ...
+     *      ...
-         * };
+     * };
-         @endcode
+     @endcode
-         * You can still add public functions and variables to your new Singleton child
+     * You can still add public functions and variables to your new Singleton child
-         * class, but your constructor should be protected (hence the need for the
+     * class, but your constructor should be protected (hence the need for the
-         * friend decleration).
+     * friend decleration).
-         */
+     */
-        template <class T>
+    template <class T>
-        class Singleton
+    class Singleton
-        {
+    {
-        protected:
+    protected:
-                /**
+        /**
-                 * Private constructor.  This constructor is empty but has a body so that
+         * Private constructor.  This constructor is empty but has a body so that
-                 * you can make your own override of it.  Be sure that you're override is
+         * you can make your own override of it.  Be sure that you're override is
-                 * also protected.
+         * also protected.
-                 */
+         */
-                Singleton() {};
+        Singleton() {};
-        private:
+    private:
-                /**
+        /**
-                 * Copy constructor, defined so that you could write your own as well.
+         * Copy constructor, defined so that you could write your own as well.
-                 */
+         */
-                Singleton( const Singleton& );
+        Singleton( const Singleton& );
-        public:
+    public:
-                /**
+        /**
-                 * Get a handle to the contained instance of the contained class.  It is
+         * Get a handle to the contained instance of the contained class.  It is
-                 * a reference.
+         * a reference.
-                 *@returns A reference to the contained object.
+         *@returns A reference to the contained object.
-                 */
+         */
-                static T &getInstance()
+        static T &getInstance()
-                {
+        {
-                        static T i;
+            static T i;
-                        return i;
+            return i;
-                }
+        }
-        };
+    };
 }
 #endif

diff --git a/src/stable/singleton.h b/src/stable/singleton.h index 6fe2777..27d907d 100644 --- a/src/stable/singleton.h +++ b/src/stable/singleton.h
@@ -12,57 +12,57 @@
12		12
13	namespace Bu	13	namespace Bu
14	{	14	{
15	/**	15	/**
16	* Provides singleton functionality in a modular sort of way. Make this the	16	* Provides singleton functionality in a modular sort of way. Make this the
17	* base class of any other class and you immediately gain singleton	17	* base class of any other class and you immediately gain singleton
18	* functionality. Be sure to make your constructor and various functions use	18	* functionality. Be sure to make your constructor and various functions use
19	* intellegent scoping. Cleanup and instantiation are performed automatically	19	* intellegent scoping. Cleanup and instantiation are performed automatically
20	* for you at first use and program exit. There are two things that you must	20	* for you at first use and program exit. There are two things that you must
21	* do when using this template, first is to inherit from it with the name of	21	* do when using this template, first is to inherit from it with the name of
22	* your class filling in for T and then make this class a friend of your class.	22	* your class filling in for T and then make this class a friend of your class.
23	*@code	23	*@code
24	* // Making the Single Singleton:	24	* // Making the Single Singleton:
25	* class Single : public Singleton<Single>	25	* class Single : public Singleton<Single>
26	* {	26	* {
27	* friend class Singleton<Single>;	27	* friend class Singleton<Single>;
28	* protected:	28	* protected:
29	* Single();	29	* Single();
30	* ...	30	* ...
31	* };	31	* };
32	@endcode	32	@endcode
33	* You can still add public functions and variables to your new Singleton child	33	* You can still add public functions and variables to your new Singleton child
34	* class, but your constructor should be protected (hence the need for the	34	* class, but your constructor should be protected (hence the need for the
35	* friend decleration).	35	* friend decleration).
36	*/	36	*/
37	template <class T>	37	template <class T>
38	class Singleton	38	class Singleton
39	{	39	{
40	protected:	40	protected:
41	/**	41	/**
42	* Private constructor. This constructor is empty but has a body so that	42	* Private constructor. This constructor is empty but has a body so that
43	* you can make your own override of it. Be sure that you're override is	43	* you can make your own override of it. Be sure that you're override is
44	* also protected.	44	* also protected.
45	*/	45	*/
46	Singleton() {};	46	Singleton() {};
47		47
48	private:	48	private:
49	/**	49	/**
50	* Copy constructor, defined so that you could write your own as well.	50	* Copy constructor, defined so that you could write your own as well.
51	*/	51	*/
52	Singleton( const Singleton& );	52	Singleton( const Singleton& );
53		53
54	public:	54	public:
55	/**	55	/**
56	* Get a handle to the contained instance of the contained class. It is	56	* Get a handle to the contained instance of the contained class. It is
57	* a reference.	57	* a reference.
58	*@returns A reference to the contained object.	58	*@returns A reference to the contained object.
59	*/	59	*/
60	static T &getInstance()	60	static T &getInstance()
61	{	61	{
62	static T i;	62	static T i;
63	return i;	63	return i;
64	}	64	}
65	};	65	};
66	}	66	}
67		67
68	#endif	68	#endif