ciao.
Ho una classe che funge da iteratore , ha delle variabili
membro array che contengono i dati e vi accedo dall'esterno tipo:
int dato1=cclasseiteratore->getDato1;
int dato2=cclasseiteratore->getDato2;
dato1 = 1
dato2 = 2
ecc....
se poi incremento l'indice avro:

cclasseiteratore->movenext();

int dato1=cclasseiteratore->getDato1;
int dato2=cclasseiteratore->getDato2;

dato1 = 3
dato2 = 4

questo lo ottengo incrementanodo un indice all'interno
della mia classe iteratore e "andando" a prendere i valori
dagli array interni utilizzando l'indice.

m_StressIterator è un instanza della classe iteratore.

il problema è questo:
1)ho 2 categorie reazioni e spostamenti e per ognuna devo
ciclare 2 sottocategorie statica e dinamica
devo caricare una volta sola le due categorie
e 2 volte per categoria le sottocategorie
in pratica potro' avere
1)reazione/statica
2)spostamenti/statica
3)reazione/dinamica
4)spostamenti/dinamica

adesso ho 2 categorie e due sottocategorie , ma il
concetto è piu' ampio , ptrei avere n categorie
esiste un buon metodo per gestire il tutto?
codice:
switch(m_iJointResultType)//reazioni=0 spostamenti = 1
{
	case ENTITY_STRESS: // =1
		CurrAnalysisCase();		
		m_pData->m_StressIterator->LoadJointResult(GetCurCdCType());
		break;
	case  ENTITY_DISPL: // =2
		CurrAnalysisCase();
		m_pData->m_StressIterator->LoadJointDisplacement(GetCurCdCType());
		break;
	}
io avevo pensato a questa soluzione:

codice:
m_pData->m_StressIterator->LoadJoint(GetCurCdCType(),m_iJointResultType);
e gestire il tutto all'internoi della classe cclasseiteratore
tipo:
codice:
void CSapStressIteratorBase::LoadJoint(int type ,int analysis)
{
	switch (type)
	{
		case 0:
			LoadJointResult(analysis)
			break;
		case 1:
			LoadJointDisplacement(analysis)
			break;
	}
	
}
dove loadjointresult e loadjoint displacement sono le due funzioni
che caricano i dati negli array all'interno della classe iteratore prendendo come parametro
l'analisi.

il mio problema è che la funzione va richiamata una sola volta per tipo parametro
e mai piu:

codice:
void importfunction()
{
	//questo solo una volta per parametro
   	//caricamento dati classe:(non fa niente se la combinazione è gia stata caricata)
	m_pData->m_StressIterator->LoadJoint(GetCurCdCType(),m_iJointResultType);
   	
	//perchè la funzione processa i dati qui fino alla loro
	//fine.

	m_pData->m_StressIterator->getData1 ;
	m_pData->m_StressIterator->getData2 ;
            //e poi riparte caricando un alta combinazione di analisi e di m:iJointResulttype


}
è questa "prima volta" che non riesco a rendere