/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2025 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file BrepTraverse.cpp
This file demonstrates how to programmatically traverse the Brep structure

***********************************************************************************************************************/

#include "../VisitorContainer.h"
#include "../BrepTraverse.h"
#include <map>


//////////////////////////////////////////////////////////////////////////////
//					Traverse Brep
//////////////////////////////////////////////////////////////////////////////

A3DBrepDataConnector::A3DBrepDataConnector(const A3DTopoBrepData *pBrep) : A3DConnector(pBrep)
{
	A3D_INITIALIZE_DATA(A3DTopoBrepDataData, m_sBrepData);
	CALL_A3D_FCTION(A3DTopoBrepDataGet,(pBrep, &m_sBrepData));
}

A3DBrepDataConnector::~A3DBrepDataConnector()
{
	CALL_A3D_FCTION(A3DTopoBrepDataGet,(NULL, &m_sBrepData));
}

A3DStatus A3DBrepDataConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;

	//TopoContext
	A3DTopoBody *psTopoBody = (A3DTopoBody*)GetA3DEntity();
	A3DTopoBodyData sA3DTopoBodyData;
	A3D_INITIALIZE_DATA(A3DTopoBodyData, sA3DTopoBodyData);
	CHECK_RET_CALL_A3D_FCTION(A3DTopoBodyGet,(psTopoBody, &sA3DTopoBodyData));
	A3DTopoContext* psContext = sA3DTopoBodyData.m_pContext;

	A3DTopoContextData sA3DTopoContextData;
	A3D_INITIALIZE_DATA(A3DTopoContextData, sA3DTopoContextData);
	CHECK_RET_CALL_A3D_FCTION(A3DTopoContextGet,(psContext, &sA3DTopoContextData));
	//m_dScale = sA3DTopoContextData.m_dScale;

	CHECK_RET(psVisitor->visitEnter(*this));
	A3DUns32 uNbConnex = m_sBrepData.m_uiConnexSize;
	for (A3DUns32 uI = 0; uI < uNbConnex; uI++)
	{
		A3DConnexConnector sConnecConnector(m_sBrepData.m_ppConnexes[uI]);
		CHECK_RET(sConnecConnector.Traverse(psVisitor));
	}

	CHECK_RET(psVisitor->visitLeave(*this));
	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					Connex
//////////////////////////////////////////////////////////////////////////////

A3DConnexConnector::A3DConnexConnector(const A3DTopoConnex *pConnex) : A3DConnector(pConnex)
{
	A3D_INITIALIZE_DATA(A3DTopoConnexData, m_sConnexData);
	CALL_A3D_FCTION(A3DTopoConnexGet,(pConnex, &m_sConnexData));
}

A3DConnexConnector::~A3DConnexConnector()
{
	CALL_A3D_FCTION(A3DTopoConnexGet,(NULL, &m_sConnexData));
}

A3DStatus A3DConnexConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));
	unsigned uI, uNbShell = m_sConnexData.m_uiShellSize;
	for (uI = 0; uI < uNbShell; uI++)
	{
		A3DShellConnector sShellConnector(m_sConnexData.m_ppShells[uI]);
		CHECK_RET(sShellConnector.Traverse(psVisitor));
	}
	CHECK_RET(psVisitor->visitLeave(*this));
	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					Shell
//////////////////////////////////////////////////////////////////////////////

A3DShellConnector::A3DShellConnector(const A3DTopoShell *pShell) : A3DConnector(pShell)
{
	A3D_INITIALIZE_DATA(A3DTopoShellData, m_sShellData);
	CALL_A3D_FCTION(A3DTopoShellGet,(pShell, &m_sShellData));
}

A3DShellConnector::~A3DShellConnector()
{
	CALL_A3D_FCTION(A3DTopoShellGet,(NULL, &m_sShellData));
}

A3DStatus A3DShellConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));
	unsigned int uI, uFaceSize = m_sShellData.m_uiFaceSize;
	for (uI = 0; uI < uFaceSize; uI++)
	{
		A3DFaceConnector sFaceConnector(m_sShellData.m_ppFaces[uI]);
		CHECK_RET(sFaceConnector.Traverse(psVisitor));
	}
	CHECK_RET(psVisitor->visitLeave(*this));
	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					Face
//////////////////////////////////////////////////////////////////////////////

A3DFaceConnector::A3DFaceConnector(const A3DTopoFace* pFace) : A3DConnector(pFace)
{
	A3D_INITIALIZE_DATA(A3DTopoFaceData, m_sFaceData);
	CALL_A3D_FCTION(A3DTopoFaceGet,(pFace, &m_sFaceData));
}

A3DFaceConnector::~A3DFaceConnector()
{
	CALL_A3D_FCTION(A3DTopoFaceGet,(NULL, &m_sFaceData));
}

A3DStatus A3DFaceConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));
	unsigned int uI, uLoopSize = m_sFaceData.m_uiLoopSize;
	for (uI = 0; uI < uLoopSize; uI++)
	{
		A3DLoopConnector sLoopConnector(m_sFaceData.m_ppLoops[uI]);
		CHECK_RET(sLoopConnector.Traverse(psVisitor));
	}
	CHECK_RET(psVisitor->visitLeave(*this));
	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					Loop
//////////////////////////////////////////////////////////////////////////////

A3DLoopConnector::A3DLoopConnector(const A3DTopoLoop *pLoop) : A3DConnector(pLoop)
{
	A3D_INITIALIZE_DATA(A3DTopoLoopData, m_sLoopData);
	CALL_A3D_FCTION(A3DTopoLoopGet,(pLoop, &m_sLoopData));
}

