//-------------------------------------------------------------------*--------*
// Test of PPF on the same doubly-linked list.
//     Jiri Soukup, Aug.10, 2004
//-------------------------------------------------------------------*--------*

#include <time.h>
#include <stdlib.h>
#include "d:\ppf\factory.h"

class ListNode {
  PersistClass (ListNode);
  friend class List;

    PersistPtr<ListNode> next;
    PersistPtr<ListNode> prev;
    int id;

  public:
    ListNode(){id= -1; next.setNull(); prev.setNull();}
    ListNode(int i){id=i; next.setNull(); prev.setNull();} 
    PersistPtr<ListNode> getNext(){return next;}
};

class List {
  PersistClass (List);

    PersistPtr<ListNode> tail;
    int count;

  public:
    List(){tail.setNull(); count=0;}
    PersistPtr<ListNode> getTail(){return tail;}
    PersistPtr<ListNode> getHead(){if(tail)return tail->next; return null;}
    void addTail(PersistPtr<ListNode> n){
        if(tail){
            n->next=tail->next;
            tail->next->prev=n;
            tail->next=n;
            n->prev=tail;
        }
        else { n->next=n->prev=n;}
        tail=n;
        count++;
    }
    int getCount(){return count;}
};

#include "d:\ppf\pointer.cpp"


#define ELAPSED int(time(NULL)-start)
#define RESET start=time(NULL)

int main(int argc,char **argv) {
    PersistPtr<List> root;
    PersistPtr<ListNode> n, tail;;
    FILE *fp;
    time_t start,start0;
    int i,NUM;

    if(argc!=2){
        printf("syntax: list numOfNodes\n");
        return 1;
    }
    NUM=atoi(argv[1]);

    printf("opening database ");
    RESET; start0=start;
   
    List::startPager(512,3,1000,0);  // define storage for persistent classes
    ListNode::startPager(512,10,200000000,0); // 512 B, 100 pages,200MB limit
       // note: using same page size as POST++
    PersistStart; // needed to synchronize classes

    root.getRoot();
    if(root){
        printf("%d sec\ncount=",ELAPSED);
        RESET;
        tail=root->getTail();
        for(n=root->getHead(), i=0; n; n=n->getNext()){
            i++;
            if(n==tail)break;
        }
        printf("%d in %d sec\n",i,ELAPSED);
        RESET;
    }
    else {
        printf("%d sec\ncreating list of %d nodes ",ELAPSED,NUM);
        root=new List();
        root.setRoot();

        for(i=0; i<NUM; i++){
            n=new ListNode();
            root->addTail(n);
        }
        printf("%d sec\n",ELAPSED);
        RESET;
            
        List::closePager();
        ListNode::closePager();
        printf("database closed %d sec\n",ELAPSED);
    }
    start=start0;
    printf("total time %d sec\n",ELAPSED);
    return 0;
}

PersistImplement(List);
PersistImplement(ListNode);