rangerdatatype.cpp

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

	std::vector<TANSPORTINFO_FRONTIMAGE>().swap(FrontImages);
	std::vector<TANSPORTINFO_REARIMAGE>().swap(RearImages);
}

TRANSPORTINFO::TRANSPORTINFO(const TRANSPORTINFO& other)
{
	General = other.General;
	Encoder = other.Encoder ;
	FrontEndorser = other.FrontEndorser;
	RearEndorser = other.RearEndorser;
	FrontStamp = other.FrontStamp;
	RearStamp = other.RearStamp ;
	MicroFilmer = other.MicroFilmer;

	std::copy(other.MicrReaders.begin(),other.MicrReaders.end(),std::back_inserter(MicrReaders));
	std::copy(other.OCRReaders.begin(),other.OCRReaders.end(),std::back_inserter(OCRReaders));
	std::copy(other.FrontImages.begin(),other.FrontImages.end(),std::back_inserter(FrontImages));
	std::copy(other.RearImages.begin(),other.RearImages.end(),std::back_inserter(RearImages));

}

TRANSPORTINFO& TRANSPORTINFO::operator=(const TRANSPORTINFO& other)
{
	if (this != &other)
	{
		General = other.General;
		Encoder = other.Encoder ;
		FrontEndorser = other.FrontEndorser;
		RearEndorser = other.RearEndorser;
		FrontStamp = other.FrontStamp;
		RearStamp = other.RearStamp ;
		MicroFilmer = other.MicroFilmer;
		
		std::vector<TANSPORTINFO_MICRREADER>().swap(MicrReaders);
		std::vector<TANSPORTINFO_OCRREADER>().swap(OCRReaders);
		std::vector<TANSPORTINFO_FRONTIMAGE>().swap(FrontImages);
		std::vector<TANSPORTINFO_REARIMAGE>().swap(RearImages);
		std::copy(other.MicrReaders.begin(),other.MicrReaders.end(),std::back_inserter(MicrReaders));
		std::copy(other.OCRReaders.begin(),other.OCRReaders.end(),std::back_inserter(OCRReaders));
		std::copy(other.FrontImages.begin(),other.FrontImages.end(),std::back_inserter(FrontImages));
		std::copy(other.RearImages.begin(),other.RearImages.end(),std::back_inserter(RearImages));
	}
	return *this;
}
//TRANSPORTJOBOPTION_DEVICE
TRANSPORTJOBOPTION_DEVICE::TRANSPORTJOBOPTION_DEVICE()
{
	bNeedMicrEncoder = FALSE;
	bNeedFrontEndorser = FALSE;
	bNeedRearEndorser = FALSE;
	bNeedFrontStamp = FALSE;
	bNeedRearStamp = FALSE;
	bNeedMicrofilmer = FALSE;
	bNeedOcr = FALSE;
	std::vector<BOOL>().swap(bNeedOCRReaders);
	bNeedImaging = FALSE;
	std::vector<BOOL>().swap(bNeedFrontImages);
	std::vector<BOOL>().swap(bNeedRearImages);
	bNeedPocketGroups = FALSE;
	bNeedIQA = FALSE;
	bNeedIQAUpstream = FALSE;
	bNeedIQADownstream = FALSE;
}

TRANSPORTJOBOPTION_DEVICE::TRANSPORTJOBOPTION_DEVICE(const TRANSPORTJOBOPTION_DEVICE& other)
{
	bNeedMicrEncoder = other.bNeedMicrEncoder;
	bNeedFrontEndorser = other.bNeedFrontEndorser;
	bNeedRearEndorser = other.bNeedRearEndorser;
	bNeedFrontStamp = other.bNeedFrontStamp;
	bNeedRearStamp = other.bNeedRearStamp;
	bNeedMicrofilmer = other.bNeedMicrofilmer;
	bNeedOcr = other.bNeedOcr;
	std::copy(other.bNeedOCRReaders.begin(),other.bNeedOCRReaders.end(),std::back_inserter(bNeedOCRReaders));
 	bNeedImaging = other.bNeedImaging;
	std::copy(other.bNeedFrontImages.begin(),other.bNeedFrontImages.end(),std::back_inserter(bNeedFrontImages));
	std::copy(other.bNeedRearImages.begin(),other.bNeedRearImages.end(),std::back_inserter(bNeedRearImages));
	bNeedPocketGroups = other.bNeedMicrEncoder;
	bNeedIQA = other.bNeedIQA;
	bNeedIQAUpstream = other.bNeedIQAUpstream;
	bNeedIQADownstream = other.bNeedIQADownstream;
}

