Update copyright to LGPL on all files
[dyninst.git] / common / src / List.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 // $Id: list.C,v
33
34 #include <ostream>
35 #include "common/h/List.h"
36
37 using namespace std;
38
39 template <class DataType, class KeyType> DO_INLINE_F typename 
40 ListBase<DataType, KeyType>::node *ListBase<DataType, KeyType>::getLastNode()
41 {
42   node *lag = NULL;
43   node *curNode = head;
44   while(1) {
45     if(curNode == NULL) break;
46     lag = curNode;
47     curNode = curNode->next;
48   }
49   return lag;
50 }
51
52 template <class DataType, class KeyType> void 
53 ListBase<DataType, KeyType>::__push_front(DataType &data, 
54                                           const KeyType &key)
55 {
56    typename ListBase<DataType, KeyType>::node *ni = new node(data, key, head);
57    head = ni;
58 }
59
60
61 template <class DataType, class KeyType> 
62 void ListBase<DataType, KeyType>::__push_back(DataType &data, 
63                                               const KeyType &key)
64 {
65    node *newNode = new node(data, key, NULL);
66
67    if(! isEmpty()) {
68      node *lastNode = getLastNode();
69      lastNode->next = newNode;
70    } else {
71      head = newNode;
72    }
73 }
74
75 template <class DataType, class KeyType>
76 void ListBase<DataType, KeyType>::clear()
77 {
78   node *curr, *nx;
79
80   curr = head;
81   while (curr) {
82     nx = curr->next;
83     delete (curr);
84     curr = nx;
85   }
86   head = NULL;
87 }
88
89 template <class DataType, class KeyType>
90 bool ListBase<DataType, KeyType>::__remove_with_val(const DataType &dataVal)
91 {
92     node *lag;
93     node *curr;
94
95     for (curr=head, lag = NULL; curr; curr=curr->next) {
96         if (curr->data == dataVal) {
97             break;
98         }
99         lag = curr;
100     }
101
102     if (curr) {
103         if (lag) {
104             lag->next = curr->next;
105         } else {
106             head = curr->next;
107         }
108         delete(curr);
109         return(true);
110     } else {
111         return(false);
112     }
113 }
114
115 template <class DataType, class KeyType>
116 bool ListBase<DataType, KeyType>::__remove_with_key(const KeyType &key)
117 {
118     node *lag;
119     node *curr;
120
121     for (curr=head, lag = NULL; curr; curr=curr->next) {
122         if (curr->key == key) {
123             break;
124         }
125         lag = curr;
126     }
127
128     if (curr) {
129         if (lag) {
130             lag->next = curr->next;
131         } else {
132             head = curr->next;
133         }
134         delete(curr);
135         return(true);
136     } else {
137         return(false);
138     }
139 }
140
141 template <class DataType, class KeyType>
142 bool ListBase<DataType, KeyType>::__find_with_key(const KeyType &key, 
143                                                   DataType *saveVal)
144 {
145    node *curr;
146
147    for (curr=head; curr; curr=curr->next) {
148       if (curr->key == key) {
149          (*saveVal) = curr->data;
150          return true;
151       }
152    }
153    return false;
154 }
155
156 template <class DataType, class KeyType>
157 bool ListBase<DataType, KeyType>::__find_with_val(const DataType &dataVal)
158   const {
159    node *curr;
160
161    for (curr=head; curr; curr=curr->next) {
162       if (curr->data == dataVal) {
163          return true;
164       }
165    }
166    return false;
167 }
168
169