A fast and lightweight cell control

#include "stdafx.h"
#include "../include/GridBorders.h"
namespace mycell{
	struct ClearLeftBorderPolicy
	{
		ClearLeftBorderPolicy(BorderPair& bp)
		{
			bp.left.SetNull();
		}
	};
	struct ClearTopBorderPolicy
	{
		ClearTopBorderPolicy(BorderPair& bp)
		{
			bp.top.SetNull();
		}
	};
	struct ClearRightBorderPolicy
	{
		ClearRightBorderPolicy(BorderPair& bp)
		{
			bp.right.SetNull();
		}
	};
	struct ClearBottomBorderPolicy
	{
		ClearBottomBorderPolicy(BorderPair& bp)
		{
			bp.right.SetNull();
		}
	};

	template<class ClearBorderPolicyT>
	void ClearXBorder(map<row_t,map<col_t,BorderPair>*>& maps,int row,int col)
	{
		map<row_t,map<col_t,BorderPair>*>::iterator it=maps.find(row);
		if(it!=maps.end()){
			map<col_t,BorderPair>& mi=*it->second;
			map<col_t,BorderPair>::iterator i=mi.find(col);
			if(i!=mi.end()){
				ClearBorderPolicyT(i->second);
				if(i->second.empty()){
					mi.erase(i);
					if(mi.empty()){
						delete it->second;
						maps.erase(it);
					}
				}
			}
		}
	}

	struct SetLeftBorderPolicy
	{
		SetLeftBorderPolicy(BorderPair& bp,Border const& bdr)
		{
			bp.left=bdr;
		}
	};
	struct SetTopBorderPolicy
	{
		SetTopBorderPolicy(BorderPair& bp,Border const& bdr)
		{
			bp.top=bdr;
		}
	};
	struct SetRightBorderPolicy
	{
		SetRightBorderPolicy(BorderPair& bp,Border const& bdr)
		{
			bp.right=bdr;
		}
	};
	struct SetBottomBorderPolicy
	{
		SetBottomBorderPolicy(BorderPair& bp,Border const& bdr)
		{
			bp.bottom=bdr;
		}
	};
	template<class SetBorderPolicyT,class ClearBorderPolicyT>
	void SetXBorder(map<row_t,map<col_t,BorderPair>*>& maps,int row,int col,Border bdr)
	{
		BorderPair borderPair;
		map<row_t,map<col_t,BorderPair>*>::iterator it=maps.find(row);
		if(it==maps.end()){
			map<col_t,BorderPair>* p=new map<col_t,BorderPair>();
			SetBorderPolicyT sbp(borderPair,bdr);
			(*p).insert(make_pair(col,borderPair));
			maps.insert(make_pair(row,p));
		}else{
			map<col_t,BorderPair>& mi=*it->second;
			map<col_t,BorderPair>::iterator i=mi.find(col);
			if(i!=mi.end()){
				SetBorderPolicyT sbp(i->second,bdr);
				borderPair=i->second;
			}else{
				SetBorderPolicyT sbp(borderPair,bdr);
				mi.insert(make_pair(col,borderPair));
			}
		}
		if(borderPair.empty())
			ClearXBorder<ClearBorderPolicyT>(maps,row,col);
	};
	void GridBorders::SetLeftBorder(int row,int col,Border border)
	{
		//SetRightBorder(row,col-1,border);
		//map<row_t,map<col_t,val_t>*>::iterator it=maps_.find(row);
		//if(it==maps_.end()){
		//	map<col_t,val_t>* p=new map<col_t,val_t>();
		//	val_t bp;
		//	bp.clear();
		//	bp.left=border;
		//	(*p).insert(make_pair(col,bp));
		//	maps_.insert(make_pair(row,p));
		//}else{
		//	map<col_t,val_t>& mi=*it->second;
		//	map<col_t,val_t>::iterator i=mi.find(col);
		//	if(i!=mi.end()){
		//		i->second.left=border;
		//	}else{
		//		val_t bp;
		//		bp.clear();
		//		bp.left=border;
		//		mi.insert(make_pair(col,bp));
		//	}
		//}
		SetXBorder<SetLeftBorderPolicy,ClearLeftBorderPolicy>(maps_,row,col,border);
		if(col>0){
			SetXBorder<SetRightBorderPolicy,ClearRightBorderPolicy>(maps_,row,col-1,border);
		}
	}

