rangedatatypehelper.h

支票扫描仪协议Ranger的应用.使用vc7.1

#pragma once 
#include "RangerDataType.h"

class SRangerDataTypeHelper
{
public:
	static BOOL StringToBOOL(const CString& str)
	{
		if (str.CompareNoCase("true") == 0) return TRUE;
		return FALSE;
	}

	static CString BOOLToString(const BOOL b)
	{
		if (b) return "true";
		else return "false";
	}

	static int  StringToINT(const CString& str)
	{
		return atoi((LPCSTR)str);
	}
	
	static CString INTToString(const int& i)
	{
		CString str;
		str.Format("%d",i);
		return str;
	}

	static Transport_ExceptionManager  StringToExceptionManager(const CString& str)
	{
		if (str.CompareNoCase("Ranger") == 0)	
			return TE_Ranger;
		else if (str.CompareNoCase("WiseIP") == 0)	
			return TE_WiseIP;
		else if (str.CompareNoCase("CAPI") == 0)	
			return TE_CAPI;
		else 
		{
			ASSERT(FALSE);
			return TE_Unknown;
		}
	}
	
	static CString ExceptionManagerToString(const Transport_ExceptionManager& exp)
	{
		switch(exp)
		{
		case TE_Ranger: return "Ranger";
		case TE_WiseIP:  return "WiseIP";
		case TE_CAPI:  return "CAPI";
		default:  return "Ranger";
		}
	}

	static Transport_EncoderFont  StringToEncoderFont(const CString& str)
	{
		if (str.CompareNoCase("E13B"))
			return TEC_E13B;
		else if (str.CompareNoCase("CMC7"))
			return TEC_CMC7;
		else if (str.CompareNoCase("OCRA"))
			return TEC_OCRA;
		else if (str.CompareNoCase("OCRB"))
			return TEC_OCRB;
		else
		{
			ASSERT(FALSE);
			return TEC_Unknown;
		}
	}

	static CString EncoderFontToString(const Transport_EncoderFont& font)
	{
		switch(font)
		{
		case TEC_E13B:return "E13B";
		case TEC_CMC7:return "CMC7";
		case TEC_OCRA:return "OCRA";
		case TEC_OCRB:return "OCRB";
		default:return "E13B";

		}
	}

	static Transport_StampType  StringToStampType(const CString& str)
	{
		if (str.CompareNoCase("Roll On") == 0)	
			return TST_RollOn;
		else if (str.CompareNoCase("Programmable") == 0)	
			return TST_Programmable;
		else 
		{
			ASSERT(FALSE);
			return TST_Unknown;
		}
	}

	static CString StampTypeToString(const Transport_StampType& type)
	{
		switch(type)
		{
		case TST_RollOn: return "Roll On";
		case TST_Programmable: return "Programmable";
		default: return "Roll On";
		}
	}

	static Transport_PositionType  StringToPositionType(const CString& str)
	{
		if (str.CompareNoCase("Static") == 0)	
			return TSP_Static;
		else if (str.CompareNoCase("Dynamic") == 0)	
			return TSP_Dynamic;
		else 
		{
			ASSERT(FALSE);
			return TSP_Unknown;
		}
	}
	
	static CString PositionTypeToString(const Transport_PositionType& type)
	{
		switch(type)
		{
		case TSP_Static:	return "Static";
		case TSP_Dynamic:	return "Dynamic";
		default:			return "Static";
		}
	}

	static Transport_MICRFont  StringToMICRFont(const CString& str)
	{
		if (str.CompareNoCase("E13B"))
			return TM_E13B;
		else if (str.CompareNoCase("CMC7"))
			return TM_CMC7;
		else if (str.CompareNoCase("OCRA"))
			return TM_OCRA;
		else if (str.CompareNoCase("OCRB"))
			return TM_OCRB;
		else if (str.CompareNoCase("MicrAutoDetect"))
			return TM_MicrAutoDetect;
		else
		{
			ASSERT(FALSE);
			return TM_Unknown;
		}
	}
	
	static CString MICRFontToString(const Transport_MICRFont& font)
	{
		switch(font)
		{
		case TM_E13B:			return "E13B";
		case TM_CMC7:			return "CMC7";
		case TM_OCRA:			return "OCRA";
		case TM_OCRB:			return "OCRB";
		case TM_MicrAutoDetect: return "MicrAutoDetect";
		default:				return "MicrAutoDetect";
		}
	}

