C++ ListNode::getData方法代码示例

void LinkedList::printList(ofstream& out){
   out << "ListHead --> (" << listHead->getData() << ", " << listHead->getNext() << ") ";
   ListNode* temp = listHead->getNext();
   while(temp != NULL){
      out << "--> (" << temp->getData() << ", " << temp->getNext() << ") ";
      temp = temp->getNext();
   }
   out << endl;
}

    /*!
     * Create middlephase jobs according to the \ref BroadPhaseJob.
     *
     * See also \ref MiddlePhaseJobCreator and \ref
     * DetectorDeformManager::pickAlgorithmFor
     */
    void Pipeline::createMiddlePhaseJobs(BroadPhaseJob* broadPhaseJob) {
        List<CollisionPair*>& jobResults = broadPhaseJob->getJobResultsReference();
        for (ListNode<CollisionPair*>* node = jobResults.getFirstNode(); node; node = node->getNext()) {
            CollisionPair* pair = node->getData();

            // TODO make CollisionPair store Proxy pointers.
            //      we usually dont care about the BVs when reading the pairs!!
            Proxy* p1 = pair->bvol1->getHierarchyNode()->getProxy();
            Proxy* p2 = pair->bvol2->getHierarchyNode()->getProxy();

            if (p1->getProxyType() & PROXYTYPE_DEFORMABLE ||
                    p2->getProxyType() & PROXYTYPE_DEFORMABLE) {

                if (mWorld->getUseCollisionCaching()) {
                    bool cacheApplied = mWorld->getCollisionCache()->applyCacheIfAvailable(p1, p2);
                    if (cacheApplied) {
                        continue;
                    }
                }

                DetectorDeformAlgorithm* algorithm = mDetectorDeformManager->pickAlgorithmFor(p1, p2);
                if (algorithm) {
                    // TODO: fix API.
                    //       createCollisionJobFor() uses CollisionPair,
                    //       pickAlgorithmFor() uses two Proxy pointers.
                    //       choose one!
                    algorithm->createCollisionJobFor(*pair);
                }
            }
        }


        mMiddlePhaseJobCreator->createJobs(broadPhaseJob);
    }

void List::copy(List L){
		Head = NULL;
		ListNode * temp = L.Head;
		while(temp!=NULL){
			this->append(temp->getData());
			temp=temp->getNext();
		}
}

void List<NODETYPE>::concatenate(List<NODETYPE> &listSecond) {
    ListNode<NODETYPE> *currentPtr = listSecond.firstPtr;

    while (currentPtr != 0) {
        insertAtBack(currentPtr->getData());
        currentPtr = currentPtr->nextPtr;
    }
}

 /*!
  * Start all jobs that have been added to this collection (see \ref addJob).
  * If a job gets added after this point, it will get started immediately
  * (unless \ref resetCompleted has been called in between, which also resets
  * the started flag).
  */
 void ThreadJobCollection::start() {
     if (mStarted) {
         return;
     }
     if (getAllJobsCompleted()) {
         throw Exception("Cannot start collection - all jobs already marked as completed");
     }
     mStarted = true;
     if (mJobs.empty()) {
         allJobsCompleted();
     } else {
         for (ListNode<ThreadJob*>* node = mJobs.getFirstNode(); node; node = node->getNext()) {
             startJob(node->getData());
         }
     }
 }

