#include

using namespace std;

class BookRecord $\{$

public:

string title $=$ "NULL";

string author $=$ "NULL";

int num$\_$pages $=-1$;

int year$\_$published $=-1$;

bool is$\_$equiv$($BookRecord rhs$)\{$

if $(($title $==$ rhs$.$title$)$ && $($author $==$ rhs$.$author$)$ && $($num$\_$pages $==$ rhs$.$num$\_$pages$)$

&& $($year$\_$published $==$ rhs$.$year$\_$published$))\{$

return true;

$\}$

else $\{$

return false;

$\}$

$\}$

void display$()\{$

cout $<<$ "Author Name: $"<<$ author $<<$ endl;

cout $<<$ "Title: $"<<$ title $<<$ endl;

cout $<<$ "Pages: $"<<$ num$\_$pages $<<$ endl;

cout $<<$ "Year Published: $"<<$ year$\_$published $<<$ endl;

cout $<<$ endl;

$\}$

$\}$;

class Node $\{$

public:

BookRecord data;

Node$*$ next $=$ nullptr;

Node$*$ prev $=$ nullptr; $//$ New prev pointer for doubly linked list

$\}$;

class DoublyLinkedList $\{$

private:

Node$*$ head $=$ nullptr;

Node$*$ tail $=$ nullptr; $//$ Pointer to the last node for convenience

public:

void display$()$;

void display$\_$reverse$()$;

void insertHead$($BookRecord val$)$;

void insertEnd$($BookRecord val$)$;

void insertAt$($BookRecord val, int pos$)$;

void deleteHead$()$;

void deleteEnd$()$;

void deleteAt$($int pos$)$;

int size$()$;

DoublyLinkedList$()$;

DoublyLinkedList$($BookRecord vals$[],$ int num$\_$vals$)$;

DoublyLinkedList$($const DoublyLinkedList& orig$)$;

~DoublyLinkedList$()$;

$\}$;

$//$ Definitions

void DoublyLinkedList::insertHead$($BookRecord val$)\{$

Node$*$ new$\_$node $=$ new Node$()$;

newNode $->$data $=$ val;

if$(!$head$)$

head $=$ new Node$()$;

head$->$data$=$val;

$\}$

$\}$

void DoublyLinkedList::display$()\{$

Node$*$ temp $=$ head;

while $()\{$

$\}$

$\}$

void DoublyLinkedList::display$\_$reverse$()\{$

$\}$

void DoublyLinkedList::insertEnd$($BookRecord val$)\{$

$\}$

void DoublyLinkedList::insertAt$($BookRecord val, int pos$)\{$

$\}$

void DoublyLinkedList::deleteHead$()\{$

$\}$

void DoublyLinkedList::deleteEnd$()\{$

$\}$

void DoublyLinkedList::deleteAt$($int pos$)\{$

$\}$

int DoublyLinkedList::size$()\{$

return $-1$;

$\}$

DoublyLinkedList::DoublyLinkedList$()\{$

cout $<<$ "Calling default constructor." $<<$ endl;

$\}$

DoublyLinkedList::DoublyLinkedList$($BookRecord vals$[],$ int num$\_$vals$)\{$

cout $<<$ "Calling parameterized constructor!" $<<$ endl;

$\}$

DoublyLinkedList::DoublyLinkedList$($const DoublyLinkedList& orig$)\{$

cout $<<$ "Executing copy constructor for DoublyLinkedList!" $<<$ endl;

$\}$

DoublyLinkedList::~DoublyLinkedList$()\{$

cout $<<$ "Executing Destructor for DoublyLinkedList!" $<<$ endl;

$\}$

void foo$($DoublyLinkedList lst$)\{$

lst$.$display$()$;

cout $<<$ endl;

$\}$

int main$()\{$

BookRecord book$1,$ book$2,$ book$3,$ book$4$;

book$1.$title $=$ "Digital Design and Computer Architecture";

book$1.$num$\_$pages $=720$;

book$1.$year$\_$published $=2012$;

book$1.$author $=$ "David Harris";

book$2.$title $=$ "A Game of Thrones";

book$2.$num$\_$pages $=496$;

book$2.$year$\_$published $=1996$;

book$2.$author $=$ "George R$.$ R$.$ Martin";

book$3.$title $=$ "Thrawn $($Star Wars$)"$;

book$3.$num$\_$pages $=835$;

book$3.$year$\_$published $=2018$;

book$3.$author $=$ "Timothy Zahn";

book$4.$title $=$ "The C$++$ Programming Language";

book$4.$num$\_$pages $=1376$;

book$4.$year$\_$published $=2013$;

book$4.$author $=$ "Bjarne Stroustrup";

DoublyLinkedList list$1$;

cout $<<"=========$Testing insertHead$()=========="<<$ endl;

list$1.$insertHead$($book$1)$;

list$1.$insertHead$($book$2)$;

list$1.$insertHead$($book$3)$;

list$1.$insertHead$($book$4)$;

list$1.$display$()$;

cout $<<"=========$Testing display$\_$reverse$()=========="<<$ endl;

list$1.$display$\_$reverse$()$;

cout $<<"=========$Testing insertEnd$()=========="<<$ endl;

list$1.$insertEnd$($book$1)$;

list$1.$insertEnd$($book$2)$;

list$1.$insertEnd$($book$3)$;

list$1.$display$()$;

cout $<<"=========$Testing deleteHead$()=========="<<$ endl;

list$1.$deleteHead$()$;

list$1.$display$()$;

cout $<<"=========$Testing size$()=========="<<$ endl;

list$1.$display$()$;

cout $<<$ "There are $"<<$ list$1.$size$()<<"$ elements in the linked list." $<<$ endl;

cout $<<"=========$Testing parameterized constructor.$=========="<<$ endl;

BookRecord vals$[4]=\{$ book$1,$ book$2,$ book$3,$ book$4\}$;

DoublyLinkedList list$2($vals$,4)$;

list$2.$display$()$;

cout $<<"=========$Testing copy constructor.$=========="<<$ endl;

foo$($list$2)$;

cout $<<"=========$Testing insertAt$()=========="<<$ endl;

list$1.$insertAt$($book$3,3)$;

list$1.$display$()$;

cout $<<"=========$Testing deleteEnd$()=========="<<$ endl;

list$1.$deleteEnd$()$;

list$1.$display$()$;

cout $<<"=========$Testing deleteAt$()=========="<<$ endl;

list$1.$deleteAt$(1)$;

list$1.$display$()$;

return $0$;

$\}$