Apache C++ Standard Library User's Guide

## 6.3 Example Program: An Inventory System

Let's use a simple inventory management system to illustrate the use of several list operations. Assume a business, named WorldWideWidgetWorks, requires a software system to manage their supply of widgets.

> NOTE -- The complete version of the widget works program is in file widwork.cpp.

Widgets are simple devices, distinguished by different identification numbers:

    class  Widget {
    public:
      Widget(int a = 0) : id(a) { }
      void operator=(const Widget& rhs) { id = rhs.id; }
      int id;
      friend std::ostream& operator<<
        (std::ostream& out, const Widget& w)
        { return out << "Widget " << w.id; }
    };

    bool operator== (const Widget& lhs, const Widget& rhs) {
      return lhs.id == rhs.id;
    }

    bool operator< (const Widget& lhs, const Widget& rhs) {
      return lhs.id < rhs.id;
    }

The state of the inventory is represented by two lists: a list of widgets represents the stock of widgets on hand, and a list of widget identification types represents the type of widgets that customers have backordered.

    typedef std::list<Widget, std::allocator<Widget> > widgetList;
    typedef std::list<int, std::allocator<int> >       idList;

To handle our inventory we have two commands: `order()` processes orders, and `receive()` processes the shipment of a new widget.

    class inventory {
    public:
      void order (int wid);   // process order for widget type wid
      void receive (int wid); // receive widget of type wid
                              // in shipment
    private:
      widgetList on_hand;
      idList     on_order;
    };

When a new widget arrives in shipment, we compare the widget identification number with the list of widget types on backorder. We use `find()` to search the backorder list, immediately shipping the widget if necessary. Otherwise it is added to the stock on hand:

    void inventory::receive (int wid) {
      std::cout << "Received shipment of widget type "
                << wid << std::endl;

      idList::iterator weneed =
        find(on_order.begin(), on_order.end(), wid);

      if (weneed != on_order.end()) {
        std::cout << "Ship " << Widget(wid)
                  << " to fill back order" << std::endl;
        on_order.erase(weneed);
      }
      else
        on_hand.push_front(Widget(wid));
    }

When a customer orders a new widget, we scan the list of widgets in stock to determine if the order can be processed immediately. We can use the standard algorithm `std::find_if()` to search the list. To do so, we need a binary function that takes as its argument a widget and determines whether the widget matches the type requested. We create this function by taking a general binary widget-testing function, and binding the second argument to the specific widget type. To use the function `std::bind2nd()`, however, requires that the binary function be an instance of the class binary_function. The general widget-testing function is written as follows:

    struct WidgetTester : std::binary_function<Widget, int, bool> {

    public:
      bool operator()(const Widget& wid, int testid) const
      {
        return wid.id == testid;
      }

    };

The widget order function is then written as follows:

    void inventory::order(int wid) {

      std::cout << "Received order for widget type " << wid
                << std::endl;

      widgetList::iterator wehave =
        std::find_if(on_hand.begin(), on_hand.end(),
                     std::bind2nd(WidgetTester(), wid));

        if (wehave != on_hand.end()) {
          std::cout << "Ship " << *wehave << std::endl;
          on_hand.erase(wehave);
       }
       else {
         std::cout << "Back order widget of type "  << wid
                   << std::endl;
         on_order.push_front(wid);
       }

    }