← Back to branch summary

~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to src/kernel/mesh/dolfin/EdgeIterator.h

  • Committer: Anders Logg
  • Date: 2007-01-10 09:04:44 UTC
  • mfrom: (1689.1.221 trunk)
  • Revision ID: logg@simula.no-20070110090444-ecyux3n1qnei4i8h
Remove old head

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kernel/mesh/dolfin/EdgeIterator.h
1
 
// Copyright (C) 2003-2005 Johan Hoffman and Anders Logg.
2
 
// Licensed under the GNU GPL Version 2.
3
 
//
4
 
// Modified by Garth N. Wells 2005.
5
 
//
6
 
// First added:  2003
7
 
// Last changed: 2005-12-01
8
 
 
9
 
#ifndef __EDGE_ITERATOR_H
10
 
#define __EDGE_ITERATOR_H
11
 
 
12
 
#include <dolfin/PArray.h>
13
 
#include <dolfin/PList.h>
14
 
#include <dolfin/Table.h>
15
 
 
16
 
namespace dolfin
17
 
{
18
 
  
19
 
  class Mesh;
20
 
  class Vertex;
21
 
  class Cell;
22
 
  class Edge;
23
 
  class Face;
24
 
  class Boundary;
25
 
  class VertexIterator;
26
 
  class CellIterator;
27
 
  class FaceIterator;
28
 
  class GenericCell;
29
 
 
30
 
  typedef Edge* EdgePointer;
31
 
  
32
 
  class EdgeIterator
33
 
  {
34
 
  public:
35
 
         
36
 
    EdgeIterator(const Mesh& mesh);
37
 
    EdgeIterator(const Mesh* mesh);
38
 
 
39
 
    EdgeIterator(const Boundary& boundary);
40
 
    EdgeIterator(const Boundary* boundary);
41
 
 
42
 
    EdgeIterator(const Vertex& vertex);
43
 
    EdgeIterator(const VertexIterator& vertexIterator);
44
 
 
45
 
    EdgeIterator(const Cell& cell);
46
 
    EdgeIterator(const CellIterator& cellIterator);
47
 
 
48
 
    EdgeIterator(const Face& face);
49
 
    EdgeIterator(const FaceIterator& faceIterator);
50
 
         
51
 
    ~EdgeIterator();
52
 
 
53
 
    operator EdgePointer() const;
54
 
        
55
 
    EdgeIterator& operator++();
56
 
    bool end();
57
 
    bool last();
58
 
    int index();
59
 
         
60
 
    Edge& operator*() const;
61
 
    Edge* operator->() const;
62
 
    bool  operator==(const EdgeIterator& n) const;
63
 
    bool  operator!=(const EdgeIterator& n) const;
64
 
         
65
 
    // Base class for edge iterators
66
 
    class GenericEdgeIterator {
67
 
    public:
68
 
                
69
 
      virtual void operator++() = 0;
70
 
      virtual bool end() = 0;
71
 
      virtual bool last() = 0;
72
 
      virtual int index() = 0;
73
 
 
74
 
      virtual ~GenericEdgeIterator() {};
75
 
                
76
 
      virtual Edge& operator*() const = 0;
77
 
      virtual Edge* operator->() const = 0;
78
 
      virtual Edge* pointer() const = 0;
79
 
                
80
 
    };
81
 
         
82
 
    // Iterator for the edges in a mesh
83
 
    class MeshEdgeIterator : public GenericEdgeIterator {
84
 
    public:
85
 
                
86
 
      MeshEdgeIterator(const Mesh& mesh); 
87
 
                
88
 
      void operator++();
89
 
      bool end();
90
 
      bool last();
91
 
      int index();
92
 
                
93
 
      Edge& operator*() const;
94
 
      Edge* operator->() const;
95
 
      Edge* pointer() const;
96
 
 
97
 
      Table<Edge>::Iterator edge_iterator;
98
 
      Table<Edge>::Iterator at_end;
99
 
                
100
 
    };
101
 
 
102
 
    // Iterator for the edges on a boundary
103
 
    class BoundaryEdgeIterator : public GenericEdgeIterator {
104
 
    public:
105
 
 
106
 
      BoundaryEdgeIterator(const Boundary& boundary);
107
 
      void operator++();
108
 
      bool end();
109
 
      bool last();
110
 
      int index();
111
 
 
112
 
      Edge& operator*() const;
113
 
      Edge* operator->() const;
114
 
      Edge* pointer() const;
115
 
                
116
 
    private:
117
 
 
118
 
      PList<Edge*>::Iterator edge_iterator;
119
 
      
120
 
    };
121
 
 
122
 
    // Iterator for the edges at a vertex 
123
 
    class VertexEdgeIterator : public GenericEdgeIterator {
124
 
    public:
125
 
 
126
 
      VertexEdgeIterator(const Vertex& vertex);
127
 
      void operator++();
128
 
      bool end();
129
 
      bool last();
130
 
      int index();
131
 
 
132
 
      Edge& operator*() const;
133
 
      Edge* operator->() const;
134
 
      Edge* pointer() const;
135
 
                
136
 
    private:
137
 
 
138
 
      PArray<Edge*>::Iterator edge_iterator;
139
 
                
140
 
    };
141
 
         
142
 
    // Iterator for the edges in a cell
143
 
    class CellEdgeIterator : public GenericEdgeIterator {
144
 
    public:
145
 
 
146
 
      CellEdgeIterator(const Cell& cell);
147
 
      void operator++();
148
 
      bool end();
149
 
      bool last();
150
 
      int index();
151
 
 
152
 
      Edge& operator*() const;
153
 
      Edge* operator->() const;
154
 
      Edge* pointer() const;
155
 
                
156
 
    private:
157
 
 
158
 
      PArray<Edge*>::Iterator edge_iterator;
159
 
 
160
 
    };
161
 
 
162
 
    // Iterator for the edges in a face
163
 
    class FaceEdgeIterator : public GenericEdgeIterator {
164
 
    public:
165
 
 
166
 
      FaceEdgeIterator(const Face& face);
167
 
      void operator++();
168
 
      bool end();
169
 
      bool last();
170
 
      int index();
171
 
 
172
 
      Edge& operator*() const;
173
 
      Edge* operator->() const;
174
 
      Edge* pointer() const;
175
 
                
176
 
    private:
177
 
 
178
 
      PArray<Edge*>::Iterator edge_iterator;
179
 
 
180
 
    };
181
 
         
182
 
  private:
183
 
 
184
 
    GenericEdgeIterator* e;
185
 
         
186
 
  };
187
 
 
188
 
}
189
 
 
190
 
#endif