	static Transport_OCRFont  StringToOCRFont(const CString& str)
	{
		if (str.CompareNoCase("TO_OCRA"))
			return TO_OCRA;
		else if (str.CompareNoCase("TO_OCRA_Numeric"))
			return TO_OCRA_Numeric;
		else if (str.CompareNoCase("TO_OCRA_Special"))
			return TO_OCRA_Special;
		else if (str.CompareNoCase("TO_OCRA_Numeric_Special"))
			return TO_OCRA_Numeric_Special;
		else if (str.CompareNoCase("TO_OCRB"))
			return TO_OCRB;
		else if (str.CompareNoCase("TO_OCRB_Numeric"))
			return TO_OCRB_Numeric;
		else if (str.CompareNoCase("TO_OCRB_Special"))
			return TO_OCRB_Special;
		else if (str.CompareNoCase("TO_OCRB_Numeric_Special"))
			return TO_OCRB_Numeric_Special;
		else if (str.CompareNoCase("TO_E13B"))
			return TO_E13B;
		else if (str.CompareNoCase("TO_CMC7"))
			return TO_CMC7;
		else if (str.CompareNoCase("TO_IBRO"))
			return TO_IBRO;
		else if (str.CompareNoCase("TO_Barcode_Code39"))
			return TO_Barcode_Code39;
		else if (str.CompareNoCase("TO_7B_Numeric"))
			return TO_7B_Numeric;
		else if (str.CompareNoCase("TO_IBM_1403_Numeric"))
			return TO_IBM_1403_Numeric;
		else if (str.CompareNoCase("TO_1428_Numeric"))
			return TO_1428_Numeric;
		else
		{
			ASSERT(FALSE);
			return TO_Unknown;
		}
	}

	static CString OCRFontToString(const Transport_OCRFont& font)
	{
		switch(font)
		{
		case TO_OCRA:					return "TO_OCRA";
		case TO_OCRA_Numeric:			return "TO_OCRA_Numeric";
		case TO_OCRA_Special:			return "TO_OCRA_Special";
		case TO_OCRA_Numeric_Special:	return "TO_OCRA_Numeric_Special";
		case TO_OCRB:					return "TO_OCRB";
		case TO_OCRB_Numeric:			return "TO_OCRB_Numeric";
		case TO_OCRB_Special:			return "TO_OCRB_Special";
		case TO_OCRB_Numeric_Special:	return "TO_OCRB_Numeric_Special";
		case TO_E13B:					return "TO_E13B";
		case TO_CMC7:					return "TO_CMC7";	
		case TO_IBRO:					return "TO_IBRO";
		case TO_Barcode_Code39:			return "TO_Barcode_Code39";	
		case TO_7B_Numeric:				return "TO_7B_Numeric";
		case TO_IBM_1403_Numeric:		return "TO_IBM_1403_Numeric";
		case TO_1428_Numeric:			return "TO_1428_Numeric";
		default:						return "TO_OCRA";

		}
	}

	static Transport_ImageSide  StringToImageImageSide(const CString& str)
	{
		if (str.CompareNoCase("Front") == 0)
			return TIS_Front;
		else if (str.CompareNoCase("Rear") == 0)
			return TIS_Rear;
		else
		{
			ASSERT(FALSE);
			return TIS_Unkown;
		}
	}

	static CString ImageImageSideToString(const Transport_ImageSide& side)
	{
		switch(side)
		{
		case TIS_Front:return "Front";
		case TIS_Rear:return "Rear";
		default:return "Front";
		}
	}

	static Transport_ImageColorType  StringToImageColorType(const CString& str)
	{
		if (str.CompareNoCase("Bitonal") == 0)
			return TI_CT_Bitonal;
		else if (str.CompareNoCase("Grayscale") == 0)
			return TI_CT_Grayscale;
		else if (str.CompareNoCase("Color") == 0)
			return TI_CT_Color;
		else
		{
			ASSERT(FALSE);
			return TI_CT_Unkown;
		}
	}

	static CString ImageColorTypeToString(const Transport_ImageColorType& type)
	{
		switch(type)
		{
		case TI_CT_Bitonal:		return "Bitonal";
		case TI_CT_Grayscale:	return "Grayscale";
		case TI_CT_Color:		return "Color";
		default:				return "Bitonal";
		}	
	}

	static Transport_ImagePortion  StringToImagePortion(const CString& str)
	{
		if (str.CompareNoCase("Full Image") == 0)
			return TI_PORT_FullImage;
		else if (str.CompareNoCase("MICR CLI") == 0)
			return TI_PORT_MICRCLI;
		else if (str.CompareNoCase("OCR CLI") == 0)
			return TI_PORT_OCRCLI;
		else
		{
			ASSERT(FALSE);
			return TI_PORT_Unknown;
		}
	}
	
	static CString ImagePortionToString(const Transport_ImagePortion& portion)
	{
		switch(portion)
		{
		case TI_PORT_FullImage:			return "Full Image";
		case TI_PORT_MICRCLI:			return "MICR CLI";
		case TI_PORT_OCRCLI:			return "OCR CLI";
		default:						return "Full Image";
		}
	}
	static Transport_ImageLocation  StringToImageLocation(const CString& str)
	{
		if (str.CompareNoCase("Upstream") == 0)
			return TI_LOC_Upstream;
		else if (str.CompareNoCase("Downstream") == 0)
			return TI_LOC_Downstream;
		else
		{
			ASSERT(FALSE);
			return TI_LOC_Unknown;
		}
	}

	static CString ImageLocationToString(const Transport_ImageLocation& location)
	{
		switch(location)
		{
		case TI_LOC_Upstream:		return "Upstream";
		case TI_LOC_Downstream:		return "Downstream";
		default:					return "Upstream";
		}
	}
};