TRANSPORTJOBOPTION_DEVICE& TRANSPORTJOBOPTION_DEVICE::operator=(const TRANSPORTJOBOPTION_DEVICE& other)
{
	if (this != &other)
	{
		std::vector<BOOL>().swap(bNeedOCRReaders);
		std::vector<BOOL>().swap(bNeedFrontImages);
		std::vector<BOOL>().swap(bNeedRearImages);
		bNeedMicrEncoder = other.bNeedMicrEncoder;
		bNeedFrontEndorser = other.bNeedFrontEndorser;
		bNeedRearEndorser = other.bNeedRearEndorser;
		bNeedFrontStamp = other.bNeedFrontStamp;
		bNeedRearStamp = other.bNeedRearStamp;
		bNeedMicrofilmer = other.bNeedMicrofilmer;
		bNeedOcr = other.bNeedOcr;
		std::copy(other.bNeedOCRReaders.begin(),other.bNeedOCRReaders.end(),std::back_inserter(bNeedOCRReaders));
		bNeedImaging = other.bNeedImaging;
		std::copy(other.bNeedFrontImages.begin(),other.bNeedFrontImages.end(),std::back_inserter(bNeedFrontImages));
		std::copy(other.bNeedRearImages.begin(),other.bNeedRearImages.end(),std::back_inserter(bNeedRearImages));
		bNeedPocketGroups = other.bNeedMicrEncoder;
		bNeedIQA = other.bNeedIQA;
		bNeedIQAUpstream = other.bNeedIQAUpstream;
		bNeedIQADownstream = other.bNeedIQADownstream;
	}
	return *this;
}

//TRANSPORTJOBOPTION_REARSTAMP
TRANSPORTJOBOPTION_FRONTSTAMP::TRANSPORTJOBOPTION_FRONTSTAMP()
{
	nStaticPosition = 0;
	std::vector<CString>().swap(StampFiles);
}

TRANSPORTJOBOPTION_FRONTSTAMP::TRANSPORTJOBOPTION_FRONTSTAMP(const TRANSPORTJOBOPTION_FRONTSTAMP& other)
{
	nStaticPosition = other.nStaticPosition;
	std::copy(other.StampFiles.begin(),other.StampFiles.end(),std::back_inserter(StampFiles));
}

TRANSPORTJOBOPTION_FRONTSTAMP& TRANSPORTJOBOPTION_FRONTSTAMP::operator=(const TRANSPORTJOBOPTION_FRONTSTAMP& other)
{
	if (this != &other)
	{
		std::vector<CString>().swap(StampFiles);
		nStaticPosition = other.nStaticPosition;
		std::copy(other.StampFiles.begin(),other.StampFiles.end(),std::back_inserter(StampFiles));
	}
	return *this;
}

//TRANSPORTJOBOPTION_REARSTAMP
TRANSPORTJOBOPTION_REARSTAMP::TRANSPORTJOBOPTION_REARSTAMP()
{
	nStaticPosition = 0;
	std::vector<CString>().swap(StampFiles);
}

TRANSPORTJOBOPTION_REARSTAMP::TRANSPORTJOBOPTION_REARSTAMP(const TRANSPORTJOBOPTION_REARSTAMP& other)
{
	nStaticPosition = other.nStaticPosition;
	std::copy(other.StampFiles.begin(),other.StampFiles.end(),std::back_inserter(StampFiles));
}

TRANSPORTJOBOPTION_REARSTAMP& TRANSPORTJOBOPTION_REARSTAMP::operator=(const TRANSPORTJOBOPTION_REARSTAMP& other)
{
	if (this != &other)
	{
		std::vector<CString>().swap(StampFiles);
		nStaticPosition = other.nStaticPosition;
		std::copy(other.StampFiles.begin(),other.StampFiles.end(),std::back_inserter(StampFiles));
	}
	return *this;
}

//TRANSPORTJOBOPTION_OCRREDER
TRANSPORTJOBOPTION_OCRREDER::TRANSPORTJOBOPTION_OCRREDER()
{
	font = TO_Unknown;
	nVerticalCenter = 0;
	nRight = 0;
	nWidth = 0;
}

