Initial implementation of iterators (NodeIterator and EdgeIterator) for Graph and...
[dyninst.git] / depGraphAPI / src / DDGIterator.h
1 /*
2  * Copyright (c) 2007-2008 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             ++virtualsCur_;
101         }
102         else {
103             ++paramsCur_;
104         }
105     }
106     virtual void dec() {
107         if (virtualsCur_ == virtualsBegin_) {
108             --paramsCur_;
109         }
110         else {
111             --virtualsCur_;
112         }
113     }
114             
115     virtual Node::Ptr get() {
116         if (paramsCur_ == paramsEnd_) {
117             return *virtualsCur_;
118         }
119         else {
120             return *paramsCur_;
121         }
122     }
123
124     virtual bool equals(NodeIteratorImpl *rhs) {
125         DDGEntryIter *tmp = dynamic_cast<DDGEntryIter *>(rhs);
126         if (tmp == NULL) return false;
127         
128         return ((paramsCur_ == tmp->paramsCur_) &&
129                 (paramsEnd_ == tmp->paramsEnd_) &&
130                 (virtualsBegin_ == tmp->virtualsBegin_) &&
131                 (virtualsCur_ == tmp->virtualsCur_));
132     }
133
134     virtual NodeIteratorImpl *copy() {
135         NodeIteratorImpl *tmp =  new DDGEntryIter(paramsCur_, paramsEnd_,
136                                                   virtualsBegin_, virtualsCur_);
137         return tmp;
138     }
139     
140     virtual ~DDGEntryIter() {
141         // Nothing to do
142     }
143     
144     DDGEntryIter(NodeIterator &paramsCur, NodeIterator &paramsEnd,
145                  NodeIterator &virtualsBegin, NodeIterator &virtualsCur) :
146         paramsCur_(paramsCur),
147         paramsEnd_(paramsEnd),
148         virtualsBegin_(virtualsBegin),
149         virtualsCur_(virtualsCur) {};
150
151  private:
152     // The set of parameter nodes...
153     NodeIterator paramsCur_;
154     NodeIterator paramsEnd_;
155
156     // The next thing we want is the children (if any)
157     // of the virtual node. That's, amusingly, a NodeIterator
158     // over virtualNode.outs...
159     NodeIterator virtualsBegin_;
160     NodeIterator virtualsCur_;
161 };
162
163 }
164 }
165
166
167 #endif