template <class T>
class Var {

	typedef Var<T>		Base;

	public:
		
		bool ValidPtr() {
			return m_var != NULL;
		}

		virtual Release() {
			m_var = NULL;
		}

		void Attach(T *var) {
			Release();
			m_var = var;
		}

		T *Detach() {
			T *retval = m_var;
			m_var = NULL;
			return retval;
		}

		virtual void Clear() = 0;
		virtual void Undef() = 0;

		operator T *() {
			return m_var;
		}

		operator T *() const {
			return m_var;
		}

		operator const T *() {
			return m_var;
		}

		operator const T *() const {
			return m_var;
		}

	protected:
		Var(T *var) : m_var(var) {
		}

	protected:
		T*	m_var;
};

class Scalar : public Var<SV> {
	public:
		Scalar();
		Scalar(IV iv);
		Scalar(UV uv);
		Scalar(double dv);
		Scalar(const char *str, STRLEN len);
		Scalar(const std::string & str);
		Scalar(SV *sv);
		Scalar(const Scalar & scalar);
		~Scalar();		

	public:
		void Clear();
		void Undef();
};

class Hash : public Var<HV> {
	
	public:
		Hash();		
		~Hash();		
		
	public:
		void Clear();
		void Undef();

	public:
		Scalar Store(const std::string & key, const Scalar & scalar);
		
};

void Hash::Store(const std::string & key, const Scalar & scalar) {
	if(ValidPtr()) {
		SV **result = hv_store(
			*this, 
			key.c_str(), 
			key.length(), 
			scalar,
			0
		);
	}
}

##</code><code>##

Hash Interpreter::GetHash(const char *name, bool create /*=false*/) {
	Hash hash;

	hash.Attach(get_hv(name, create));

	return hash;
}

##</code><code>##

Perl::Hash perlenv = m_perl->GetHash("ENV");
if(perlenv.ValidPtr()) {
	perlenv.Store("foo", Perl::Scalar("bar"));
	perlenv.Store("bar", Perl::Scalar("foo"));
}