NDGrid<T,N>::NDGrid(const NDGrid<T,N>& src)
{
	copyFrom(src);
}

RealTimeSampleArrayMetricState & RealTimeSampleArrayMetricState:: operator=(const RealTimeSampleArrayMetricState & object) {
	copyFrom(object);
	return *this;
}

QDropboxFileInfo &QDropboxFileInfo::operator=(const QDropboxFileInfo &other)
{
    copyFrom(other);
    return *this;
}

sendableMDNInfos::sendableMDNInfos(const sendableMDNInfos& other)
	: MDNInfos()
{
	copyFrom(other);
}

bodyPart& bodyPart::operator=(const bodyPart& other)
{
	copyFrom(other);
	return (*this);
}

Clipboard &
Clipboard::operator=(const Clipboard &c)
{
    copyFrom(&c);
    return *this;
}

void BinaryData::copyFrom(BinaryDataRef const & bdr)
{
   copyFrom( bdr.getPtr(), bdr.getSize() );
}

 TriggerParameterNumberAll(const TriggerParameterNumberAll& rhs) : TriggerParameterBase(rhs) { copyFrom(rhs); }

 TriggerParameterNumberAll& operator=(const TriggerParameterNumberAll& rhs)
 {
     if ( &rhs != this ) copyFrom(rhs);
     return *this;
 }

contentDisposition& contentDisposition::operator=(const contentDisposition& other)
{
	copyFrom(other);
	return (*this);
}

void test()
{
	//void main()
	

	int board_state[] = {
		1, 0, 0, 0, 5, 0, 0, 5, 0, 5, 5,
		0, 0, 0, 0, 5, 0, 5, 0, 0, 5, 5,
		0, 0, 0, 0, 0, 5, 0, 0, 5, 5, 5,
		0, 0, 5, 0, 0, 5, 5, 5, 5, 5, 5,
		0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 5, 5, 5, 5, 0, 5,
		5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 5,
		0, 0, 0, 0, 0, 0, 5, 5, 3, 5, 5,
		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
		5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
	};//               |

	auto b = copyFrom(board_state);
	unsigned int* rBoard = b->cells;

	float total = 0;
	system("pause");

	for (int i = 0; i < 45; ++i)
	{

		FILETIME now;
		GetSystemTimeAsFileTime(&now);
		LONGLONG now1 = (LONGLONG)now.dwLowDateTime + ((LONGLONG)(now.dwHighDateTime) << 32LL);

		int maxDepth = deepMove_ia(rBoard, 8, 8, 0, 100, false);

		GetSystemTimeAsFileTime(&now);
		LONGLONG now2 = (LONGLONG)now.dwLowDateTime + ((LONGLONG)(now.dwHighDateTime) << 32LL);

		int maxDepth2 = deepMove(b, 8, 8, 0, 100, false);

		GetSystemTimeAsFileTime(&now);
		LONGLONG now3 = (LONGLONG)now.dwLowDateTime + ((LONGLONG)(now.dwHighDateTime) << 32LL);

		//printf("Max Depth iterative = %d, time = %lld\n", maxDepth, now2 - now1);
		//printf("Max Depth recursive = %d, time = %lld\n", maxDepth2, now3 - now2);
		float rate = (now2 - now1) / (float)(now3 - now2);
		//printf("Ratio iterative/recursive = %f\n", rate);
		total += rate;
	}

	printf("end test, rate = %f", total / 45);
	getchar();

	//extern int evaluateBoard(board* b, const Position& myPos, const Position& opPos);
	Position myPos = Position(0, 0);
	Position opPos = Position(8, 8);
	
	for (int y = 0; y < MAP_SIZE; ++y)
	{
		for (int x = 0; x < MAP_SIZE; ++x)
		{
			printf("%d  ", board_state[CONVERT_COORD(x, y)]);
		}
		printf("\n\n");
	}

	while (true)
	{
		FILETIME ft_now;
		GetSystemTimeAsFileTime(&ft_now);
		LONGLONG ll_now = (LONGLONG)ft_now.dwLowDateTime + ((LONGLONG)(ft_now.dwHighDateTime) << 32LL);

		int dir = AiMove(board_state, myPos, opPos);

		GetSystemTimeAsFileTime(&ft_now);
		LONGLONG ll_now2 = (LONGLONG)ft_now.dwLowDateTime + ((LONGLONG)(ft_now.dwHighDateTime) << 32LL);
		printf("Player1: time = %lld, dir = %d\n", (ll_now2 - ll_now) / 10000, dir);
		board_state[CONVERT_COORD(myPos.x, myPos.y)] = BLOCK_PLAYER_1_TRAIL;
		switch (dir)
		{
		case 1:
			myPos.x--;
			break;
		case 2:
			myPos.y--;
			break;
		case 3:
			myPos.x++;
			break;
		case 4:
			myPos.y++;
			break;
		default:
			break;
		}
		board_state[CONVERT_COORD(myPos.x, myPos.y)] = BLOCK_PLAYER_1;
		for (int y = 0; y < MAP_SIZE; ++y)
		{
			for (int x = 0; x < MAP_SIZE; ++x)
			{
				printf("%d  ", board_state[CONVERT_COORD(x, y)]);
//.........这里部分代码省略.........

WorkflowContextDescriptor & WorkflowContextDescriptor:: operator=(const WorkflowContextDescriptor & object) {
	copyFrom(object);
	return *this;
}

// Construct a copy of a graph from a given graph
digraph::digraph(const digraph& G) : graph(G) {
    makeSpace();
    copyFrom(G);
}

void digraph::cFrom(const digraph& G) {
    graph::cFrom(G);
    copyFrom(G);
}

void MemoryBlock::copyFrom(MemoryBlock *src) {
	copyFrom(src, 0, 0, src->size());
}

charset& charset::operator=(const charset& other)
{
	copyFrom(other);
	return (*this);
}

Clipboard::Clipboard(const Clipboard &c) :
    m_partial(false)
{
    copyFrom(&c);
}

void
PasteUndoCommand::undo()
{
    copyFrom(_imp->originalSerialization->getKnob(), false);
} // undo

SecureBinaryData & SecureBinaryData::operator=(SecureBinaryData const & sbd2)
{ 
   copyFrom(sbd2.getPtr(), sbd2.getSize() );
   lockData(); 
   return (*this);
}

context& context::operator=(const context& ctx)
{
	copyFrom(ctx);
	return *this;
}