Computer Science assignment help
32 flights must land at, be serviced by, and take off from, an airport. All flights that approach the airport go to a 20,000 holding pattern, which can accomodate all of the flights simultaneously. However, as they approach to land, they go thru 4 different flight areas. Each flight area can hold its own maximum number of flights, and must be visited in the given order:
Flight Area:Number of
simultaneous flights:10000 ft holding pattern3Landing Runway1Terminal4Take off Runway1
Note: some flight areas can hold multiple flights. Therefore, we do not want to lock the flight area. Rather, we want to lock the enter()-ing and leave()-ing of the flight area.
You must:
Make main() create NUM_FLIGHTS pthreads. Each pthread will run fly() given the address of one of the NUM_FLIGHTS instances of Flight in array flights[]. Afterwards, main()should wait for all NUM_FLIGHTS pthreads. Because fly() does not return any meaningful value, the second argument to pthread_join() can just be NULL.
Write void* fly (void* vPtr). fly() must cast the incoming vPtr to a pointer of type Flight, then run method doFlight() on that Flight instance. (You can say something like oHare.doFlight(*flightPtr)) Finally, it should return NULL
Finish the enter() method of class FlightArea. Do not disturb the code that is already there, but make it thread safe by locking the method as you begin, unlocking it as you leave, and waiting if the FlightArea is full.
Finish the leave() method of class FlightArea. Again, do not disturb the code that is already there, but make it thread safe by locking the method as you begin, unlocking it as you leave, and signalling that another Flight may enter.
Of course you may have add member variables to class FlightArea, and initialize and kill them in the constructor and destructor respectively.
The program:
/*————————————————————————-*
*— —*
*— airport.cpp —*
*— —*
*— This program simulates the approach, landing, servicing, —*
*— and taking off of several flights. Each flight is in its own —*
*— thread, and is to be handled in a thread-safe fashion. —*
*— —*
*— —- —- —- —- —- —- —- —- —*
*— —*
*— Version 1.0 2018 August 1 Joseph Phillips —*
*— —*
*————————————————————————-*/
//
// Compile with: g++ airport.cpp -o airport -lpthread
//
#include <cstdlib>
#include <cstdio>
#include <string>
#include <iostream>
#include <pthread.h>
#include <queue>
using namespace std;
// PURPOSE: To hold the names of the various airlines
const char* AIRLINE_NAME_ARRAY[]
= {“Air No Cares”,
“Fly-By-Nite”,
“Pterodactyl”,
“SwineAir”,
“Flying Toaster”,
“Do You Dare Air”,
“Air Montgolfier”,
“Luft Zeppelin”
};
// PURPOSE: To tell how many elements are in array ‘AIRLINE_NAME_ARRAY[]’.
const int NUM_AIRLINES = sizeof(AIRLINE_NAME_ARRAY)
/ sizeof(const char*);
// PURPOSE: To tell how many Flight instances need to be serviced.
const int NUM_FLIGHTS = 32;
// PURPOSE: To represent instances of a flight.
class Flight
{
// I. Member vars:
// PURPOSE: To tell the name of flight.
string name_;
// II. Disallowed auto-generated methods:
protected :
// III. Protected methods:
public :
// IV. Constructor(s), assignment op(s), factory(s) and destructor:
// PURPOSE: To randomly generate a flight. No parameters. No return value.
Flight ()
{
char text[64];
snprintf(text,64,”%s %d”,
AIRLINE_NAME_ARRAY[rand() % NUM_AIRLINES],
(rand() % 9999)+1
);
name_ = text;
}
// PURPOSE: To make ‘*this’ a copy of ‘source’. No return value.
Flight (const Flight& source
) :
name_(source.getName())
{ }
// PURPOSE: To release the resources of ‘*this’, make ‘*this’ a copy of
// ‘source’, and return a reference to ‘*this’. No return value.
Flight& operator= (const Flight& source
)
{
// I. Application validity check:
if (this == &source)
return(*this);
// II. Release resources:
// III. Copy ‘source’:
name_ = source.getName();
// IV. Finished:
return(*this);
}
// PURPOSE: To release the resources of ‘*this’. No parameters. No return
// value.
~Flight ()
{
}
// V. Accessors:
// PURPOSE: To return the name of the Flight.
const string& getName ()
const
{
return(name_);
}
};
// PURPOSE: To output Flight instance ‘flight’ to ‘os’. Returns reference to
// ‘os’.
ostream& operator<< (ostream& os,
const Flight& flight
)
{
os << flight.getName();
return(os);
}
// PURPOSE: To represent the various places that a limited number of Flight
// instances could be.
typedef enum
{
HOLDING_PATTERN_FLIGHT_AREA,
LANDING_RUNWAY_FLIGHT_AREA,
TERMINAL_FLIGHT_AREA,
TAKE_OFF_RUNWAY_FLIGHT_AREA
}
flightArea_t;
// PURPOSE: To represent the various places that a limited number of Flight
// instances could be.
class FlightArea
{
// I. Member vars:
// PURPOSE: To tell what type of flight area this is.
flightArea_t type_;
// PURPOSE: To tell the capacity.
int capacity_;
// PURPOSE: To hold pointers to the Flight instances.
queue<Flight> flightQueue_;
// YOUR CODE HERE:
// II. Disallowed auto-generated methods:
// No default constructor:
FlightArea ();
// No copy constructor:
FlightArea (const FlightArea&
);
// No copy assignment op:
FlightArea& operator= (const FlightArea&
);
protected :
// III. Protected methods:
// PURPOSE: To return the name of ‘*this’ FlightArea. No parameters.
string getName ()
const
{
const char* cPtr;
switch (type_)
{
case HOLDING_PATTERN_FLIGHT_AREA :
cPtr = “holding pattern”;
break;
case LANDING_RUNWAY_FLIGHT_AREA :
cPtr = “landing runway”;
break;
case TERMINAL_FLIGHT_AREA :
cPtr = “terminal”;
break;
case TAKE_OFF_RUNWAY_FLIGHT_AREA :
cPtr = “take-off runway”;
break;
}
return(string(cPtr));
}
// PURPOSE: To return the text when a Flight should stay out while it is
// waiting to enter ‘*this’ FlightArea. No parameters.
string getHoldText ()
const
{
const char* cPtr;
switch (type_)
{
case HOLDING_PATTERN_FLIGHT_AREA :
cPtr = “stay in the 20,000 foot holding pattern”;
break;
case LANDING_RUNWAY_FLIGHT_AREA :
cPtr = “stay in the 10,000 foot holding pattern”;
break;
case TERMINAL_FLIGHT_AREA :
cPtr = “stay in one the landing runway”;
break;
case TAKE_OFF_RUNWAY_FLIGHT_AREA :
cPtr = “stay at the terminal”;
break;
}
return(string(cPtr));
}
// PURPOSE: To return the text when a Flight may enter ‘*this’ FlightArea.
// No parameters.
string getEnterText ()
const
{
const char* cPtr;
switch (type_)
{
case HOLDING_PATTERN_FLIGHT_AREA :
cPtr = “enter the holding pattern”;
break;
case LANDING_RUNWAY_FLIGHT_AREA :
cPtr = “land”;
break;
case TERMINAL_FLIGHT_AREA :
cPtr = “taxi to the terminal”;
break;
case TAKE_OFF_RUNWAY_FLIGHT_AREA :
cPtr = “take off”;
break;
}
return(string(cPtr));
}
// PURPOSE: To return the text when a Flight should leave ‘*this’
// FlightArea. No parameters.
string getLeaveText ()
const
{
const char* cPtr;
switch (type_)
{
case HOLDING_PATTERN_FLIGHT_AREA :
cPtr = “make your final approach”;
break;
case LANDING_RUNWAY_FLIGHT_AREA :
cPtr = “clear the runway for other flights”;
break;
case TERMINAL_FLIGHT_AREA :
cPtr = “refuel safely”;
break;
case TAKE_OFF_RUNWAY_FLIGHT_AREA :
cPtr = “have a safe flight”;
break;
}
return(string(cPtr));
}
public :
// IV. Constructor(s), assignment op(s), factory(s) and destructor:
// PURPOSE: To initialize ‘*this’ FlightArea to have type ‘newType’ and
// to be allowed to hold ‘newCapacity’ simultaneous Flight instances. No
// return value.
FlightArea (flightArea_t newType,
int newCapacity
) :
type_(newType),
capacity_(newCapacity),
flightQueue_()
{
// YOUR CODE HERE:
}
// PURPOSE: To release the resources of ‘*this’. No parameters. No return
// value.
~FlightArea ()
{
// YOUR CODE HERE:
}
// V. Accessors:
// PURPOSE: To return ‘true’ if ‘*this’ FlightArea is full with Flight
// instances, or ‘false’ otherwise.
bool isFull ()
const
{
return(flightQueue_.size() == capacity_);
}
// VI. Mutators:
// VII. Methods that do main and misc. work of class:
// PURPOSE: To let Flight ‘flight’ begin to enter ‘*this’ FlightArea. No
// return value.
void enter (const Flight& flight
)
{
// YOUR CODE IN HERE, SOMEWHERE:
while ( isFull() )
{
cout << “Air Traffic Control: \”Flight ” << flight
<< “, the ” << getName() << ” is full. ”
<< “Please ” << getHoldText() << “\”.” << endl;
}
flightQueue_.push(flight);
if (flightQueue_.size() > capacity_)
{
cout << “CRASH! Too many flights in/on/at the ” << getName() << endl;
exit(EXIT_FAILURE);
}
cout << “Air Traffic Control: \”Flight ” << flight << “, please ”
<< getEnterText() << “\”.” << endl;
}
// PURPOSE: To let Flight ‘flight’ leave ‘*this’ FlightArea. No return
// value.
void leave (const Flight& flight
)
{
// YOUR CODE IN HERE, SOMEWHERE:
flightQueue_.pop();
cout << “Air Traffic Control: \”Flight ” << flight << “, please ”
<< getLeaveText() << “\”.” << endl;
}
};
// PURPOSE: To represent an Airport with multiple ‘FlightArea’ instances and
// with the responsibility of servicing multiple ‘Flight’ instances.
class Airport
{
// I. Member vars:
// PURPOSE: To implement the near orbit that Flight instances enter before
// final approach.
FlightArea holdingPattern_;
// PURPOSE: To implement the landing strip.
FlightArea landingRunway_;
// PURPOSE: To implement the airport terminal.
FlightArea terminal_;
// PURPOSE: To implement the taking-off runway.
FlightArea takeOffRunway_;
// II. Disallowed auto-generated methods:
// No copy constructor:
Airport (const Airport&
);
// No copy assignment op:
Airport& operator= (const Airport&
);
protected :
// III. Protected :
public :
// IV. Constructor(s), assignment op(s), factory(s) and destructor:
// PURPOSE: To initialize ‘*this’ Airport to have no Flight instances yet.
// No parameters. No return value.
Airport () :
holdingPattern_(HOLDING_PATTERN_FLIGHT_AREA,3),
landingRunway_(LANDING_RUNWAY_FLIGHT_AREA,1),
terminal_(TERMINAL_FLIGHT_AREA,4),
takeOffRunway_(TAKE_OFF_RUNWAY_FLIGHT_AREA,1)
{ }
// PURPOSE: To release the resources of ‘*this’. No parameters. No return
// value.
~Airport ()
{ }
// V. Accessors:
// VI. Mutators:
// VII. Methods that do main and misc. work of class:
// PURPOSE: To handle Flight ‘flight’ as it approaches, landis, gets
// serviced, and taked off. No return value.
void* doFlight (const Flight* flightPtr
)
{
cout << “Flight ” << *flightPtr << ” approaches the airport.” << endl;
holdingPattern_.enter(*flightPtr);
sleep( (rand() % 6) + 1);
holdingPattern_.leave(*flightPtr);
landingRunway_.enter(*flightPtr);
sleep( (rand() % 2) + 1);
landingRunway_.leave(*flightPtr);
terminal_.enter(*flightPtr);
sleep( (rand() % 8) + 1);
terminal_.leave(*flightPtr);
takeOffRunway_.enter(*flightPtr);
sleep( (rand() % 3) + 1);
takeOffRunway_.leave(*flightPtr);
}
};
// PURPOSE: To be the global variable that implements the airport at which
// all Flight instances must land.
Airport oHare;
// PURPOSE: To make Flight ‘*(Flight*)vPtr’ fly to, land at, and take off
// from, ‘oHare’. Returns ‘NULL’.
void* fly (void* vPtr
)
{
// YOUR CODE HERE:
return(NULL);
}
// PURPOSE: To simulate the ‘NUM_FLIGHTS’ Flight instances being serviced
// by Airport instance ‘oHare’. Ignores command line arguments. Returns
// ‘EXIT_SUCCESS’ to OS.
int main ()
{
// I. Application validity check:
// II. Simulate the approach, landing, servicing, and taking off of several
// flights:
// II.A. Create Flight instances:
Flight flights[NUM_FLIGHTS];
// II.B. Launch threads for Flight instances:
// YOUR CODE HERE:
// II.C. Collect threads for Flight instances:
// YOUR CODE HERE:
// III. Finished:
return(EXIT_SUCCESS);