A3DLoopConnector::~A3DLoopConnector()
{
	CALL_A3D_FCTION(A3DTopoLoopGet,(NULL, &m_sLoopData));
}

A3DStatus A3DLoopConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));

	unsigned uI, uCoEdgeSize = m_sLoopData.m_uiCoEdgeSize;
	for (uI = 0; uI < uCoEdgeSize; uI++)
	{
		A3DCoEdgeConnector sCoEdgeConnector(m_sLoopData.m_ppCoEdges[uI]);
		CHECK_RET(sCoEdgeConnector.Traverse(psVisitor));
	}

	CHECK_RET(psVisitor->visitLeave(*this));
	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					CoEdge
//////////////////////////////////////////////////////////////////////////////

A3DCoEdgeConnector::A3DCoEdgeConnector(const A3DTopoCoEdge *pCoEdge) : A3DConnector(pCoEdge)
{
	A3D_INITIALIZE_DATA(A3DTopoCoEdgeData, m_sCoEdgeData);
	CALL_A3D_FCTION(A3DTopoCoEdgeGet,(pCoEdge, &m_sCoEdgeData));
}

A3DCoEdgeConnector::~A3DCoEdgeConnector()
{
	CALL_A3D_FCTION(A3DTopoCoEdgeGet,(NULL, &m_sCoEdgeData));
}

A3DStatus A3DCoEdgeConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));

	if (!(psVisitor->FindInMap(m_sCoEdgeData.m_pEdge)))
	{
		psVisitor->SetInMap(m_sCoEdgeData.m_pEdge, (void*) this->GetA3DEntity());
		A3DEdgeConnector sEdgeConnector(m_sCoEdgeData.m_pEdge);
		CHECK_RET(sEdgeConnector.Traverse(psVisitor));
	}
	CHECK_RET(psVisitor->visitLeave(*this));

	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					Edge
//////////////////////////////////////////////////////////////////////////////

A3DEdgeConnector::A3DEdgeConnector(const A3DTopoEdge *pEdge)
	: A3DConnector(pEdge)
{
	A3D_INITIALIZE_DATA(A3DTopoEdgeData, m_sEdgeData);
	CALL_A3D_FCTION(A3DTopoEdgeGet,(pEdge, &m_sEdgeData));
}

A3DEdgeConnector::~A3DEdgeConnector()
{
	CALL_A3D_FCTION(A3DTopoEdgeGet,(NULL, &m_sEdgeData));
}

A3DStatus A3DEdgeConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));

	A3DEEntityType eType;
	//Start Vertex
	if (m_sEdgeData.m_pStartVertex != NULL)
	{
		CHECK_RET_CALL_A3D_FCTION(A3DEntityGetType,(m_sEdgeData.m_pStartVertex,&eType));
		if (eType == kA3DTypeTopoMultipleVertex)
		{
			A3DMultipleVertexConnector sStart(m_sEdgeData.m_pStartVertex);
			sStart.Traverse(psVisitor);
		}
		else if (eType == kA3DTypeTopoUniqueVertex)
		{
			A3DUniqueVertexConnector sStart(m_sEdgeData.m_pStartVertex);
			sStart.Traverse(psVisitor);
		}
	}

	//End Vertex
	if (m_sEdgeData.m_pEndVertex != NULL)
	{
		CHECK_RET_CALL_A3D_FCTION(A3DEntityGetType,(m_sEdgeData.m_pEndVertex,&eType));
		if (eType == kA3DTypeTopoMultipleVertex)
		{
			A3DMultipleVertexConnector sStart(m_sEdgeData.m_pEndVertex);
			sStart.Traverse(psVisitor);
		}
		else if (eType == kA3DTypeTopoUniqueVertex)
		{
			A3DUniqueVertexConnector sStart(m_sEdgeData.m_pEndVertex);
			sStart.Traverse(psVisitor);
		}
	}

	CHECK_RET(psVisitor->visitLeave(*this));
	return A3D_SUCCESS;
}

//////////////////////////////////////////////////////////////////////////////
//					Vertex
//////////////////////////////////////////////////////////////////////////////

A3DUniqueVertexConnector::A3DUniqueVertexConnector(const A3DTopoVertex *pVertex)
	: A3DConnector(pVertex)
{
	A3D_INITIALIZE_DATA(A3DTopoUniqueVertexData, m_sVertexData);
	CALL_A3D_FCTION(A3DTopoUniqueVertexGet,(pVertex, &m_sVertexData));
}

A3DUniqueVertexConnector::~A3DUniqueVertexConnector()
{
	CALL_A3D_FCTION(A3DTopoUniqueVertexGet,(NULL, &m_sVertexData));
}

A3DStatus A3DUniqueVertexConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));
	return A3D_SUCCESS;
}


A3DMultipleVertexConnector::A3DMultipleVertexConnector(const A3DTopoVertex *pVertex) : A3DConnector(pVertex)
{
	A3D_INITIALIZE_DATA(A3DTopoMultipleVertexData, m_sVertexData);
	CALL_A3D_FCTION(A3DTopoMultipleVertexGet,(pVertex, &m_sVertexData));
}

A3DMultipleVertexConnector::~A3DMultipleVertexConnector()
{
	CALL_A3D_FCTION(A3DTopoMultipleVertexGet,(NULL, &m_sVertexData));
}

A3DStatus A3DMultipleVertexConnector::Traverse(A3DVisitorContainer*  psVisitor) const
{
	A3DStatus iRet = A3D_SUCCESS;
	CHECK_RET(psVisitor->visitEnter(*this));
	return A3D_SUCCESS;
}