//
// ********************************************************************
// * DISCLAIMER                                                       *
// *                                                                  *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in:                      *
// *   http://cern.ch/geant4/license                                  *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.                                                             *
// *                                                                  *
// * This  code  implementation is the  intellectual property  of the *
// * GEANT4 collaboration.                                            *
// * By copying,  distributing  or modifying the Program (or any work *
// * based  on  the Program)  you indicate  your  acceptance of  this *
// * statement, and all its terms.                                    *
// ********************************************************************
//
//
// $Id: G4NavigationHistory.icc,v 1.4.2.1 2001/06/28 19:09:38 gunter Exp $
// GEANT4 tag $Name:  $
//
//
// class G4NavigationHistory Inline implementation
//

inline
G4NavigationHistory::G4NavigationHistory()
  : fNavHistory(kHistoryMax), fStackDepth(0)
{
	Reset();	// Reset depth
	Clear();
}

inline
G4NavigationHistory::G4NavigationHistory(const G4NavigationHistory &h)
  : fNavHistory(h.fNavHistory), fStackDepth(h.fStackDepth)
{
}

inline G4NavigationHistory::~G4NavigationHistory()
{
	Reset();	// To delete all but one current entries!
        // delete fNavHistory(0);
}

inline
G4NavigationHistory&
G4NavigationHistory::operator=(const G4NavigationHistory &h)
{
  if (&h == this) return *this;

  // fNavHistory=h.fNavHistory;   // This works, but is very slow.
  if( this->GetMaxDepth() < h.fStackDepth ){
     fNavHistory.resize( h.fStackDepth ); 
  }
  register G4int ilev= h.fStackDepth;
  for ( ; ilev>=0; ilev--) { 
     fNavHistory[ilev] = h.fNavHistory[ilev]; 
  } 

  fStackDepth=h.fStackDepth;

  return *this;
}

inline
void G4NavigationHistory::Reset()
{
	fStackDepth=0;
}

inline
void G4NavigationHistory::Clear()
{
	G4AffineTransform dummyTransform(G4ThreeVector(0.));

	G4NavigationLevel  tmpNavLevel;
	tmpNavLevel=G4NavigationLevel(0, dummyTransform, kParameterised, -1) ;

	Reset();
	for (G4int ilev=fNavHistory.size()-1; ilev>=0; ilev--)
	{
	   // fNavHistory(ilev)= 0;
	   fNavHistory[ilev]= tmpNavLevel;
	}
}

inline
void G4NavigationHistory::SetFirstEntry(G4VPhysicalVolume* pVol)
{
	G4ThreeVector translation(0.,0.,0.);

   	// Protection needed in case pVol=null 
        //   so that a touchable-history can signal OutOfWorld 
	//   
	if(pVol !=0) {
	    translation=pVol->GetTranslation();
	}
	fNavHistory[0]= G4NavigationLevel( pVol,
					   G4AffineTransform(translation), 
					   kNormal );
}

inline
const G4AffineTransform* G4NavigationHistory::GetPtrTopTransform() const
{
	return   fNavHistory[fStackDepth].GetPtrTransform();
}

inline
const G4AffineTransform& G4NavigationHistory::GetTopTransform() const
{
	return fNavHistory[fStackDepth].GetTransform();
}

inline
G4int G4NavigationHistory::GetTopReplicaNo() const
{
	return fNavHistory[fStackDepth].GetReplicaNo();
}

inline
EVolume G4NavigationHistory::GetTopVolumeType() const
{
	return fNavHistory[fStackDepth].GetVolumeType();
}

inline
G4VPhysicalVolume* G4NavigationHistory::GetTopVolume() const
{
	return fNavHistory[fStackDepth].GetPhysicalVolume();
}

inline
G4int G4NavigationHistory::GetDepth() const
{
	return fStackDepth;
}

inline
const G4AffineTransform&
G4NavigationHistory::GetTransform(G4int n) const
{
	return fNavHistory[n].GetTransform();
}

inline
G4int G4NavigationHistory::GetReplicaNo(G4int n) const
{
	return fNavHistory[n].GetReplicaNo();
}

inline
EVolume G4NavigationHistory::GetVolumeType(G4int n) const
{
	return fNavHistory[n].GetVolumeType();
}

inline
G4VPhysicalVolume* G4NavigationHistory::GetVolume(G4int n) const
{
	return fNavHistory[n].GetPhysicalVolume();
}

inline
G4int G4NavigationHistory::GetMaxDepth() const
{
	return fNavHistory.size();
}

inline
void G4NavigationHistory::BackLevel()
{
	assert(fStackDepth>0);

        //  Tell  the  level  that I am forgetting it
        // delete fNavHistory(fStackDepth); 
        fStackDepth--;
}

inline
void G4NavigationHistory::BackLevel(G4int n)
{
	assert(n<=fStackDepth);
        fStackDepth-=n;
}

inline
void G4NavigationHistory::EnlargeHistory()
{
	G4int len=fNavHistory.size();
	if (len==fStackDepth)
		{       // Note: Resize operation clears additional entries
			G4int nlen=len+kHistoryStride;
			fNavHistory.resize(nlen);
		}	
}


inline
void G4NavigationHistory::NewLevel(G4VPhysicalVolume *pNewMother,
				   EVolume vType,
				   G4int nReplica)
{
	EnlargeHistory();	// Enlarge if required
	fStackDepth++;
	fNavHistory[fStackDepth] = 
	       G4NavigationLevel(pNewMother, 
				 fNavHistory[fStackDepth-1].GetTransform(),
				 G4AffineTransform(pNewMother->GetRotation(),
						pNewMother->GetTranslation()),
				 vType,
				 nReplica); 
	// The constructor computes the new global->local transform
}