	void GridBorders::SetRightBorder(int row,int col,Border border)
	{
		SetXBorder<SetRightBorderPolicy,ClearRightBorderPolicy>(maps_,row,col,border);
		//if(col>0){
			SetXBorder<SetLeftBorderPolicy,ClearLeftBorderPolicy>(maps_,row,col+1,border);
		//}
		/*
		map<row_t,map<col_t,val_t>*>::iterator it=maps_.find(row);
		if(it==maps_.end()){
			map<col_t,val_t>* p=new map<col_t,val_t>();
			val_t bp;
			bp.clear();
			bp.put_Right(border);
			(*p).insert(make_pair(col,bp));
			maps_.insert(make_pair(row,p));
		}else{
			map<col_t,val_t>& mi=*it->second;
			map<col_t,val_t>::iterator i=mi.find(col);
			if(i!=mi.end()){
				i->second.put_Right(border);
			}else{
				val_t bp;
				bp.clear();
				bp.put_Right(border);
				mi.insert(make_pair(col,bp));
			}
		}
		*/
	}
	void GridBorders::SetTopBorder(int row,int col,Border border)
	{
		SetXBorder<SetTopBorderPolicy,ClearTopBorderPolicy>(maps_,row,col,border);
		if(row>0){
			SetXBorder<SetBottomBorderPolicy,ClearBottomBorderPolicy>(maps_,row-1,col,border);
		}
	}
	void GridBorders::SetBottomBorder(int row,int col,Border border)
	{
		SetXBorder<SetBottomBorderPolicy,ClearBottomBorderPolicy>(maps_,row,col,border);
		//if(col>0){
			SetXBorder<SetTopBorderPolicy,ClearTopBorderPolicy>(maps_,row+1,col,border);
		//}
		//map<row_t,map<col_t,val_t>*>::iterator it=maps_.find(row);
		//if(it==maps_.end()){
		//	map<col_t,val_t>* p=new map<col_t,val_t>();
		//	val_t bp;
		//	bp.clear();
		//	bp.put_Bottom(border);
		//	(*p).insert(make_pair(col,bp));
		//	maps_.insert(make_pair(row,p));
		//}else{
		//	map<col_t,val_t>& mi=*it->second;
		//	map<col_t,val_t>::iterator i=mi.find(col);
		//	if(i!=mi.end()){
		//		i->second.put_Bottom(border);
		//	}else{
		//		val_t bp;
		//		bp.clear();
		//		bp.put_Bottom(border);
		//		mi.insert(make_pair(col,bp));
		//	}
		//}
	}
	void GridBorders::ClearLeftBorder(int row,int col)
	{
		ClearXBorder<ClearLeftBorderPolicy>(maps_,row,col);
	}
	void GridBorders::ClearTopBorder(int row,int col)
	{
		ClearXBorder<ClearTopBorderPolicy>(maps_,row,col);
	}
	void GridBorders::ClearBottomBorder(int row,int col)
	{
		ClearXBorder<ClearBottomBorderPolicy>(maps_,row,col);
	}
	void GridBorders::ClearRightBorder(int row,int col)
	{
		ClearXBorder<ClearRightBorderPolicy>(maps_,row,col);
		/*old
		BorderPair* p=find(row,col);
		if(p){
			p->clear_right();
		}
		*/
		//
		//map<row_t,map<col_t,BorderPair>*>::iterator it=maps_.find(row);
		//if(it!=maps_.end()){
		//	map<col_t,BorderPair>& mi=*it->second;
		//	map<col_t,BorderPair>::iterator i=mi.find(col);
		//	if(i!=mi.end()){
		//		i->second.clear_right();
		//		if(!i->second.HasBottom()){
		//			mi.erase(i);
		//			if(mi.empty()){
		//				delete it->second;
		//				maps_.erase(it);
		//			}
		//		}
		//	}
		//}
		//ClearLeftBorder(row,col+1);
	}
}//namespace mycell