TRANSPORTJOBOPTION_OCRREDER::TRANSPORTJOBOPTION_OCRREDER(const TRANSPORTJOBOPTION_OCRREDER& other)
{
	font = other.font;
	nVerticalCenter = other.nVerticalCenter;
	nRight = other.nRight;
	nWidth = other.nWidth;
}

TRANSPORTJOBOPTION_OCRREDER& TRANSPORTJOBOPTION_OCRREDER::operator=(const TRANSPORTJOBOPTION_OCRREDER& other)
{
	if (this != &other)
	{
		font = other.font;
		nVerticalCenter = other.nVerticalCenter;
		nRight = other.nRight;
		nWidth = other.nWidth;
	}
	return *this;
}

//TRANSPORTJOBOPTION_IMAGING
TRANSPORTJOBOPTION_IMAGING::TRANSPORTJOBOPTION_IMAGING()
{
	RootCaptureDirectory = "";
}

TRANSPORTJOBOPTION_IMAGING::TRANSPORTJOBOPTION_IMAGING(const TRANSPORTJOBOPTION_IMAGING& other)
{
	RootCaptureDirectory = other.RootCaptureDirectory;
}

TRANSPORTJOBOPTION_IMAGING& TRANSPORTJOBOPTION_IMAGING::operator=(const TRANSPORTJOBOPTION_IMAGING& other)
{
	if (this != &other)
	{
		RootCaptureDirectory = other.RootCaptureDirectory;
	}
	return *this;
}

//TRANSPORTJOBOPTION_FRONTIMAGE
TRANSPORTJOBOPTION_FRONTIMAGE::TRANSPORTJOBOPTION_FRONTIMAGE()
{
	StorageFile = "";
}

TRANSPORTJOBOPTION_FRONTIMAGE::TRANSPORTJOBOPTION_FRONTIMAGE(const TRANSPORTJOBOPTION_FRONTIMAGE& other)
{
	StorageFile = other.StorageFile;
}

TRANSPORTJOBOPTION_FRONTIMAGE& TRANSPORTJOBOPTION_FRONTIMAGE::operator=(const TRANSPORTJOBOPTION_FRONTIMAGE& other)
{
	if (this != &other)
	{
		StorageFile = other.StorageFile;
	}
	return *this;
}

//TRANSPORTJOBOPTION_REARIMAGE
TRANSPORTJOBOPTION_REARIMAGE::TRANSPORTJOBOPTION_REARIMAGE()
{
	StorageFile = "";
}

TRANSPORTJOBOPTION_REARIMAGE::TRANSPORTJOBOPTION_REARIMAGE(const TRANSPORTJOBOPTION_REARIMAGE& other)
{
	StorageFile = other.StorageFile;
}

TRANSPORTJOBOPTION_REARIMAGE& TRANSPORTJOBOPTION_REARIMAGE::operator=(const TRANSPORTJOBOPTION_REARIMAGE& other)
{
	if (this != &other)
	{
		StorageFile = other.StorageFile;
	}
	return *this;
}

//TRANSPORTJOBOPTION_POCKETS
TRANSPORTJOBOPTION_POCKETS::TRANSPORTJOBOPTION_POCKETS()
{
	nPocketFullCount = 0;
	std::vector<CString>().swap(PhysicalPockets);
}

TRANSPORTJOBOPTION_POCKETS::TRANSPORTJOBOPTION_POCKETS(const TRANSPORTJOBOPTION_POCKETS& other)
{
	nPocketFullCount = other.nPocketFullCount;
	std::copy(other.PhysicalPockets.begin(),other.PhysicalPockets.end(),std::back_inserter(PhysicalPockets));
}

TRANSPORTJOBOPTION_POCKETS& TRANSPORTJOBOPTION_POCKETS::operator=(const TRANSPORTJOBOPTION_POCKETS& other)
{
	if (this != &other)
	{
		nPocketFullCount = other.nPocketFullCount;
		std::copy(other.PhysicalPockets.begin(),other.PhysicalPockets.end(),std::back_inserter(PhysicalPockets));
	}
	return *this;
}

//TRANSPORTJOBOPTION_EXCEPTIONHANDING
TRANSPORTJOBOPTION_EXCEPTIONHANDING::TRANSPORTJOBOPTION_EXCEPTIONHANDING()
{
	bEnable = FALSE;
	bAutoHandPocket = FALSE;
	MaxHandPocketDisplayItems = 0;
	bAllowSkipItemRecovery = FALSE;
}

