The Windows Access Control Model Part 4

/**
*	This code is by OShah. all code will have the following licence.
*	Copyright Shexec32. All code bears the following licence:
**/

/**
*	Copyright Shexec32 2004-2005. All rights reserved.
*
*	THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
*	ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED
*	TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
*	PARTICULAR PURPOSE.
**/
#ifndef RAII_H
#define RAII_H
#pragma once


template<class DatType>
class sized_array
{/**	A simplified scoped_array class from Boost. This has copy semantics. For Anti-hacking technologies, we're
*	going to Zero all memory allocated. For STL compatibility, we are going to add a copy consructor and equality
*	operator. This makes it act more like a C99 VLA rather than an auto_ptr.
*	Due to the lack of export keyword support in many C++ compilers, I'll need to define the shared class here.
**/
protected:
	size_t Size;
	DatType * OurPtr;	/* The scope of this variable is determined by the object. */

	void CopyHelper(const std::basic_string<TCHAR> &OldClass)
	{
		/* always resize. */
		if(this->get_Size() < OldClass.size() + 1)
		{
			this->reset(OldClass.size() + 1);
		}
#ifndef _SCL_INSECURE_DEPRECATE
		OldClass.copy(this->get(), OldClass.size(), 0);
#else
		OldClass._Copy_s(this->get(), this->get_Size(), OldClass.size(), 0);
#endif /* _SCL_INSECURE_DEPRECATE */
	};

	void DoCopy(DatType *TheirPtr, size_t TheirSize)
	{
		std::copy<const DatType *, DatType *>(TheirPtr, TheirPtr + TheirSize, this->OurPtr);
	};

public:
	explicit sized_array (size_t len = 1) : OurPtr(NULL), Size(len)
	{
		if(len != 0)
		{
			this->OurPtr = new DatType[len];
			SecureZeroMemory(OurPtr, len * sizeof(DatType));
		}
	};

	sized_array(const sized_array &OldClass) : Size(OldClass.Size), OurPtr(new DatType[OldClass.Size])
	{
		DoCopy(OldClass.OurPtr, OldClass.Size);
		//std::copy<const DatType *, DatType *>(OldClass.OurPtr, OldClass.OurPtr + Size, OurPtr);
	};

	void reset(size_t len = 1)
	{/* Also called release and reallocate. */
		delete [] OurPtr;
		OurPtr = new DatType[len];
		SecureZeroMemory(OurPtr, len * sizeof(DatType));

		Size = len;
	};


	DatType *get(void) const
	{/* Accessor. Only get is currently implemented. */
		return OurPtr;
	};

	size_t get_Size(void) const
	{/* For Convenience */
		return Size;
	};


	sized_array &operator=(const sized_array &OldClass)
	{/* This equality may be required by CObjSecurity. */
		if(this==&OldClass) return *this;

		Size = OldClass.Size;
		this->reset(Size);
		DoCopy(OldClass.OurPtr, Size);
		return *this;
	};

	sized_array(const std::basic_string<DatType> &OldClass) : Size(0), OurPtr(NULL)
	{/* Copy contructor for strings */
		this->CopyHelper(OldClass);
	};

	sized_array &operator=(const std::basic_string<DatType> &OldClass)
	{
		this->CopyHelper(OldClass);
		return *this;
	};

	virtual ~sized_array()
	{
		delete [] OurPtr;
		OurPtr = NULL;
	};
};

#endif /* RAII_H */