C++ 日程管理软件 课程设计

// base64Coder.cpp: implementation of the base64Coder class.
//
//////////////////////////////////////////////////////////////////////

#include “stdafx.h“
#include “base64Coder.h“

// Digits...
static char	base64Digits[] = “ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/“;

BOOL base64Coder::m_Init		= FALSE;
char base64Coder::m_DecodeTable[256];

#ifndef PAGESIZE
#define PAGESIZE					4096
#endif

#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE（a）			（（（a/4096）+1）*4096）
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

base64Coder::base64Coder（）
:	m_pDBuffer（NULL）
	m_pEBuffer（NULL）
	m_nDBufLen（0）
	m_nEBufLen（0）
{

}

base64Coder::~base64Coder（）
{
	if（m_pDBuffer != NULL）
		delete [] m_pDBuffer;

	if（m_pEBuffer != NULL）
		delete [] m_pEBuffer;
}

LPCTSTR base64Coder::DecodedMessage（） const 
{ 
	return （LPCTSTR） m_pDBuffer;
}

PBYTE base64Coder::DecodedMessage（DWORD& nLenMessage） const
{
	nLenMessage = m_nDDataLen;

	return m_pDBuffer;
}

LPCTSTR base64Coder::EncodedMessage（） const
{ 
	return （LPCTSTR） m_pEBuffer;
}

void base64Coder::AllocEncode（DWORD nSize）
{
	if（m_nEBufLen < nSize）
	{
		if（m_pEBuffer != NULL）
			delete [] m_pEBuffer;

		m_nEBufLen = ROUNDTOPAGE（nSize）;
		m_pEBuffer = new BYTE[m_nEBufLen];
	}

	::ZeroMemory（m_pEBuffer m_nEBufLen）;
	m_nEDataLen = 0;
}

void base64Coder::AllocDecode（DWORD nSize）
{
	if（m_nDBufLen < nSize）
	{
		if（m_pDBuffer != NULL）
			delete [] m_pDBuffer;

		m_nDBufLen = ROUNDTOPAGE（nSize）;
		m_pDBuffer = new BYTE[m_nDBufLen];
	}

	::ZeroMemory（m_pDBuffer m_nDBufLen）;
	m_nDDataLen = 0;
}

void base64Coder::SetEncodeBuffer（const PBYTE pBuffer DWORD nBufLen）
{
	DWORD	i = 0;

	AllocEncode（nBufLen）;
	while（i < nBufLen）
	{
		if（!_IsBadMimeChar（pBuffer[i]））
		{
			m_pEBuffer[m_nEDataLen] = pBuffer[i];
			m_nEDataLen++;
		}

		i++;
	}
}

void base64Coder::SetDecodeBuffer（const PBYTE pBuffer DWORD nBufLen）
{
	AllocDecode（nBufLen）;
	::CopyMemory（m_pDBuffer pBuffer nBufLen）;
	m_nDDataLen = nBufLen;
}

void base64Coder::Encode（const PBYTE pBuffer DWORD nBufLen）
{
	SetDecodeBuffer（pBuffer nBufLen）;
	AllocEncode（nBufLen * 2）;

	TempBucket			Raw;
	DWORD					nIndex	= 0;

	while（（nIndex + 3） <= nBufLen）
	{
		Raw.Clear（）;
		::CopyMemory（&Raw m_pDBuffer + nIndex 3）;
		Raw.nSize = 3;
		_EncodeToBuffer（Raw m_pEBuffer + m_nEDataLen）;
		nIndex		+= 3;
		m_nEDataLen	+= 4;
	}

	if（nBufLen > nIndex）
	{
		Raw.Clear（）;
		Raw.nSize = （BYTE） （nBufLen - nIndex）;
		::CopyMemory（&Raw m_pDBuffer + nIndex nBufLen - nIndex）;
		_EncodeToBuffer（Raw m_pEBuffer + m_nEDataLen）;
		m_nEDataLen += 4;
	}
}

void base64Coder::Encode（LPCTSTR szMessage）
{
	if（szMessage != NULL）
		base64Coder::Encode（（const PBYTE）szMessage strlen（szMessage））;
}

void base64Coder::De