void DisplayTrip(const int BORDER,
				  string username,
			      Trip &trip)
{
	const int NUM_OF_OPTIONS = trip.getDestinations().size();

	//Data Structures
	ListNode<tripNode>* 	   selected[NUM_OF_OPTIONS];
	int            parentAr   [NUM_OF_OPTIONS];
	int            dist       [NUM_OF_OPTIONS];

	List<tripNode> destinations;
	avltree<User>  users;

	//Input-Output
	stringstream   ss;
	stringstream   ss2;

	//Variables
	int input;
	int option;
	int index;
	int distance;
	int totalDistance;

	string tripStr;
	string tripName;

	ifstream inFile;
	ofstream outFile;
	User     tempUser;

	tripNode tempTrip;
	tripNode lastTrip;
	tripNode source;
	ListNode<tripNode> *node;

	DWORD mode;

	//Initialize Variables
	input         = 0;
	option        = 1;
	index         = 0;
	distance      = 0;
	totalDistance = 0;

	destinations = trip.getDestinations();
	destinations.to_front();

	CenterStrings(ss, "Press Enter to Select a Trip", BORDER);
	CenterStrings(ss, "Use Up or Down Arrow Keys to Navigate list", BORDER);
	CenterStrings(ss, "Press Ctrl-S to Save and Exit \n\n", BORDER);

	if(destinations.currentNode(source)){
		destinations.to_front();
		source = trip.getSource();
		fastRoute(destinations,
				  source,
				  parentAr,
				  dist,
				  NUM_OF_OPTIONS);
	}

	//Initialize all indices of currentTrip[] to 0 (All options unselected)
	for(int pos = 0; pos < NUM_OF_OPTIONS; pos++){
		selected[pos] = NULL;
	}


	//Main Loop
	while(input != -1)
	{
		// Clear Console.
		system("CLS");

		//Reset Index
		index = 0;
		//PrintInput("MainMenu.txt");
		cout << (MenuString());
		cout << ss.str() << '\n';

		destinations.to_front();

		// Prints Selection.  Passes parameter based on
		// current value of option.
		node = destinations.currentNode();
		while(node != NULL){
			if(index == 0)
			{
				distance = 0;
			}
			else
			{
				distance = node->getData().s.getLocation().distanceTo
													(lastTrip.s.getLocation());
			}
			totalDistance += distance;
			lastTrip = node->getData();

			ss2 << node->getData().s.getStadiumName().str
//.........这里部分代码省略.........

 /*!
  * Called once all jobs in this collection have been completed, i.e.:
  * \li every job that was added using \ref addJob also called \ref setJobCollection
  * \li all jobs that belong to this collection have been added (see \ref setAllJobsAreAdded)
  *
  * Derived classes that reimplement this method \em must call the base
  * implementation!
  */
 void ThreadJobCollection::allJobsCompleted() {
     mAllJobsCompleted = true;
     for (ListNode<ThreadJobCollection*>* node = mStartOnceCompleted.getFirstNode(); node; node = node->getNext()) {
         node->getData()->start();
     }
 }

int main()
{
	//PlaySound(("NFL_REMIX.wav"), NULL, SND_LOOP | SND_ASYNC);
	List<Souvenir> souvList;
	avltree< TeamContainer<teamName> >    teamAvl;
	avltree< TeamContainer<stadiumName> > stadiumAvl;
	avltree< TeamContainer<year> >        yearAvl;

	ofstream outFile;
	ifstream inFile;
	tripNode tempTrip;
	List<tripNode> trip;
	Team        stad;
	string temp;
	tripNode       source;
	int size = 0;



    MainMenu(80);

	outFile.open("CONSOLE OUTPUT.txt");

	List<Team> stadiumList;

	GenerateStadiums("NFLStadiums.txt", stadiumList);

	stadiumList.to_front();
	ListNode<Team>* tempNode;

	while(!(stadiumList.isEmpty())){
		tempNode = stadiumList.pop();
		if(tempNode != NULL){
			Team tempStadium = tempNode->getData();
			stadiumAvl.insert(TeamContainer<stadiumName>(tempStadium));
			teamAvl.insert(TeamContainer<teamName>(tempStadium));
			yearAvl.insert(TeamContainer<year>(tempStadium));
		}
	}

	outFile << "------------------------------------------------------" << endl
			<< "-        LIST OF NFL TEAMS BY : STADIUM NAME          " << endl
			<< "------------------------------------------------------"
			<< endl << endl;
	outFile << stadiumAvl.inorder() << endl << endl;

	outFile << "------------------------------------------------------" << endl
			<< "-        LIST OF NFL TEAMS BY : TEAM NAME             " << endl
			<< "------------------------------------------------------"
			<< teamAvl.inorder() << endl << endl;

	outFile << "------------------------------------------------------" << endl
			<< "-        LIST OF NFL TEAMS BY : STADIUM NAME          " << endl
			<< "------------------------------------------------------"
			<< endl << endl;
	outFile << yearAvl.inorder() << endl << endl;




	outFile << "------------------------------------------------------" << endl
		    << "-     AVL TREE BY Team Name : ASCENDING ORDER     -" << endl
		    << "------------------------------------------------------"
		    << endl << endl;
	outFile << stadiumAvl.inorder();

	//START OF AVL TREE
		GenerateStadiums("NFLStadiums.txt", stadiumList);
		avltree< TeamContainer<roofType> > roofAvl;

		while(!(stadiumList.isEmpty())){
			tempNode = stadiumList.pop();
			if(tempNode != NULL){
				Team tempStadium = tempNode->getData();
				roofAvl.insert(TeamContainer<roofType>(tempStadium));
			}
		}

		outFile << "------------------------------------------------------" << endl
			    << "-     AVL TREE BY ROOF TYPE: ASCENDING ORDER     -" << endl
			    << "------------------------------------------------------"
			    << endl << endl;
		outFile << roofAvl.inorder();

	return 0;
}

 /*!
  * Start all jobs in \p list, i.e. add them to the \ref getWorkerPool
  */
 void Pipeline::startJobs(List<ThreadJob*>* list) {
     for (ListNode<ThreadJob*>* node = list->getFirstNode(); node; node = node->getNext()) {
         mWorkerPool->addJob(node->getData());
     }
     list->clear();
 }