Need help with structure, accuracy, formatting etc. of this module.

[ginfinity]

Hello,

My name is Jeremy and I am an experienced C++ programmer but am completely new to C++11. Below is a module I am working on for a project of mine which is used to manage resources (similiar to a COM interface). It is not tested/debugged etc. so please don't run it as it is the first draft and untested. I have the following questions concerning it:

1) Since I am new to C++11 I would like to know if there are features/optimizations of C++11 that I am not using in this module that would make it better. It has been programmed (for the most part) without my knowledge of C++11.

2) Does C++11 have support for eliminating the need for forward declarations?
(There is one at the top that I do not know if I can eliminate with C++11).

3) It has always been my understanding that you want larger data members declared before smaller data members to save on padding bytes. Is this still accurate these days?

4) Due to its structure/nature, I needed to include the bodies of the methods inside the .h file (at least pre-C++11) although it would be nicer if I could use a .cpp file. With C++11 is there a way to move the method bodies of these template/static methods to a .cpp file?

5) Any other thoughts, recommendations?

Thank you for your help, ok, here it is:

/* !
*/
#pragma once
#ifndef JSFT_RESOURCE_MANAGER
#define JSFT_RESOURCE_MANAGER

// @ !
#include <map>
// @ End

/* @ !
*/
namespace Jade
{
	/* @ !
	*/
	namespace ResourceManager
	{
		/*
		*/
		class JInvalidRefCount : public std::exception
		{
		public:
		// @
			/*
			*/
			const char* what() const {return "ERROR: Attempted release of resource with reference count 0.";}
		};
		// @ End

		/*
		*/
		class JResourceNotFound : public std::exception
		{
		public:
		// @
			/*
			*/
			const char* what() const {return "ERROR: Attempted access of non-existant resource.";}
		};
		// @ End

		/* !
		*/
		template <class JLoadProperties, class JBaseResource>
		class JResourceManager
		{
		private:
		// @
			// @ !
			template <class JLoadProperties> class JResource;
			// @ End
		// @ End
		public:
		// @
			/* !
			*/
			typedef JResource<JLoadProperties>* PResource;
			// @ End
		// @ End
		private:
		// @
			/* !
			*/
			template <class JLoadProperties>
			class JResource : public JBaseResource
			{
			private:
			// @
				// @ !
				JLoadProperties load_properties_;
				unsigned int ref_count_;
				bool cached_;
				// @ End
			// @ End
			public:
			// @
				// @ 
				JResource() : ref_count_(0), cached_(false){}
				// @ End

				// @ 
				void Initialize(const JLoadProperties& load_properties){load_properties_ = load_properties; JBaseResource::Initialize(load_properties);}
				// @ End

				// @ !
				virtual ~JResource(){}
				// @ End

				/* !
				*/
				bool GetCacheState() const {return cached_;}
				// @ End

				/* !
				*/
				unsigned int GetRefCount() const {return ref_count_;}
				// @ End

				/* !
				*/
				const JLoadProperties& GetLoadProperties() const {return load_properties_;}
				// @ End

				/* !
				*/
				void SetCacheState(bool cache){cached_ = cache;}
				// @ End

				/* !
				*/
				void AddRef(){++ref_count_;}
				// @ End

				/* !
				*/
				unsigned int Release();
				// @ End
			};
			// @ End
		//@ End
		protected:
		// @
			// @
			static std::map<JLoadProperties, JResource<JLoadProperties>> resources_;
			// @ End
		//@ End
		public:
		// @
			/* !
			*/
			static bool GetCacheState(const JLoadProperties& load_properties);
			// @ End

			/* !
			*/
			static unsigned int GetResourceCount(){return resources_.size();}
			// @ End

			/* !
			*/
			static void CacheResource(const JLoadProperties& load_properties);
			// @ End

			/* !
			*/
			static void UncacheResource(const JLoadProperties& load_properties);
			// @ End

			/* !
			*/
			static void UncacheResources();
			// @ End

			/* !
			*/
			static PResource GetResource(const JLoadProperties& load_properties);
			// @ End

			/* !
			*/
			static bool HasReferencedResources();
			// @ End
		//@ End
		private:
		// @
			// @ !
			JResourceManager();
			// @ End
		};
		// @ End

		/*
		*/
		template <class LP, class BR> template <class LP2> unsigned int JResourceManager<LP, BR>::JResource<LP2>::Release()
		{
			if(!ref_count_)
			{
				throw JInvalidRefCount();
			}
			if(1 == ref_count_ && !cached_)
			{
				JResourceManager<LP, BR>::resources_.erase(load_properties_);
				return 0;
			}
			return --ref_count_;
		}
		// @ End

		/* 2
		*/
		template <class LP, class BR> bool JResourceManager<LP, BR>::GetCacheState(const LP& load_properties)
		{
			auto i = resources_.find(load_properties);
			if(resources_.end() == i)
			{
				throw JResourceNotFound();
			}
			return i->second.GetCacheState();
		}
		// @ End

		/* 2
		*/
		template <class LP, class BR> void JResourceManager<LP, BR>::CacheResource(const LP& load_properties)
		{
			auto description = resources_.emplace(std::pair<LP, JResource<LP>>(load_properties, JResource<LP>()));
			if(description.second)
			{
				description.first->second.Initialize(load_properties);
			}
			description.first->second.SetCacheState(true);
		}
		// @ End

		/* 2
		*/
		template <class LP, class BR> void JResourceManager<LP, BR>::UncacheResource(const LP& load_properties)
		{
			auto i = resources_.find(load_properties);
			if(resources_.end() == i)
			{
				throw JResourceNotFound();
			}
			if(i->second.GetRefCount())
			{
				i->second.SetCacheState(false);
			}
			else
			{
				resources_.erase(load_properties);
			}
		}
		// @ End

		/* 2
		*/
		template <class LP, class BR> void JResourceManager<LP, BR>::UncacheResources()
		{
			auto i = resources_.begin();
			while(resources_.end() != i)
			{
				if(i->second.GetCacheState())
				{
					if(i->second.GetRefCount())
					{
						i->second.SetCacheState(false);
					}
					else
					{
						i = resources_.erase(i);
						continue;
					}
				}
				++i;
			}
		}
		// @ End

		/* ! 2
		*/
		template <class LP, class BR> typename JResourceManager<LP, BR>::PResource JResourceManager<LP, BR>::GetResource(const LP& load_properties)
		{
			auto description = resources_.emplace(std::pair<LP, JResource<LP>>(load_properties, JResource<LP>()));
			if(description.second)
			{
				description.first->second.Initialize(load_properties);
			}
			description.first->second.AddRef();
			return &description.first->second;
		}
		// @ End

		/*
		*/
		template <class LP, class BR> bool JResourceManager<LP, BR>::HasReferencedResources()
		{
			for(auto& i : resources_)
			{
				if(i.second.GetRefCount())
				{
					return true;
				}
			}
			return false;
		}
		// @ End

		// @
		template <class LP, class BR> std::map<LP, typename JResourceManager<LP, BR>::JResource<LP>> JResourceManager<LP, BR>::resources_;
		// @ End
	}
	// @ End
}
// @ End

#endif;
// @ End !
// @ End