Update copyright to LGPL on all files
[dyninst.git] / depGraphAPI / src / DDGIterator.h
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 // Implementations of Node iterators
33
34 #if !defined(DDG_ITERATOR_H)
35 #define DDG_ITERATOR_H
36
37 #include "Node.h"
38 #include "DepGraphNode.h"
39
40
41 namespace Dyninst {
42
43 namespace DepGraphAPI {
44
45 class FormalParamSetIter : public NodeIteratorImpl {
46  public:
47     virtual void inc() { ++internal_; }
48     virtual void dec() { --internal_; }
49     virtual Node::Ptr get() { return *internal_; }
50     virtual bool equals(NodeIteratorImpl *rhs) {
51         FormalParamSetIter *tmp = dynamic_cast<FormalParamSetIter *>(rhs);
52         if (tmp == NULL) return false;
53         return internal_ == tmp->internal_;
54     }
55
56     virtual NodeIteratorImpl *copy() {
57         NodeIteratorImpl *tmp = new FormalParamSetIter(internal_);
58         return tmp;
59     }
60
61     virtual ~FormalParamSetIter() {
62         // Nothing to do
63     }
64     
65     FormalParamSetIter(const std::set<FormalParamNode::Ptr>::iterator iter) : internal_(iter) {};
66
67  private:
68     std::set<FormalParamNode::Ptr>::iterator internal_;
69 };
70
71 class FormalReturnSetIter : public NodeIteratorImpl {
72  public:
73     virtual void inc() { ++internal_; }
74     virtual void dec() { --internal_; }
75     virtual Node::Ptr get() { return *internal_; }
76     virtual bool equals(NodeIteratorImpl *rhs) {
77         FormalReturnSetIter *tmp = dynamic_cast<FormalReturnSetIter *>(rhs);
78         if (tmp == NULL) return false;
79         return internal_ == tmp->internal_;
80     }
81
82     virtual NodeIteratorImpl *copy() {
83         return new FormalReturnSetIter(internal_);
84     }
85
86     virtual ~FormalReturnSetIter() {
87         // Nothing to do
88     }
89     
90     FormalReturnSetIter(const std::set<FormalReturnNode::Ptr>::iterator iter) : internal_(iter) {};
91
92  private:
93     std::set<FormalReturnNode::Ptr>::iterator internal_;
94 };
95
96 class DDGEntryIter : public NodeIteratorImpl {
97  public:
98     virtual void inc() {
99         if (paramsCur_ == paramsEnd_) {
100             assert(virtualsCur_ != virtualsEnd_);
101             ++virtualsCur_;
102         }
103         else {
104             ++paramsCur_;
105         }
106     }
107     virtual void dec() {
108         if (virtualsCur_ == virtualsBegin_) {
109             assert(paramsCur_ != paramsBegin_); 
110             --paramsCur_;
111         }
112         else {
113             --virtualsCur_;
114         }
115     }
116             
117     virtual Node::Ptr get() {
118         if (paramsCur_ == paramsEnd_) {
119             assert(virtualsCur_ != virtualsEnd_);
120             return *virtualsCur_;
121         }
122         else {
123             return *paramsCur_;
124         }
125     }
126
127     virtual bool equals(NodeIteratorImpl *rhs) {
128         DDGEntryIter *tmp = dynamic_cast<DDGEntryIter *>(rhs);
129         if (tmp == NULL) return false;
130         
131         return ((paramsBegin_ == tmp->paramsBegin_) &&
132                 (paramsCur_ == tmp->paramsCur_) &&
133                 (paramsEnd_ == tmp->paramsEnd_) &&
134                 (virtualsBegin_ == tmp->virtualsBegin_) &&
135                 (virtualsCur_ == tmp->virtualsCur_) &&
136                 (virtualsEnd_ == tmp->virtualsEnd_));
137     }
138     
139     virtual NodeIteratorImpl *copy() {
140         NodeIteratorImpl *tmp =  new DDGEntryIter(paramsBegin_, paramsCur_, paramsEnd_,
141                                                   virtualsBegin_, virtualsCur_, virtualsEnd_);
142         return tmp;
143     }
144     
145     virtual ~DDGEntryIter() {
146         // Nothing to do
147     }
148     
149     DDGEntryIter(NodeIterator &paramsBegin, 
150                  NodeIterator &paramsCur, 
151                  NodeIterator &paramsEnd,
152                  NodeIterator &virtualsBegin, 
153                  NodeIterator &virtualsCur, 
154                  NodeIterator &virtualsEnd) :
155         paramsBegin_(paramsBegin),
156         paramsCur_(paramsCur),
157         paramsEnd_(paramsEnd),
158         virtualsBegin_(virtualsBegin),
159         virtualsCur_(virtualsCur),
160         virtualsEnd_(virtualsEnd)
161         {};
162
163  private:
164     // The set of parameter nodes...
165     NodeIterator paramsBegin_;
166     NodeIterator paramsCur_;
167     NodeIterator paramsEnd_;
168
169     // The next thing we want is the children (if any)
170     // of the virtual node. That's, amusingly, a NodeIterator
171     // over virtualNode.outs...
172     NodeIterator virtualsBegin_;
173     NodeIterator virtualsCur_;
174     NodeIterator virtualsEnd_;
175 };
176
177
178 class DDGExitIter : public NodeIteratorImpl {
179  public:
180     virtual void inc() {
181         if (returnsCur_ == returnsEnd_) {
182             assert(virtualsCur_ != virtualsEnd_);
183             ++virtualsCur_;
184         }
185         else {
186             ++returnsCur_;
187         }
188     }
189     virtual void dec() {
190         if (virtualsCur_ == virtualsBegin_) {
191             assert(returnsCur_ != returnsBegin_); 
192             --returnsCur_;
193         }
194         else {
195             --virtualsCur_;
196         }
197     }
198             
199     virtual Node::Ptr get() {
200         if (returnsCur_ == returnsEnd_) {
201             assert(virtualsCur_ != virtualsEnd_);
202             return *virtualsCur_;
203         }
204         else {
205             return *returnsCur_;
206         }
207     }
208
209     virtual bool equals(NodeIteratorImpl *rhs) {
210         DDGExitIter *tmp = dynamic_cast<DDGExitIter *>(rhs);
211         if (tmp == NULL) return false;
212         
213         return ((returnsBegin_ == tmp->returnsBegin_) &&
214                 (returnsCur_ == tmp->returnsCur_) &&
215                 (returnsEnd_ == tmp->returnsEnd_) &&
216                 (virtualsBegin_ == tmp->virtualsBegin_) &&
217                 (virtualsCur_ == tmp->virtualsCur_) &&
218                 (virtualsEnd_ == tmp->virtualsEnd_));
219     }
220     
221     virtual NodeIteratorImpl *copy() {
222         NodeIteratorImpl *tmp =  new DDGExitIter(returnsBegin_, returnsCur_, returnsEnd_,
223                                                   virtualsBegin_, virtualsCur_, virtualsEnd_);
224         return tmp;
225     }
226     
227     virtual ~DDGExitIter() {
228         // Nothing to do
229     }
230     
231     DDGExitIter(NodeIterator &returnsBegin, 
232                  NodeIterator &returnsCur, 
233                  NodeIterator &returnsEnd,
234                  NodeIterator &virtualsBegin, 
235                  NodeIterator &virtualsCur, 
236                  NodeIterator &virtualsEnd) :
237         returnsBegin_(returnsBegin),
238         returnsCur_(returnsCur),
239         returnsEnd_(returnsEnd),
240         virtualsBegin_(virtualsBegin),
241         virtualsCur_(virtualsCur),
242         virtualsEnd_(virtualsEnd)
243         {};
244
245  private:
246     // The set of parameter nodes...
247     NodeIterator returnsBegin_;
248     NodeIterator returnsCur_;
249     NodeIterator returnsEnd_;
250
251     // The next thing we want is the children (if any)
252     // of the virtual node. That's, amusingly, a NodeIterator
253     // over virtualNode.outs...
254     NodeIterator virtualsBegin_;
255     NodeIterator virtualsCur_;
256     NodeIterator virtualsEnd_;
257 };
258
259 }
260 }
261
262
263 #endif