warurltype.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarUrlType.h"   // class implemented


/////////////////////////////// PUBLIC ///////////////////////////////////////

//============================= LIFECYCLE ====================================

WarUrlType::WarUrlType()
{
	Reset();
}// WarUrlType

WarUrlType::WarUrlType(const WarUrlType& from)
{
	operator = (from);
}// WarUrlType

WarUrlType::WarUrlType(war_ccstr_t tagName)
{
	std::string tag = tagName;
	if (!strchr(tagName, ':'))
	{
		tag += ":///";
	}
	Create(tag.c_str());
}

WarUrlType::~WarUrlType()
{
}// ~WarUrlType


//============================= OPERATORS ====================================

WarUrlType& WarUrlType::operator = (const WarUrlType& from)
{
	mTagName = from.mTagName;
	mDoHostscan = from.mDoHostscan;
    mDoFilePath = from.mDoFilePath;
	mStyle = from.mStyle;
	return *this;   
}// =

bool WarUrlType::operator == (war_ccstr_t urlTag)
{
	return stricmp(urlTag, mTagName.c_str()) == 0;
}

//============================= OPERATIONS ===================================

void WarUrlType::Create(war_ccstr_t fullUrl) throw(WarException)
{    
	Reset();
	
	war_ccstr_t p, pp;
	
	if (!fullUrl || !*fullUrl)
		WarThrow(WarError(WAR_ERR_INVALID_ARGUMENT), NULL);
	
	for(p = fullUrl; *p; p++)
	{
		if (*p == ':')
		{
			size_t len = p - fullUrl;
			
			if (len < 2)
				WarThrow(WarError(WAR_ERR_INVALID_URL), NULL);
			
			for(pp = fullUrl; pp < p;)
				mTagName += *pp++;

			// Lookup
			typemap_t::const_iterator P = mDefinedTypes.find(mTagName);
			if (P != mDefinedTypes.end())
				operator = (*P->second);
			
			if (mDoHostscan
				&& (*++p != '/')
				&& (*++p != '/'))
				WarThrow(WarError(WAR_ERR_INVALID_URL), NULL);
			
			return;
		}
	}

	WarThrow(WarError(WAR_ERR_NOT_AN_URL), NULL);
}

void WarUrlType::Initialize()
{
	DefineUrlType("ftp", S_FTP, true, false);
	DefineUrlType("ftps", S_FTP, true, false);
	DefineUrlType("http", S_HTTP, true, false);
	DefineUrlType("https", S_HTTP, true, false);
	DefineUrlType("mailto", S_GENERIC, false, false);
	DefineUrlType("news", S_GENERIC, false, false);
	DefineUrlType("file", S_GENERIC, true, true);
}

void WarUrlType::Reset()
{
	mTagName.erase();
	mDoHostscan = true;
	mDoFilePath = false;
	mStyle = S_GENERIC; 
}

void WarUrlType::DefineUrlType(war_ccstr_t urlTag,
		ProtocolStyleE urlStyle,
		bool isHostscanRequired,
		bool isFilepathRequired)
{
	WarUrlType *pnew = new WarUrlType;
	pnew->mTagName = urlTag;
	pnew->mStyle = urlStyle;
	pnew->mDoHostscan = isHostscanRequired;
	pnew->mDoFilePath = isFilepathRequired;

	if (mDefinedTypes.insert(typemap_t::value_type(
		pnew->mTagName, pnew)).second != true)
	{
		// Already defined
		delete pnew;
	}
}


//============================= CALLBACK   ===================================
//============================= ACCESS     ===================================
//============================= INQUIRY    ===================================

const std::string& WarUrlType::GetUrlTag() const 
throw(WarException)
{
	if (mTagName.empty())
		WarThrow(WarError(WAR_ERR_INTERNAL_DATA_NOT_INITIALIZED), NULL);
	return mTagName;
}

const std::string WarUrlType::GetUrlName() const
throw(WarException)
{
	if (mTagName.empty())
		WarThrow(WarError(WAR_ERR_INTERNAL_DATA_NOT_INITIALIZED), NULL);
	std::string ret_value = mTagName;
	
	if (mDoHostscan)
		ret_value += "://";
	else
		ret_value += ':';
	
	return ret_value;
}

size_t WarUrlType::GetLenght() throw(WarException)
{
	if (mTagName.empty())
		WarThrow(WarError(WAR_ERR_INTERNAL_DATA_NOT_INITIALIZED), NULL);
	return mTagName.size() + 1 + (mDoHostscan ? 2 : 0); // <name>://
}

bool WarUrlType::IsHostscanRequiered() const
throw(WarException)
{
	if (mTagName.empty())
		WarThrow(WarError(WAR_ERR_INTERNAL_DATA_NOT_INITIALIZED), NULL);
	return mDoHostscan;
}

bool WarUrlType::IsFilePathRequired() const
throw(WarException)
{
	if (mTagName.empty())
		WarThrow(WarError(WAR_ERR_INTERNAL_DATA_NOT_INITIALIZED), NULL);
	return mDoFilePath;
}

WarUrlType::ProtocolStyleE WarUrlType::GetStyle()
{
	return mStyle;
}

bool WarUrlType::IsEmpty() const
{
	return mTagName.empty() == true;
}

/////////////////////////////// PROTECTED  ///////////////////////////////////

/////////////////////////////// PRIVATE    ///////////////////////////////////

WarUrlType::typemap_t WarUrlType::mDefinedTypes;