InDesign SDK  20.5
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
IDXMLDOMGraph.h
1 //========================================================================================
2 //
3 // $File$
4 //
5 // Owner: Will Lin
6 //
7 // $Author$
8 //
9 // $DateTime$
10 //
11 // $Revision$
12 //
13 // $Change$
14 //
15 // Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
16 //
17 // NOTICE: Adobe permits you to use, modify, and distribute this file in accordance
18 // with the terms of the Adobe license agreement accompanying it. If you have received
19 // this file from a source other than Adobe, then your use, modification, or
20 // distribution of it requires the prior written permission of Adobe.
21 //
22 //========================================================================================
23 
24 #ifndef __IDXMLDOMGraph__
25 #define __IDXMLDOMGraph__
26 
27 #include "boost/graph/graph_traits.hpp"
28 #include "boost/iterator/iterator_facade.hpp"
29 #include "boost/iterator_adaptors.hpp"
30 #include "DepthFirstTreeIterator.h"
31 
32 #include "IIDXMLDOMNode.h"
33 
34 
35 
36 #if 0
37 struct IDXMLDOMIteratorPolicies : public boost::default_iterator_policies
38 {
39  IDXMLDOMIteratorPolicies() {}
40 
41  template <class IteratorAdaptor>
42  typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
43  { return x.base(); }
44 
45  template <class IteratorAdaptor>
46  void increment(IteratorAdaptor& x) { advance(x, 1); }
47 
48  //template <class IteratorAdaptor>
49  //void decrement(IteratorAdaptor& x) { advance(x, -1); }
50 
51  template <class IteratorAdaptor, class DifferenceType>
52  void advance(IteratorAdaptor& x, DifferenceType n);
53 };
54 
55 
56 template <class IteratorAdaptor, class DifferenceType>
57 void IDXMLDOMIteratorPolicies::advance(IteratorAdaptor& x, DifferenceType n)
58 {
59  ASSERT_MSG(n == 1, "IDXMLDOMIteratorPolicies::advance: only single step forward iterator for now");
60  ASSERT_MSG(x.base(), "IDXMLDOMIteratorPolicies::advance: cannot advance end iterator");
61  if (x.base())
62  {
63  x.base() = x.base()->GetNextSibling();
64  }
65 }
66 #endif
67 
68 
69 class IDXMLDOMIterator : public boost::iterator_facade<
70  IDXMLDOMIterator, // derived
71  IIDXMLDOMNode*, // value
72  boost::forward_traversal_tag, // category
73  IIDXMLDOMNode*, // reference
74  int32 // difference
75  >
76 {
77 public:
78  IDXMLDOMIterator() :
79  fData()
80  {}
81 
82  explicit IDXMLDOMIterator(IIDXMLDOMNode *other) :
83  fData(other)
84  {}
85 
86 private:
87  friend class boost::iterator_core_access;
88 
89  void increment()
90  {
91  advance(1);
92  }
93 
94  bool equal(IDXMLDOMIterator const& other) const { return fData == other.fData; }
95 
96  IIDXMLDOMNode*& dereference() const { ASSERT(fData); return const_cast<IIDXMLDOMNode*&>(fData); }
97 
98  void advance(int32 n)
99  {
100  ASSERT_MSG(n > 0, "IDXMLDOMIterator::advance: only positive increments are supported right now");
101  ASSERT_MSG(fData, "IDXMLDOMIterator::advance: cannot advance end iterator");
102  while (--n >= 0 && fData) {
103  fData = fData->GetNextSibling();
104  ASSERT_MSG(n == 0 || fData, "IDXMLDOMIterator::advance: attempt advance past end iterator");
105  }
106  }
107 
108  // member data
109  IIDXMLDOMNode *fData;
110 };
111 
112 
113 #if 0
114 struct IDXMLDOMInEdgeIteratorPolicies : public boost::default_iterator_policies
115 {
116  IDXMLDOMInEdgeIteratorPolicies() {}
117 
118  template <class IteratorAdaptor>
119  typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
120  { return x.base(); }
121 
122  template <class IteratorAdaptor>
123  void increment(IteratorAdaptor& x) { advance(x, 1); }
124 
125  //template <class IteratorAdaptor>
126  //void decrement(IteratorAdaptor& x) { advance(x, -1); }
127 
128  template <class IteratorAdaptor, class DifferenceType>
129  void advance(IteratorAdaptor& x, DifferenceType n);
130 };
131 
132 
133 template <class IteratorAdaptor, class DifferenceType>
134 void IDXMLDOMInEdgeIteratorPolicies::advance(IteratorAdaptor& x, DifferenceType n)
135 {
136  x.base() = nil;
137 }
138 #endif
139 
140 
141 class IDXMLDOMInEdgeIterator : public boost::iterator_facade<
142  IDXMLDOMInEdgeIterator, //derived
143  IIDXMLDOMNode*, // value
144  boost::forward_traversal_tag, // category
145  IIDXMLDOMNode*, // reference
146  int32 // difference
147  >
148 {
149 public:
150  IDXMLDOMInEdgeIterator() :
151  fData()
152  {}
153 
154  explicit IDXMLDOMInEdgeIterator(IIDXMLDOMNode *other) :
155  fData(other)
156  {}
157 
158 private:
159  friend class boost::iterator_core_access;
160 
161  void increment()
162  {
163  advance(1);
164  }
165 
166  bool equal(IDXMLDOMInEdgeIterator const& other) const { return fData == other.fData; }
167 
168  IIDXMLDOMNode*& dereference() const { ASSERT(fData); return const_cast<IIDXMLDOMNode*&>(fData); }
169 
170  void advance(int32 n)
171  {
172  ASSERT_MSG(n == 1, "IDXMLDOMInEdgeIterator::advance: can only do 1 advance");
173  ASSERT_MSG(fData, "IDXMLDOMInEdgeIterator::advance: cannot advance end iterator");
174  fData = nil;
175  }
176 
177  // member data
178  IIDXMLDOMNode* fData;
179 };
180 
181 struct IDXMLDOMGraph {
182 
183  IDXMLDOMGraph(IIDXMLDOMNode * const rootVertex) :
184  fRootVertex(rootVertex)
185  {}
186 
187  IIDXMLDOMNode *RootVertex(void) const { return fRootVertex; }
188 
189 private:
190  IIDXMLDOMNode *fRootVertex;
191 };
192 
193 
194 namespace boost {
195 
196 template<>
197 struct graph_traits<IDXMLDOMGraph> {
198  typedef IIDXMLDOMNode *vertex_descriptor;
199  typedef IIDXMLDOMNode *edge_descriptor;
200  typedef void adjacency_iterator;
201  typedef IDXMLDOMIterator out_edge_iterator;
202  typedef IDXMLDOMInEdgeIterator in_edge_iterator;
203  typedef void edge_iterator;
204  typedef void vertex_iterator;
205  typedef int32 degree_size_type;
206  typedef int32 vertices_size_type;
207  typedef int32 edges_size_type;
208  typedef boost::directed_tag directed_category;
209  typedef boost::disallow_parallel_edge_tag edge_parallel_category;
210  typedef boost::bidirectional_graph_tag traversal_category;
211 };
212 }
213 
214 
215 typedef boost::graph_traits<IDXMLDOMGraph>::out_edge_iterator IDXMLDOMOutEdgeIterator;
216 
217 
218  std::pair<IDXMLDOMOutEdgeIterator, IDXMLDOMOutEdgeIterator>
219 out_edges(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
220 
221  boost::graph_traits<IDXMLDOMGraph>::degree_size_type
222 out_degree(const IIDXMLDOMNode *v, const IDXMLDOMGraph& g);
223 
224  boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor
225 source(const boost::graph_traits<IDXMLDOMGraph>::edge_descriptor& e, const IDXMLDOMGraph& g);
226 
227  boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor
228 target(const boost::graph_traits<IDXMLDOMGraph>::edge_descriptor& e, const IDXMLDOMGraph& g);
229 
230  std::pair<boost::graph_traits<IDXMLDOMGraph>::in_edge_iterator, boost::graph_traits<IDXMLDOMGraph>::in_edge_iterator>
231 in_edges(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
232 
233 // boost::graph_traits<IDXMLDOMGraph>::degree_size_type
234 //in_degree(const boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor& v, const IDXMLDOMGraph& g);
235 
236 // boost::graph_traits<IDXMLDOMGraph>::degree_size_type
237 //degree(const boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor& v, const IDXMLDOMGraph& g);
238 /*
239 boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor
240 rootX(const IDXMLDOMGraph& g);
241 */
242 IDXMLDOMOutEdgeIterator
243 incoming_edge(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
244 
245 
246 #if 0
247 struct IDXMLDOMStructureOnlyIteratorPolicies : public boost::default_iterator_policies
248 {
249  IDXMLDOMStructureOnlyIteratorPolicies() {}
250 
251  template <class IteratorAdaptor>
252  typename IteratorAdaptor::reference dereference(const IteratorAdaptor& x) const
253  { return x.base(); }
254 
255  template <class IteratorAdaptor>
256  void increment(IteratorAdaptor& x) { advance(x, 1); }
257 
258  //template <class IteratorAdaptor>
259  //void decrement(IteratorAdaptor& x) { advance(x, -1); }
260 
261  template <class IteratorAdaptor, class DifferenceType>
262  void advance(IteratorAdaptor& x, DifferenceType n);
263 };
264 
265 
266 template <class IteratorAdaptor, class DifferenceType>
267 void IDXMLDOMStructureOnlyIteratorPolicies::advance(IteratorAdaptor& x, DifferenceType n)
268 {
269  ASSERT_MSG(n == 1, "IDXMLDOMStructureOnlyIteratorPolicies::advance: only single step forward iterator for now");
270  ASSERT_MSG(x.base(), "IDXMLDOMStructureOnlyIteratorPolicies::advance: cannot advance end iterator");
271  if (x.base())
272  {
273  x.base() = x.base()->GetNextSibling();
274 
275  // skip over all content nodes
276  while (x.base() && x.base()->GetNodeType() == IIDXMLDOMNode::kText)
277  x.base() = x.base()->GetNextSibling();
278  }
279 }
280 #endif
281 
282 
283 class IDXMLDOMStructureOnlyIterator : public boost::iterator_facade<
284  IDXMLDOMStructureOnlyIterator, //derived
285  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor, // value
286  boost::forward_traversal_tag, // category
287  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor, // reference
288  int32 // difference
289  >
290 {
291 public:
292  IDXMLDOMStructureOnlyIterator() :
293  fData()
294  {}
295 
296  explicit IDXMLDOMStructureOnlyIterator(const boost::graph_traits<IDXMLDOMGraph>::edge_descriptor& other) :
297  fData(other)
298  {}
299 
300 private:
301  friend class boost::iterator_core_access;
302 
303  void increment()
304  {
305  advance(1);
306  }
307 
308  bool equal(IDXMLDOMStructureOnlyIterator const& other) const { return fData == other.fData; }
309 
310  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor& dereference() const { return const_cast<boost::graph_traits<IDXMLDOMGraph>::edge_descriptor&>(fData); }
311 
312  void advance(int32 n)
313  {
314  ASSERT_MSG(n > 0, "IDXMLDOMStructureOnlyIterator::advance: only positive increments are supported right now");
315  ASSERT_MSG(fData, "IDXMLDOMStructureOnlyIterator::advance: cannot advance end iterator");
316  while (--n >= 0 && fData) {
317  fData = fData->GetNextSibling();
318 
319  // skip over all content nodes
320  while (fData && fData->GetNodeType() == IIDXMLDOMNode::kText) {
321  fData = fData->GetNextSibling();
322  }
323 
324  ASSERT_MSG(n == 0 || fData, "IDXMLDOMStructureOnlyIterator::advance: attempt to advance end iterator");
325  }
326  }
327 
328  // member data
329  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor fData;
330 };
331 
332 
333 struct IDXMLDOMVisitAllPred {
334  bool operator()(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph&) const
335  {
336  return true;
337  }
338 };
339 
340 
341 class IDXMLDOMDepthFirstTreeIterator : public boost::iterator_facade<
342  IDXMLDOMDepthFirstTreeIterator, // derived
343  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor, // value
344  boost::forward_traversal_tag, // category
345  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor/*&*/, // reference
346  int32 // difference
347  >
348 {
349 public:
350  IDXMLDOMDepthFirstTreeIterator() :
351  fData()
352  {}
353 
354  explicit IDXMLDOMDepthFirstTreeIterator(const boost::graph_traits<IDXMLDOMGraph>::edge_descriptor& other) :
355  fData(other)
356  {}
357 
358 private:
359  friend class boost::iterator_core_access;
360 
361  void increment()
362  {
363  advance(1);
364  }
365 
366  bool equal(IDXMLDOMDepthFirstTreeIterator const& other) const { return fData == other.fData; }
367 
368  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor& dereference() const { return const_cast<boost::graph_traits<IDXMLDOMGraph>::edge_descriptor&>(fData); }
369 
370  void advance(int32 n)
371  {
372  ASSERT_FAIL("IDXMLDOMDepthFirstTreeIterator::advance: not yet implemented");
373  }
374 
375  // member data
376  boost::graph_traits<IDXMLDOMGraph>::edge_descriptor fData;
377 };
378 
379 
380 template <class T>
381  std::pair<T, T>
382 virtual_out_edges(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
383 
384 
385 template <>
386  std::pair<IDXMLDOMOutEdgeIterator, IDXMLDOMOutEdgeIterator>
387 virtual_out_edges<IDXMLDOMOutEdgeIterator>(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
388 
389 
390 template <>
391  std::pair<IDXMLDOMStructureOnlyIterator, IDXMLDOMStructureOnlyIterator>
392 virtual_out_edges<IDXMLDOMStructureOnlyIterator>(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
393 
394 
395 template <class T>
396  T
397 virtual_make_iterator(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
398 
399 
400 template <>
401  IDXMLDOMOutEdgeIterator
402 virtual_make_iterator<IDXMLDOMOutEdgeIterator>(boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor v, const IDXMLDOMGraph& g);
403 
404 
405 // To get the root property from the graph
406 inline boost::graph_traits<IDXMLDOMGraph>::vertex_descriptor
407 get(boost::graph_tree_root_t, const IDXMLDOMGraph& g)
408 {
409  return g.RootVertex();;
410 }
411 
412 
413 #endif //__IDXMLDOMGraph__
414 
415