TRANSPORTJOBOPTION_EXCEPTIONHANDING::TRANSPORTJOBOPTION_EXCEPTIONHANDING(const TRANSPORTJOBOPTION_EXCEPTIONHANDING& other)
{
	bEnable = other.bEnable;
	bAutoHandPocket = other.bAutoHandPocket;
	MaxHandPocketDisplayItems = other.MaxHandPocketDisplayItems ;
	bAllowSkipItemRecovery = other.bAllowSkipItemRecovery;
}

TRANSPORTJOBOPTION_EXCEPTIONHANDING& TRANSPORTJOBOPTION_EXCEPTIONHANDING::operator=(const TRANSPORTJOBOPTION_EXCEPTIONHANDING& other)
{
	if (this != &other)
	{
		bEnable = other.bEnable;
		bAutoHandPocket = other.bAutoHandPocket;
		MaxHandPocketDisplayItems = other.MaxHandPocketDisplayItems ;
		bAllowSkipItemRecovery = other.bAllowSkipItemRecovery;
	}
	return *this;
}

//TRANSPORTJOBOPTION
TRANSPORTJOBOPTION::TRANSPORTJOBOPTION()
{
	device = TRANSPORTJOBOPTION_DEVICE();
	FrontStamp = TRANSPORTJOBOPTION_FRONTSTAMP();
	RearStamp = TRANSPORTJOBOPTION_REARSTAMP();
	std::vector<TRANSPORTJOBOPTION_OCRREDER>().swap(OCRReaders);
	Imaging = TRANSPORTJOBOPTION_IMAGING();
	std::vector<TRANSPORTJOBOPTION_FRONTIMAGE>().swap(FrontImages);
	std::vector<TRANSPORTJOBOPTION_REARIMAGE>().swap(RearImages);
	Pockets = TRANSPORTJOBOPTION_POCKETS();
	ExceptionHanding = TRANSPORTJOBOPTION_EXCEPTIONHANDING();
}

TRANSPORTJOBOPTION::TRANSPORTJOBOPTION(const TRANSPORTJOBOPTION& other)
{
	device = other.device;
	FrontStamp = other.FrontStamp;
	RearStamp = other.RearStamp;
	std::copy(other.OCRReaders.begin(),other.OCRReaders.end(),std::back_inserter(OCRReaders));
 	Imaging = TRANSPORTJOBOPTION_IMAGING();
	std::copy(other.FrontImages.begin(),other.FrontImages.end(),std::back_inserter(FrontImages));
	std::copy(other.RearImages.begin(),other.RearImages.end(),std::back_inserter(RearImages));
	Pockets = TRANSPORTJOBOPTION_POCKETS();
	ExceptionHanding = TRANSPORTJOBOPTION_EXCEPTIONHANDING();
}

TRANSPORTJOBOPTION& TRANSPORTJOBOPTION::operator=(const TRANSPORTJOBOPTION& other)
{
	if (this != &other)
	{
		device = TRANSPORTJOBOPTION_DEVICE();
		FrontStamp = TRANSPORTJOBOPTION_FRONTSTAMP();
		RearStamp = TRANSPORTJOBOPTION_REARSTAMP();
		std::vector<TRANSPORTJOBOPTION_OCRREDER>().swap(OCRReaders);
		Imaging = TRANSPORTJOBOPTION_IMAGING();
		std::vector<TRANSPORTJOBOPTION_FRONTIMAGE>().swap(FrontImages);
		std::vector<TRANSPORTJOBOPTION_REARIMAGE>().swap(RearImages);
		Pockets = TRANSPORTJOBOPTION_POCKETS();
		ExceptionHanding = TRANSPORTJOBOPTION_EXCEPTIONHANDING();

		device = other.device;
		FrontStamp = other.FrontStamp;
		RearStamp = other.RearStamp;
		std::copy(other.OCRReaders.begin(),other.OCRReaders.end(),std::back_inserter(OCRReaders));
		Imaging = TRANSPORTJOBOPTION_IMAGING();
		std::copy(other.FrontImages.begin(),other.FrontImages.end(),std::back_inserter(FrontImages));
		std::copy(other.RearImages.begin(),other.RearImages.end(),std::back_inserter(RearImages));
		Pockets = TRANSPORTJOBOPTION_POCKETS();
		ExceptionHanding = TRANSPORTJOBOPTION_EXCEPTIONHANDING();
	}
	return *this;
}