The key abstractions employed in this program are Inventory, Item, and ItemStack. Complete ADT implementations have been provided for the latter two.

The Inventory class is partially implemented. Your task is to complete the Inventory ADT. The code provided will not run correctly… until you complete all the following methods:

1. Copy Constructor
2. Destructor
3. Assignment Operator

   Note this is already provided and complete. Refer to our discussions of the copy-and-swap method.
   Once you have completed the Copy Constructor and Destructor, you are done with the Big-3.

4. Inventory::isFull – refer to documentation in Inventory.h.
5. Inventory::findMatchingItemStackNode – refer to documentation in Inventory.h.
6. Inventory::mergeStacks – refer to documentation in Inventory.h.
7. Inventory::addItemStackNoCheck – refer to documentation in Inventory.h.

The partial implementation provided assumes that each Inventory will keep track of items in a linked list. You must not change this choice of data structure… unless you want a zero.

Inventory.h
#ifndef INVENTORY_H_INCLUDED
#define INVENTORY_H_INCLUDED
#include
#include “ItemStack.h”
/**
* An Inventory is composed of n slots. Each slot may store only
* one type of item–specified by *slots*.
*

* Once all slots are filled, no additional Item types may be
* stored. Individual slots may contain any number of the same
* Item.
*/
class Inventory {
private:
/**
* Each Node represents on Inventory slot–i.e., space
*/
struct Node {
ItemStack data; ///< One ItemStack Node* next; ///< Next ItemStack Node /** * Create an empty *Air* Node */ Node(); /** * Create a Node that contains an ItemStack, *s* */ Node(ItemStack s); }; Node* head; ///< First inventory slot Node* tail; ///< Last inventory slot int slots; ///< Capacity int occupied; ///< Number of occupied slots public: /** * Default to 10 slots */ Inventory(); /** * Create an inventory with n slots * * @pre n > 0
*/
Inventory(int n);
/**
* Duplicate an existing Inventory
*/
Inventory(const Inventory& src);
/**
* Empty all Inventory slots.
*/
~Inventory();
/**
* Add one or more items to the inventory list
*
* @return true if *stack* was added and false otherwise
*/
bool addItems(ItemStack itemStack);
/**
* Check if this inventory is full
*
* @return (occupied < slots) // **technically a typo** */ bool isFull() const; /** * Print a Summary of the Inventory and all Items contained within */ void display(std::ostream& outs) const; /** * */ Inventory& operator=(Inventory rhs); /** * Swap the contents of two `Inventory`s * (Yes this should be spelled "ies"). However, we * need to recognize that Inventory is the type of both * `lhs` and `rhs` *

* I am using a friend function here and only here (under protest)
*

* [Refer here](http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom)
*/
friend
void swap(Inventory& lhs, Inventory& rhs);
private:
/**
* Find Node containing and ItemStack with a matching id
*
* @param itemStack ItemStack for which we want a match
*
* @return pointer to a Node containing a matching ItemStack
* or nullptr if no such Node exists
*/
Node* findMatchingItemStackNode(const ItemStack& itemStack);
/**
* Merge two item stacks.
*
* @param lhs item stack where items need to be `add`ed
* @param rhs item stack with the *number* of items to add
*
* @pre lhs.id == rhs.id
*/
void mergeStacks(ItemStack& lhs, const ItemStack& rhs);
/**
* Append a Node.
*

* This is the code we discussed in Review-01
* When this method is invoked all special cases
* have already been covered in `addItems`.
*

* Abstraction and Interfaces
*/
void addItemStackNoCheck(ItemStack itemStack);
};
//——————————————————————————
inline
bool Inventory::addItems(ItemStack itemStack)
{
Node* matchingNode = findMatchingItemStackNode(itemStack);
// A match was found
if(matchingNode != nullptr){
mergeStacks(matchingNode->data, itemStack);
return true;
}
// There is no space for a new type of `ItemStack`
if(this->isFull()) {
return false;
}
// This is a new type of item and there is plenty of room
addItemStackNoCheck(itemStack);
return true;
}
/**
* Print the Inventory through use of the display member function
*/
inline
std::ostream& operator<<(std::ostream& outs, const Inventory& prt) { prt.display(outs); return outs; } #endif Inventory.cpp #include
#include “Inventory.h”
// Allow the compiler to define the remaining
// comparison operators
using namespace std::rel_ops;
//——————————————————————————
Inventory::Node::Node()
:data(Item(0, “Air”), 0)
{
this->next = nullptr;
}
//——————————————————————————
Inventory::Node::Node(ItemStack s)
:data(s)
{
this->next = nullptr;
}
//——————————————————————————
Inventory::Inventory()
{
this->head = nullptr;
this->tail = nullptr;
this->slots = 10;
this->occupied = 0;
//std::cerr << Node().data << "\n"; } //------------------------------------------------------------------------------ Inventory::Inventory(int n) { this->head = nullptr;
this->tail = nullptr;
this->slots = n;
this->occupied = 0;
}
//——————————————————————————
Inventory::Inventory(const Inventory &src)
{
// @todo implement this function
}
//——————————————————————————
Inventory::~Inventory()
{
// @todo implement this function
}
//——————————————————————————
bool Inventory::isFull() const
{
// @todo implement this function
//
// If this is more than one line
// in the form “return (boolean expression);”
// you are overthinking the problem
return true; // This line is a placeholder. Remove it.
}
//——————————————————————————
void Inventory::display(std::ostream &outs) const
{
outs << " -Used " << occupied << " of " << slots << " slots" << "\n"; Node* it = head; while(it != nullptr){ outs << " " << it->data << "\n"; it = it->next;
}
}
//——————————————————————————
Inventory& Inventory::operator=(Inventory rhs)
{
std::swap(*this, rhs);
return *this;
}
//——————————————————————————
void swap(Inventory& lhs, Inventory& rhs)
{
using std::swap;
swap(lhs.head, rhs.head);
swap(lhs.tail, rhs.tail);
swap(lhs.slots, rhs.slots);
swap(lhs.occupied, rhs.occupied);
}
//——————————————————————————
Inventory::Node* Inventory::findMatchingItemStackNode(const ItemStack& itemStack)
{
// @todo implement this function
return nullptr;
}
//——————————————————————————
void Inventory::mergeStacks(ItemStack& lhs, const ItemStack& rhs)
{
// Update lhs… remember rhs is read only
}
//——————————————————————————
void Inventory::addItemStackNoCheck(ItemStack itemStack)
{
// @todo implement this function
}