0
Warrants do not appear on your criminal record, only your arrests and actual criminal charges.
Wiki User
∙ 14y ago
Add your answer:
Earn +20 pts
When was Jacob Remin born?
Jacob Remin was born in 1977.
When was Katarzyna Remin born?
Katarzyna Remin was born on March 7, 1958, in Krakw, Malopolskie, Poland.
How much is 5 zhongguo renmin yinhang worth in Philippine peso?
zhongguo remin yinhang
What happen between Nick Jonas and Selena Gomez?
They dated for about a year, but less then a year. They could NEVER spend any time with each other. They were spotted together ONCE! They still remin godd friends.
Why is the check engine light blinking in your 1999 Mercury Courgar Already change 2 sensors?
Maybe the sensors you changed out were not the problem. Post what the symptoms were, what the codes were, and why you changed out what sensors you did. Sometimes errantly the wrong part is diagnosed as being defective, like having low fuel pressure and people spend $500 for fuel injectors when in reality it was a clogged fuel filter for $10 Some cars take a few starting cycles or cycles of driving before they reset the check engine light. If you had someone read your codes, normally they have the ability to turn off the check engine light. If you replaced the incorrect part(s) then your check engine light will remin on until the part casuing the fault is replaced. I hope the parts you replaced were the problem and it's just a matter of havign the check engine light turned off. If not, repost and maybe we can direct you. Todays' engines are not like ones of old where you can throw parts at it and "feel" you got it fixed. It's either fixed right or the check engine light is there to remind you it isn't.
Single server queue in C plus plus?
The following code is quite involved however it is split over several classes and is heavily commented so it should be fairly easy to understand. The main class is the shop class which handles a list of customer objects who enter and leave the shop. The shop essentially operates on a refresh loop, defaulting to 300 loops (5 virtual minutes). Each customer has an associated mode (or status) that determines their progress throughout the shop. Their status is updated with each cycle and a progress report sent to the console. Initially a customer has ENTERING status. On the next cycle the shop promotes them to SHOPPING status. While in SHOPPING mode, a customer may (or may not!) place 1 item in their basket on each subsequent refresh, up to a maximum of 5 items (chosen at random when the customer was constructed), whereupon they automatically promote themselves to QUEUEING status. On the next refresh, all customers with QUEUEING status are pushed onto the checkout cue and given QUEUED status. The checkout queue handles the customer from that point on. The checkout queue handles one customer on each refresh -- whichever is at the front of the queue. If they have QUEUED status, they are promoted to SERVING status for the next refresh. While in SERVING mode, on each refresh one item is removed from their basket and added to their purchases. If there are no items in the basket, they are promoted to SERVED status instead. On the next refresh they move to PAYING status. On the next refresh they pay the bill and are promoted to LEAVING status, at which point they are popped from the queue and handed back to the shop. At the start of each refresh, all customers with LEAVING status are removed from the shop's customer list. The 300 loops essentially represent 300 seconds (5 minutes) of virtual time after which the shop will close (don't worry, even on a slow computer the program will finish in well under a minute). However, there may still be customers in the shop so a closing time of 60 seconds is also set (you can adjust the number of cycles as well as the closing time during construction of the shop, or you can use the defaults of 1 hour and 5 minutes respectively, which may take a couple of minutes in real time). Anyone entering the shop during the closing time period is automatically promoted to LEAVING status as are any SHOPPING customers with empty baskets. Those with items already in their baskets are promoted to QUEUEING status, even if their baskets are not yet filled. Thus from 1 minute to closing time, all the remaining customers are either placed in the queue or are forced to leave on the next cycle. In some cases the queue may be fully processed within the 60 remaining cycles, but if there are too many customers, the program enters an "overtime" phase to process the last of the customers, reporting how many additional cycles were required (late closing). Note that the baskets don't contain any actual items, the basket class simply maintains a count of items. However feel free to extend the program as you see fit. // Single Server Queue Demonstration // Copyright © PCForrest 2014. All Rights Reserved. // // OS: Windows 8.1 // IDE: Visual Studio Ultimate 2013 Update 2 // Platform: generic console application (cross-platform) // Standard Library: C++11 // Additional Libraries: none #include<iostream> #include<list> #include<queue> #include<random> #include<chrono> // Random number generator (see your IDE documentation for details). std::mt19937 eng ((unsigned)std::chrono::high_resolution_clock::now().time_since_epoch().count()); std::uniform_int_distribution<unsigned> dist1 (1U, 5U); std::uniform_int_distribution<unsigned> dist2 (1U, 12U); // Customer status. enum status_t { ENTERING, SHOPPING, QUEUEING, QUEUED, SERVING, SERVED, PAYING, LEAVING }; // Forward declarations. class basket_t; class customer_t; class checkout_t; class shop_t; // The basket class is used to hold a customer's items. // For the sake of brevity, the basket simply contains // the count of items. A complete implementation would // embed a sequence container. class basket_t { public: // construction basket_t () // default ctor : m_count (0) {} basket_t (const basket_t&) =delete; // copy ctor basket_t& operator= (const basket_t&) =delete; // copy assign basket_t (basket_t&& other) // move ctor : m_count (other.m_count) {} basket_t& operator= (basket_t&&) =delete; // move assign public: // accessors unsigned int items () { return m_count; } const unsigned int items () const { return m_count; } public: //operations unsigned int add (); bool remove (); private: // attributes unsigned int m_count; // no. of items }; // Removes an item from the basket. // Returns true if an item was removed. bool basket_t::remove() { // Do not remove when the count is zero! if (m_count) { --m_count; return true; } return false; } // Adds an item to the basket (or not!) // Returns the current count of items. unsigned int basket_t::add() { if (dist2 (eng) == 1U) ++m_count; return m_count; } // Overload: inserts the given basket into the given output stream. std::ostream& operator<< (std::ostream& os, const basket_t& basket) { os << "Basket contains " << basket.items() << " items. "; return os; } // The customer class maintains a record of each customer from // the time they enter the shop to the time they leave. Each // customer is identifed by an ID number. The customer's status // determines the actions he/she may perform whilst in the shop. // For the sake of brevity, the only control a customer has is // to put items into their basket whilst in SHOPPING mode. The // customer will be assigned a random number of purchases to // make and will continue shopping until their basket is full // at which point they will automatically enter QUEUEING mode. // All other modes are determined by the shop. For instance, // if a customer enters the store but doesn't put anything in // their basket before the shop closes, the shop will ask them // to leave. However, if they have one or more items in their // basket they will be directed to the checkout instead, even if // they still have other purchases to make. Once queued, the // checkout controls their actions until they have paid for // their items, at which point the shop regains control and // asks that they leave the shop. It's a bit Draconian but // keeps things simple. class customer_t { public: // construction customer_t () // default ctor : m_id (++sid) , m_status (ENTERING) , m_basket () , m_desired (dist1 (eng)) // 1 to 5 items! , m_purchases (0) {} customer_t (const customer_t&) =delete; // copy ctor customer_t& operator= (const customer_t&) =delete; // copy assign customer_t (customer_t&& other) // move ctor : m_id (other.m_id) , m_status (other.m_status) , m_basket (std::move (other.m_basket)) , m_desired (std::move (other.m_desired)) , m_purchases (other.m_purchases) {} customer_t& operator= (customer_t&&) =delete; // move assign public: // accessors unsigned int id () const { return m_id; } unsigned int& purchases() { return m_purchases; } const unsigned int& purchases() const { return m_purchases; } basket_t& basket() { return m_basket; } const basket_t& basket() const { return m_basket; } const status_t& status () const { return m_status; } void status (status_t new_status) { m_status=new_status; } public: // operations void refresh (); bool shopping() { return basket().add() != m_desired; } bool serving() { return basket().remove(); } private: // attributes unsigned int m_id; status_t m_status; basket_t m_basket; unsigned int m_desired; // no. of purchases desired (range: 1 to 10 inclusive). unsigned int m_purchases; // no. of purchases made. static unsigned int sid; }; // Customers have no control over anything except whilst // in SHOPPING mode. When their basket has the desired // count of items, they will automatically enter QUEUEING // mode. The shop will then direct them to the checkout. void customer_t::refresh() { if (m_status==SHOPPING) if (!shopping()) // Returns true until the basket is full. m_status = QUEUEING; } // static id initialiser unsigned int customer_t::sid = 0; // Overload: inserts the given customer into the given output stream. std::ostream& operator<< (std::ostream& os, const customer_t& customer) { os << "\t\tCustomer " << customer.id(); switch (customer.status()) { case ENTERING: os << " is entering the shop. "; break; case SHOPPING: os << " is shopping. " << customer.basket(); break; case QUEUEING: os << " is heading for the checkout. "; break; case QUEUED: os << " is waiting to be served. "; break; case SERVING: os << " is being served. "; if (unsigned int purchases = customer.purchases()) { os << "\n\t\t\tThe server has processed " << purchases; os << " item" << (purchases==1?". ":"s."); } break; case SERVED: os << " has been served. "; break; case PAYING: os << " is paying for " << customer.purchases(); os << " item" << (customer.purchases()==1?". ":"s. "); break; case LEAVING: os << " is leaving the shop. "; break; } return os; } // The checkout class controls the queue of customers. // The queue is essentially a subset of all customers // in the shop. As such it holds pointers to those // customers rather than the actual customers. class checkout_t { public: // typedefs using queue_t = std::queue<customer_t*>; public: // construction checkout_t (): m_queue () {} checkout_t (const checkout_t&) =delete; checkout_t& operator= (const checkout_t&) =delete; checkout_t (checkout_t&&) =delete; checkout_t& operator= (checkout_t&&) =delete; public: // accessors queue_t& queue () { return m_queue; } const queue_t& queue () const { return m_queue; } public: // operations void refresh (); private: // attributes queue_t m_queue; }; // Each time refresh is called, the queue size is checked. // If it is not empty, the customer at the front of the // queue if processed according to their current status. // In most cases the customer's status will simply be // moved from one mode to the next, ready for the next // refresh. So if the customer is currently QUEUED, they // move to SERVING. If they are already in SERVING mode, // one item is removed from their basket and added to their // purchases unless the basket is already empty in which // case the customer moves to SERVED mode (they remin in // SERVING mode while there are still items in the basket). // If they are already in SERVED mode they move to PAYING // mode. If they are already in PAYING mode they are moved // to LEAVING mode at which point they are popped from the // queue. void checkout_t::refresh () { if (!queue().empty()) { customer_t& customer = *queue().front(); switch (customer.status()) { case QUEUED: customer.status (SERVING); break; case SERVING: if (customer.serving()) ++customer.purchases(); else customer.status(SERVED); break; case SERVED: customer.status(PAYING); break; case PAYING: customer.status(LEAVING); queue().pop(); break; } } } // Overload: inserts the given checkout into the given output stream. std::ostream& operator<< (std::ostream& os, const checkout_t& checkout) { unsigned customers = checkout.queue().size(); os << "\n\tThere " << (customers==1U?"is ":"are "); if (!customers) os << "no"; else os << customers; os << " customer" << (customers==1U?"":"s") << " at the checkout. "; return os; } // The shop class maintains a list of all customers in the shop, // including those at the checkout. The shop has no control over // customers who at the checkout (QUEUED, SERVING, SERVED or PAYING // modes). Customer's who are in SHOPPING mode are also not controlled // unless the shop has closed, at which point they are either moved // to QUEUEING mode or they are moved to LEAVING mode if their baskets // are currently empty. When a customer enters the store they are // automatically assigned ENTERING mode and at the next refresh will // move to SHOPPING mode, where they remain until their basket is filled // or the shop closes. If they are in queuing mode, the are pushed onto // the checkout queue. When they leave the queue they will have LEAVING // status at which point they are removed from the list. class shop_t { public: // typedefs using customers_t = std::list<customer_t>; using iterator = customers_t::iterator; using const_iterator = customers_t::const_iterator; public: // construction shop_t (unsigned int open_minutes=60U, unsigned int closing_minutes=5U) : m_checkout() , m_customers() , m_timer (open_minutes*60U) //convert to seconds - beware of underflow! , m_closing (closing_minutes*60U) { if (m_timer <= m_closing) throw std::out_of_range ( "shop_t::shop_t(const unsigned int, const unsigned int): " "Parameter 2 is invalid! Must be less than parameter 1."); } shop_t (const shop_t&) =delete; // copy ctor shop_t& operator= (const shop_t&) =delete; // copy assign shop_t (shop_t&&) =delete; // move ctor shop_t& operator= (shop_t&&) =delete; // move assign public: // accessors customers_t& customers() { return m_customers; } const customers_t& customers() const { return m_customers; } checkout_t& checkout () { return m_checkout; } const checkout_t& checkout () const { return m_checkout; } const_iterator leave_it () const; unsigned int time_remaining() const { return m_timer; } bool is_closing() const { return m_timer<m_closing; } bool is_closed() const { return m_timer==0; } bool is_open() const { return m_timer!=0; } bool empty() const { return m_customers.empty(); } public: // operations bool add_customer (); void refresh (); private: // attributes checkout_t m_checkout; customers_t m_customers; unsigned int m_timer; // Time remaining, in seconds, before shop closes. unsigned int m_closing; // Closing time in seconds (must be less than m_timer). }; // Overload: Inserts the given shop into the given output stream. std::ostream& operator<< (std::ostream& os, const shop_t& shop) { os << "\nThe shop is "; if (shop.is_closed()) os << "closed. "; else { if (shop.is_closing()) os << "closing "; else os << "open "; os << "with " << shop.time_remaining() << " seconds remaining. "; } unsigned customers = shop.customers().size(); os << "\n\tThere " << (customers==1U?"is ":"are "); if (!customers) os << "no"; else os << customers; os << " customer" << (customers==1U?"":"s") << " in the shop. "; os << shop.checkout(); return os; } // There's a 1 in 5 chance a customer may enter the shop. bool shop_t::add_customer() { bool allow = (dist1 (eng) == 1U && !is_closing()); if (allow) customers().push_back (customer_t()); return allow; } // Returns a constant iterator to the first customer with the LEAVING status, // or end() if there are none. shop_t::const_iterator shop_t::leave_it () const { const_iterator it=customers().begin(); while (it!=customers().end() && it->status()!=LEAVING) ++it; return it; } // The shop refresh does most of the work. void shop_t::refresh() { // All customers who are LEAVING can be removed from the customer list. customers_t::const_iterator it = leave_it(); while (it!=customers().end()) { const customer_t& customer = *it; std::cout << customer << std::endl; customers().erase (it); it = leave_it(); } // Process all customers not currently at the checkout. for (customers_t::iterator it=customers().begin(); it!=customers().end(); ++it) { customer_t& customer = *it; std::cout << customer << std::endl; switch (customer.status()) { case ENTERING: if (is_open()) // OK -- allow customer into shop. customer.status (SHOPPING); else if (is_closing()) // Sorry. Try Tesco! customer.status (LEAVING); break; case SHOPPING: if (is_closing()) // The shop only controls shoppers at closing time. if (customer.basket().items()) customer.status (QUEUEING); else customer.status (LEAVING); break; case QUEUEING: // Direct customer to checkout. checkout().queue().push (&customer); customer.status (QUEUED); break; } customer.refresh(); } checkout().refresh(); // Tick, tock, tick, tock... if (m_timer) --m_timer; } int main() { // Open the shop for 5 minutes, with a 1 minute closing period. shop_t shop (5, 1); while (shop.is_open()) { shop.add_customer(); // 1 in 5 chance unless closing... shop.refresh(); std::cout << shop << std::endl; } unsigned int overtime = 0; // Do we have any shoppers at the checkout... while (!shop.empty()) { ++overtime; shop.refresh(); std::cout << shop << std::endl; } if (overtime) std::cout << "\nThe shop failed to close on time.\n" << "Overtime: " << overtime << " seconds.\n\n"; else std::cout << "\nThe shop closed on time!\n\n"; }
