home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / CPP / LINKLIST.ZIP / LINKLIST.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-11  |  4.1 KB  |  219 lines
  1. ///////////////////////////////////////////////////////
  2. //                                                   //
  3. //   Linked List Class Functions - Version 1.00      //
  4. //                                                   //
  5. //           By Kevin Campbell 22/7/95               //
  6. //                                                   //
  7. //                                                   //
  8. ///////////////////////////////////////////////////////
  9.  
  10. #include <string.h>
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13. #include <conio.h>
  14. #include <alloc.h>
  15. #include "linklist\linklist.h"
  16.  
  17. /*
  18. template <class DX>
  19. char linked_list<DX>::add(){
  20.   char far *tempstore;
  21.   DX *tempdata;
  22.   struct far linkinfo *nextlink;
  23.   struct far linkinfo *templink;
  24.  
  25.   if (tempdata=new DX[ammount]){
  26.     if (templink=(linkinfo *)malloc(sizeof(linkinfo))){
  27.       if (curr){ // curr exists and should be linked from
  28.  
  29.     // Preserve Structure
  30.  
  31.     nextlink=curr->link;
  32.  
  33.     templink->link=curr->link;
  34.     templink->oldlink=curr;
  35.  
  36.     nextlink->oldlink=templink;
  37.     curr->link=templink;
  38.  
  39.     templink->data=tempdata;
  40.  
  41.     //templink->size=ammount;
  42.  
  43.     curr=templink; // Set current Linked-List position to new struct
  44.  
  45.     curr_entry++;
  46.  
  47.     ///////////////////////////////////
  48.  
  49.       }else{
  50.     // Linked List does not exist
  51.     // Create new linked list structure
  52.     templink->link=NULL;
  53.     templink->oldlink=NULL;
  54.     templink->data=tempdata;
  55.     //templink->size=ammount;
  56.     curr=templink;
  57.     curr_entry++;
  58.       }
  59.       entries++;
  60.     }else{
  61.       delete tempdata;
  62.       return(0);
  63.     }
  64.     return(1);
  65.   }else{
  66.     // Allocation of tempdata failed
  67.     return(0);
  68.   }
  69. }
  70.  
  71. template <class DX>
  72. char linked_list<DX>::kill(void){
  73.   struct far linkinfo *templink;
  74.   struct far linkinfo *nextlink;
  75.   struct far linkinfo *oldlink;
  76.  
  77.   if(!(curr==NULL)){ // if curr exists
  78.  
  79.     // Detach and Rebuild Structure
  80.  
  81.     nextlink=curr->link;
  82.     oldlink=curr->oldlink;
  83.  
  84.     if(oldlink)oldlink->link=nextlink;
  85.     if(nextlink)nextlink->oldlink=oldlink;
  86.  
  87.     // Entry is now completely removed from structure
  88.  
  89.     templink=curr; // Store removed entry address for deallocation
  90.  
  91.     ///////////////////////////////////
  92.  
  93.     if ((curr->link==NULL)&(curr->oldlink==NULL)){
  94.       curr=NULL;
  95.       curr_entry=0;
  96.     }else{
  97.       if(!(curr->oldlink==NULL)){
  98.     curr=curr->oldlink;
  99.     curr_entry--;
  100.       }else{
  101.     curr=curr->link;
  102.       }
  103.     }
  104.  
  105.     delete (DX *)templink->data;
  106.     free(templink); // Deallocate memory and return to heap
  107.     entries--;
  108.  
  109.     return(1);
  110.  
  111.   }else{
  112.     return(0);
  113.   }
  114. }
  115.  
  116. template <class DX>
  117. char linked_list<DX>::get(void *info){
  118.   if(!(curr==NULL)){
  119.     if(memcpy(info,curr->data,sizeof(DX))){
  120.       return(1);
  121.     }else{
  122.       return(0);
  123.     }
  124.   }else{
  125.     //Linked list does not exist, return error
  126.     return(0);
  127.   }
  128. }
  129.  
  130. template <class DX>
  131. char linked_list<DX>::put(void *info){
  132.   if(!(curr==NULL)){
  133.     if(memcpy(curr->data,info,sizeof(DX))){
  134.       return(1);
  135.     }else{
  136.       return(0);
  137.     }
  138.   }else{
  139.     //Linked list does not exist, return error
  140.     return(0);
  141.   }
  142. }
  143.  
  144. template <class DX>
  145. char linked_list<DX>::last(){
  146.   if(curr){
  147.     if(curr->oldlink){
  148.       curr=curr->oldlink;
  149.       return(1);
  150.     }else{
  151.       return(0);
  152.     }
  153.   }else{
  154.     return(0);
  155.   }
  156. }
  157.  
  158. template <class DX>
  159. char linked_list<DX>::next(){
  160.   if(curr){
  161.     if(curr->link){
  162.       curr=curr->link;
  163.       return(1);
  164.     }else{
  165.       return(0);
  166.     }
  167.   }else{
  168.     return(0);
  169.   }
  170. }
  171.  
  172. template <class DX>
  173. char linked_list<DX>::rewind(){
  174.   if(curr){
  175.     while (last());
  176.     return(1);
  177.   }else{
  178.     return(0);
  179.   }
  180. }
  181.  
  182. template <class DX>
  183. char linked_list<DX>::fastforward(){
  184.   if(curr){
  185.     while (next());
  186.     return(1);
  187.   }else{
  188.     return(0);
  189.   }
  190. }
  191.  
  192. template <class DX>
  193. int linked_list<DX>::num(){
  194.   return(entries);
  195. }
  196.  
  197. template <class DX>
  198. DX *linked_list<DX>::addr(){
  199.   if(curr){
  200.     return(curr->data);
  201.   }else{
  202.     return(NULL);
  203.   }
  204. }
  205.  
  206. template <class DX>
  207. linked_list<DX>::linked_list(void){
  208.   entries=0;
  209.   curr=NULL;
  210.   data=NULL;
  211.   curr_entry=0;
  212. }
  213.  
  214. template <class DX>
  215. linked_list<DX>::~linked_list(void){
  216.   while(kill());
  217. }
  218. */
  219.