Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.11


STLHelper.hpp
Go to the documentation of this file.
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 #if !defined(STLHELPERS_HEADER_GUARD_1357924680)
19 #define STLHELPERS_HEADER_GUARD_1357924680
20 
21 
22 
23 // Base include file. Must be first.
25 
26 
27 
28 #include <algorithm>
29 #include <functional>
30 
31 
32 
34 
35 
36 
37 XALAN_CPP_NAMESPACE_BEGIN
38 
39 
40 
41 template<class Type>
42 struct
44 {
45  void
46  operator()(Type& theArg)
47  {
48  theArg.~Type();
49  }
50 
51  void
52  operator()(Type* theArg)
53  {
54  theArg->~Type();
55  }
56 
57  void
58  operator()(const Type* theArg)
59  {
60  (*this)(const_cast<Type*>(theArg));
61  }
62 
63  void
65  Type* theArg,
66  MemoryManager& theMemoryManager)
67  {
68  if (theArg != 0)
69  {
70  (*this)(*theArg);
71 
72  theMemoryManager.deallocate(theArg);
73  }
74  }
75 
76  void
78  const Type* theArg,
79  MemoryManager& theMemoryManager)
80  {
81  (*this)(const_cast<Type*>(theArg), theMemoryManager);
82  }
83 };
84 
85 
86 
87 template<class Type>
89 makeXalanDestroyFunctor(const Type* /* theType */)
90 {
92 }
93 
94 
95 
96 /**
97  * Functor to delete objects, used in STL iteration algorithms.
98  */
99 template <class Type>
100 #if defined(XALAN_NO_STD_NAMESPACE)
101 struct DeleteFunctor : public unary_function<const Type*, void>
102 #else
103 struct DeleteFunctor : public std::unary_function<const Type*, void>
104 #endif
105 {
106 #if defined(XALAN_NO_STD_NAMESPACE)
107  typedef unary_function<const Type*, void> BaseClassType;
108 #else
109  typedef std::unary_function<const Type*, void> BaseClassType;
110 #endif
111 
112  typedef typename BaseClassType::result_type result_type;
113  typedef typename BaseClassType::argument_type argument_type;
114 
115  DeleteFunctor(MemoryManager& theManager) :
116  m_memoryManager(theManager)
117  {
118  }
119 
120  /**
121  * Delete the object pointed to by argument.
122  *
123  * @param thePointer pointer to object to be deleted
124  */
125  result_type
126  operator()(argument_type thePointer) const
127  {
128  return makeXalanDestroyFunctor(thePointer)(thePointer, m_memoryManager);
129  }
130 
131 private:
132 
133  MemoryManager& m_memoryManager;
134 };
135 
136 
137 
138 #if !defined(XALAN_SGI_BASED_STL)
139 
140 /**
141  * Functor to retrieve the key of a key-value pair in a map, used in STL
142  * iteration algorithms.
143  */
144 template <class PairType>
145 #if defined(XALAN_NO_STD_NAMESPACE)
146 struct select1st : public unary_function<PairType, PairType::first_type>
147 #else
148 struct select1st : public std::unary_function<PairType, typename PairType::first_type>
149 #endif
150 {
151 #if defined(XALAN_NO_STD_NAMESPACE)
152  typedef unary_function<PairType, PairType::first_type> BaseClassType;
153 #else
154  typedef std::unary_function<PairType, typename PairType::first_type> BaseClassType;
155 #endif
156 
157  typedef typename BaseClassType::result_type result_type;
158  typedef typename BaseClassType::argument_type argument_type;
159 
160  typedef PairType value_type;
161 
162  /**
163  * Retrieve the key of a key-value pair.
164  *
165  * @param thePair key-value pair
166  * @return key
167  */
168  result_type
169  operator()(const argument_type& thePair) const
170  {
171  return thePair.first;
172  }
173 };
174 
175 
176 
177 /**
178  * Functor to retrieve the value of a key-value pair in a map, used in STL
179  * iteration algorithms.
180  */
181 template <class PairType>
182 #if defined(XALAN_NO_STD_NAMESPACE)
183 struct select2nd : public unary_function<PairType, PairType::second_type>
184 #else
185 struct select2nd : public std::unary_function<PairType, typename PairType::second_type>
186 #endif
187 {
188 #if defined(XALAN_NO_STD_NAMESPACE)
189  typedef unary_function<PairType, PairType::second_type> BaseClassType;
190 #else
191  typedef std::unary_function<PairType, typename PairType::second_type> BaseClassType;
192 #endif
193 
194  typedef typename BaseClassType::result_type result_type;
195  typedef typename BaseClassType::argument_type argument_type;
196 
197  typedef PairType value_type;
198 
199  /**
200  * Retrieve the value of a key-value pair.
201  *
202  * @param thePair key-value pair
203  * @return value
204  */
205  result_type
206  operator()(const argument_type& thePair) const
207  {
208  return thePair.second;
209  }
210 };
211 
212 #endif
213 
214 
215 
216 /**
217  * Functor to call a clear() member function on its argument.
218  */
219 template <class Type>
220 #if defined(XALAN_NO_STD_NAMESPACE)
221 struct ClearFunctor : public unary_function<Type, void>
222 #else
223 struct ClearFunctor : public std::unary_function<Type, void>
224 #endif
225 {
226 #if defined(XALAN_NO_STD_NAMESPACE)
227  typedef unary_function<Type, void> BaseClassType;
228 #else
229  typedef std::unary_function<Type, void> BaseClassType;
230 #endif
231 
232  typedef typename BaseClassType::result_type result_type;
233  typedef typename BaseClassType::argument_type argument_type;
234 
235  typedef Type value_type;
236 
237  /**
238  * Retrieve the value of a key-value pair.
239  *
240  * @param thePair key-value pair
241  * @return value
242  */
243  result_type
244  operator()(argument_type& theArg) const
245  {
246  return theArg.clear();
247  }
248 };
249 
250 
251 
252 /**
253  * Functor to delete value objects in maps, used in STL iteration algorithms.
254  */
255 template <class T>
256 #if defined(XALAN_NO_STD_NAMESPACE)
257 struct MapValueDeleteFunctor : public unary_function<const typename T::value_type&, void>
258 #else
259 struct MapValueDeleteFunctor : public std::unary_function<const typename T::value_type&, void>
260 #endif
261 {
262 #if defined(XALAN_NO_STD_NAMESPACE)
263  typedef unary_function<const typename T::value_type&, void> BaseClassType;
264 #else
265  typedef std::unary_function<const typename T::value_type&, void> BaseClassType;
266 #endif
267 
268  typedef typename BaseClassType::result_type result_type;
269  typedef typename BaseClassType::argument_type argument_type;
270 
271  MapValueDeleteFunctor(MemoryManager& theManager) :
272  m_memoryManager(theManager)
273  {
274  }
275 
276  /**
277  * Delete the value object in a map value pair. The value of the pair must
278  * be of pointer type.
279  *
280  * @param thePair key-value pair
281  */
282  result_type
283  operator()(argument_type thePair) const
284  {
285  return makeXalanDestroyFunctor(thePair.second)(thePair.second, m_memoryManager);
286  }
287 
288 private:
289 
290  MemoryManager& m_memoryManager;
291 };
292 
293 
294 
295 template<class MapType>
298 {
299  return MapValueDeleteFunctor<MapType>(theMap.getMemoryManager());
300 }
301 
302 
303 
304 /**
305  * This functor is designed to compare 0-terminated arrays. It substitutes
306  * for the default less<type*> so that pointers to arrays can be compared,
307  * rather than copies of arrays. For example, you might want to use C-style
308  * strings as keys in a map, rather than string objects. The default
309  * algorithm less<const char*> would just compare the pointers, and not the
310  * vector of characters to which it points. Using this algorithm instead of
311  * the default will allow the map to work as expected.
312  */
313 template<class T>
314 #if defined(XALAN_NO_STD_NAMESPACE)
315 struct less_null_terminated_arrays : public binary_function<const T*, const T*, bool>
316 #else
317 struct less_null_terminated_arrays : public std::binary_function<const T*, const T*, bool>
318 #endif
319 {
320 #if defined(XALAN_NO_STD_NAMESPACE)
321  typedef binary_function<const T*, const T*, bool> BaseClassType;
322 #else
323  typedef std::binary_function<const T*, const T*, bool> BaseClassType;
324 #endif
325 
326  typedef typename BaseClassType::result_type result_type;
327  typedef typename BaseClassType::first_argument_type first_argument_type;
328  typedef typename BaseClassType::second_argument_type second_argument_type;
329 
330  /**
331  * Compare the values of two objects.
332  *
333  *
334  * @param theLHS first object to compare
335  * @param theRHS second object to compare
336  * @return true if objects are the same
337  */
338  result_type
340  first_argument_type theLHS,
341  second_argument_type theRHS) const
342  {
343  while(*theLHS && *theRHS)
344  {
345  if (*theLHS != *theRHS)
346  {
347  break;
348  }
349  else
350  {
351  theLHS++;
352  theRHS++;
353  }
354  }
355 
356  return *theLHS < *theRHS ? true : false;
357  }
358 };
359 
360 
361 
362 template<class T>
363 struct equal_null_terminated_arrays : public XALAN_STD_QUALIFIER binary_function<const T*, const T*, bool>
364 {
365  typedef XALAN_STD_QUALIFIER binary_function<const T*, const T*, bool> BaseClassType;
366 
367  typedef typename BaseClassType::result_type result_type;
368  typedef typename BaseClassType::first_argument_type first_argument_type;
369  typedef typename BaseClassType::second_argument_type second_argument_type;
370  /**
371  * Compare the values of two objects.
372  *
373  *
374  * @param theLHS first object to compare
375  * @param theRHS second object to compare
376  * @return true if objects are the same
377  */
378  result_type
380  first_argument_type theLHS,
381  second_argument_type theRHS) const
382  {
383  while(*theLHS && *theRHS)
384  {
385  if (*theLHS != *theRHS)
386  {
387  return false;
388  }
389  else
390  {
391  ++theLHS;
392  ++theRHS;
393  }
394  }
395 
396  if (*theLHS || *theRHS)
397  {
398  return false;
399  }
400  else
401  {
402  return true;
403  }
404  }
405 };
406 
407 
408 
409 template <class ScalarType>
410 inline size_t
412  ScalarType theValue,
413  size_t theResult)
414 {
415  return (theResult * 37) + (theResult >> 24) + size_type(theValue);
416 }
417 
418 
419 
420 template <class T>
421 struct hash_non_terminated_array : public XALAN_STD_QUALIFIER unary_function<const T*, size_t>
422 {
423  typedef XALAN_STD_QUALIFIER unary_function<const T*, size_t> BaseClassType;
424 
425  typedef typename BaseClassType::result_type result_type;
426  typedef typename BaseClassType::argument_type argument_type;
427 
428  result_type
430  argument_type theKey,
431  result_type theLength,
432  result_type theInitialValue = 0) const
433  {
434  result_type theHashValue = theInitialValue;
435 
436  const argument_type theEnd =
437  theKey + theLength;
438 
439  while (theKey != theEnd)
440  {
441  theHashValue += XalanScalarHash(*theKey, theHashValue);
442 
443  ++theKey;
444  }
445 
446  return ++theHashValue;
447  }
448 };
449 
450 
451 
452 template <class T>
453 struct hash_null_terminated_array : public XALAN_STD_QUALIFIER unary_function<const T*, size_t>
454 {
455  typedef XALAN_STD_QUALIFIER unary_function<const T*, size_t> BaseClassType;
456 
457  typedef typename BaseClassType::result_type result_type;
458  typedef typename BaseClassType::argument_type argument_type;
459 
460  result_type
462  argument_type theKey,
463  result_type theInitialValue = 0) const
464  {
465  result_type theHashValue = theInitialValue;
466 
467  while (*theKey)
468  {
469  theHashValue += XalanScalarHash(*theKey, theHashValue);
470 
471  ++theKey;
472  }
473 
474  return ++theHashValue;
475  }
476 };
477 
478 
479 
480 template<>
481 struct XalanMapKeyTraits<const XalanDOMChar*>
482 {
485 };
486 
487 
488 
489 template<class CollectionType>
491 {
492 public:
493 
494  CollectionClearGuard(CollectionType& theCollection) :
495  m_collection(&theCollection)
496  {
497  }
498 
500  {
501  if (m_collection != 0)
502  {
503  m_collection->clear();
504  }
505  }
506 
507  void
509  {
510  m_collection = 0;
511  }
512 
513 private:
514 
515  // Not implemented...
517 
519  operator=(const CollectionClearGuard<CollectionType>&);
520 
521  // Data members...
522  CollectionType* m_collection;
523 };
524 
525 
526 
527 template<class CollectionType, class DeleteFunctorType>
529 {
530 public:
531 
532  CollectionDeleteGuard(CollectionType& theCollection) :
533  m_collection(&theCollection)
534  {
535  }
536 
538  {
539  if (m_collection != 0)
540  {
541 #if !defined(XALAN_NO_STD_NAMESPACE)
542  using std::for_each;
543 #endif
544 
545  // Delete all of the objects in the temp vector.
546  for_each(m_collection->begin(),
547  m_collection->end(),
548  DeleteFunctorType(m_collection->getMemoryManager()));
549  }
550  }
551 
552  void
554  {
555  m_collection = 0;
556  }
557 
558 private:
559 
560  // Not implemented...
562 
565 
566  // Data members...
567  CollectionType* m_collection;
568 };
569 
570 
571 
572 template<class T>
573 #if defined(XALAN_NO_STD_NAMESPACE)
574 struct pointer_equals : public binary_function<const T*, const T*, bool>
575 #else
576 struct pointer_equals : public std::binary_function<const T*, const T*, bool>
577 #endif
578 {
579 #if defined(XALAN_NO_STD_NAMESPACE)
580  typedef binary_function<const T*, const T*, bool> BaseClassType;
581 #else
582  typedef std::binary_function<const T*, const T*, bool> BaseClassType;
583 #endif
584 
585  typedef typename BaseClassType::result_type result_type;
586  typedef typename BaseClassType::first_argument_type first_argument_type;
587  typedef typename BaseClassType::second_argument_type second_argument_type;
588 
589  result_type
591  first_argument_type theLHS,
592  second_argument_type theRHS) const
593  {
594  assert(theLHS != 0 && theRHS != 0);
595 
596  return *theLHS == *theRHS;
597  }
598 };
599 
600 
601 
602 template<class T>
603 #if defined(XALAN_NO_STD_NAMESPACE)
604 struct pointer_equals_predicate : public unary_function<const T*, bool>
605 #else
606 struct pointer_equals_predicate : public std::unary_function<const T*, bool>
607 #endif
608 {
609 #if defined(XALAN_NO_STD_NAMESPACE)
610  typedef unary_function<const T*, bool> BaseClassType;
611 #else
612  typedef std::unary_function<const T*, bool> BaseClassType;
613 #endif
614 
615  typedef typename BaseClassType::result_type result_type;
616  typedef typename BaseClassType::argument_type argument_type;
617 
618  pointer_equals_predicate(argument_type theArg) :
619  m_arg(theArg)
620  {
621  }
622 
623  result_type
625  argument_type theOther) const
626  {
627  assert(theOther != 0);
628 
629  return *theOther == *m_arg;
630  }
631 
632 private:
633 
634  const argument_type m_arg;
635 };
636 
637 
638 
639 template<class T>
640 #if defined(XALAN_NO_STD_NAMESPACE)
641 struct pointer_less : public binary_function<const T*, const T*, bool>
642 #else
643 struct pointer_less : public std::binary_function<const T*, const T*, bool>
644 #endif
645 {
646 #if defined(XALAN_NO_STD_NAMESPACE)
647  typedef binary_function<const T*, const T*, bool> BaseClassType;
648 #else
649  typedef std::binary_function<const T*, const T*, bool> BaseClassType;
650 #endif
651 
652  typedef typename BaseClassType::result_type result_type;
653  typedef typename BaseClassType::first_argument_type first_argument_type;
654  typedef typename BaseClassType::second_argument_type second_argument_type;
655 
656  result_type
658  first_argument_type theLHS,
659  second_argument_type theRHS) const
660  {
661  assert(theLHS != 0 && theRHS != 0);
662 
663 #if !defined(XALAN_NO_STD_NAMESPACE)
664  using std::less;
665 #endif
666 
667  return less<T>()(*theLHS, *theRHS);
668  }
669 };
670 
671 
672 
673 template<class T>
674 struct pointer_equal : public XALAN_STD_QUALIFIER binary_function<const T*, const T*, bool>
675 {
676  typedef XALAN_STD_QUALIFIER binary_function<const T*, const T*, bool> BaseClassType;
677 
678  typedef typename BaseClassType::result_type result_type;
679  typedef typename BaseClassType::first_argument_type first_argument_type;
680  typedef typename BaseClassType::second_argument_type second_argument_type;
681 
682  result_type
684  first_argument_type theLHS,
685  second_argument_type theRHS) const
686  {
687  assert(theLHS != 0 && theRHS != 0);
688  return XALAN_STD_QUALIFIER equal_to<T>()(*theLHS, *theRHS);
689  }
690 };
691 
692 
693 
694 
695 XALAN_CPP_NAMESPACE_END
696 
697 
698 
699 #endif // STLHELPERS_HEADER_GUARD_1357924680
std::binary_function< const T *, const T *, bool > BaseClassType
Definition: STLHelper.hpp:649
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:113
result_type operator()(first_argument_type theLHS, second_argument_type theRHS) const
Definition: STLHelper.hpp:683
Functor to retrieve the value of a key-value pair in a map, used in STL iteration algorithms...
Definition: STLHelper.hpp:185
Functor to call a clear() member function on its argument.
Definition: STLHelper.hpp:223
MapValueDeleteFunctor(MemoryManager &theManager)
Definition: STLHelper.hpp:271
Functor to delete value objects in maps, used in STL iteration algorithms.
Definition: STLHelper.hpp:259
void operator()(Type &theArg)
Definition: STLHelper.hpp:46
BaseClassType::result_type result_type
Definition: STLHelper.hpp:112
std::unary_function< Type, void > BaseClassType
Definition: STLHelper.hpp:229
result_type operator()(argument_type thePair) const
Delete the value object in a map value pair.
Definition: STLHelper.hpp:283
BaseClassType::second_argument_type second_argument_type
Definition: STLHelper.hpp:654
XALAN_STD_QUALIFIER unary_function< const T *, size_t > BaseClassType
Definition: STLHelper.hpp:423
hash_null_terminated_array< XalanDOMChar > Hasher
Definition: STLHelper.hpp:483
BaseClassType::first_argument_type first_argument_type
Definition: STLHelper.hpp:368
This functor is designed to compare 0-terminated arrays.
Definition: STLHelper.hpp:317
BaseClassType::first_argument_type first_argument_type
Definition: STLHelper.hpp:679
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:269
result_type operator()(argument_type theOther) const
Definition: STLHelper.hpp:624
std::unary_function< const Type *, void > BaseClassType
Definition: STLHelper.hpp:109
std::unary_function< PairType, typename PairType::second_type > BaseClassType
Definition: STLHelper.hpp:191
equal_null_terminated_arrays< XalanDOMChar > Comparator
Definition: STLHelper.hpp:484
result_type operator()(first_argument_type theLHS, second_argument_type theRHS) const
Definition: STLHelper.hpp:590
BaseClassType::second_argument_type second_argument_type
Definition: STLHelper.hpp:328
result_type operator()(argument_type thePointer) const
Delete the object pointed to by argument.
Definition: STLHelper.hpp:126
PairType value_type
Definition: STLHelper.hpp:160
Functor to retrieve the key of a key-value pair in a map, used in STL iteration algorithms.
Definition: STLHelper.hpp:148
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:458
BaseClassType::second_argument_type second_argument_type
Definition: STLHelper.hpp:680
std::unary_function< PairType, typename PairType::first_type > BaseClassType
Definition: STLHelper.hpp:154
BaseClassType::result_type result_type
Definition: STLHelper.hpp:194
result_type operator()(first_argument_type theLHS, second_argument_type theRHS) const
Compare the values of two objects.
Definition: STLHelper.hpp:339
BaseClassType::result_type result_type
Definition: STLHelper.hpp:326
result_type operator()(first_argument_type theLHS, second_argument_type theRHS) const
Definition: STLHelper.hpp:657
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:426
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:158
result_type operator()(const argument_type &thePair) const
Retrieve the value of a key-value pair.
Definition: STLHelper.hpp:206
BaseClassType::result_type result_type
Definition: STLHelper.hpp:457
std::unary_function< const typename T::value_type &, void > BaseClassType
Definition: STLHelper.hpp:265
BaseClassType::result_type result_type
Definition: STLHelper.hpp:652
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:195
BaseClassType::first_argument_type first_argument_type
Definition: STLHelper.hpp:586
result_type operator()(const argument_type &thePair) const
Retrieve the key of a key-value pair.
Definition: STLHelper.hpp:169
DeleteFunctor(MemoryManager &theManager)
Definition: STLHelper.hpp:115
XalanDestroyFunctor< Type > makeXalanDestroyFunctor(const Type *)
Definition: STLHelper.hpp:89
Functor to delete objects, used in STL iteration algorithms.
Definition: STLHelper.hpp:103
void operator()(Type *theArg)
Definition: STLHelper.hpp:52
XALAN_STD_QUALIFIER binary_function< const T *, const T *, bool > BaseClassType
Definition: STLHelper.hpp:365
XALAN_CPP_NAMESPACE_BEGIN typedef size_t size_type
Definition: XalanMap.hpp:46
std::binary_function< const T *, const T *, bool > BaseClassType
Definition: STLHelper.hpp:582
XALAN_STD_QUALIFIER binary_function< const T *, const T *, bool > BaseClassType
Definition: STLHelper.hpp:676
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:616
MapValueDeleteFunctor< MapType > makeMapValueDeleteFunctor(MapType &theMap)
Definition: STLHelper.hpp:297
BaseClassType::result_type result_type
Definition: STLHelper.hpp:678
size_t XalanScalarHash(ScalarType theValue, size_t theResult)
Definition: STLHelper.hpp:411
CollectionDeleteGuard(CollectionType &theCollection)
Definition: STLHelper.hpp:532
BaseClassType::argument_type argument_type
Definition: STLHelper.hpp:233
BaseClassType::first_argument_type first_argument_type
Definition: STLHelper.hpp:653
BaseClassType::result_type result_type
Definition: STLHelper.hpp:157
BaseClassType::result_type result_type
Definition: STLHelper.hpp:367
void operator()(Type *theArg, MemoryManager &theMemoryManager)
Definition: STLHelper.hpp:64
BaseClassType::result_type result_type
Definition: STLHelper.hpp:268
BaseClassType::second_argument_type second_argument_type
Definition: STLHelper.hpp:369
BaseClassType::first_argument_type first_argument_type
Definition: STLHelper.hpp:327
XALAN_STD_QUALIFIER unary_function< const T *, size_t > BaseClassType
Definition: STLHelper.hpp:455
std::binary_function< const T *, const T *, bool > BaseClassType
Definition: STLHelper.hpp:323
BaseClassType::result_type result_type
Definition: STLHelper.hpp:425
BaseClassType::result_type result_type
Definition: STLHelper.hpp:615
std::unary_function< const T *, bool > BaseClassType
Definition: STLHelper.hpp:612
BaseClassType::result_type result_type
Definition: STLHelper.hpp:585
BaseClassType::result_type result_type
Definition: STLHelper.hpp:232
pointer_equals_predicate(argument_type theArg)
Definition: STLHelper.hpp:618
CollectionClearGuard(CollectionType &theCollection)
Definition: STLHelper.hpp:494
BaseClassType::second_argument_type second_argument_type
Definition: STLHelper.hpp:587
result_type operator()(first_argument_type theLHS, second_argument_type theRHS) const
Compare the values of two objects.
Definition: STLHelper.hpp:379
PairType value_type
Definition: STLHelper.hpp:197
void operator()(const Type *theArg, MemoryManager &theMemoryManager)
Definition: STLHelper.hpp:77
void operator()(const Type *theArg)
Definition: STLHelper.hpp:58
result_type operator()(argument_type &theArg) const
Retrieve the value of a key-value pair.
Definition: STLHelper.hpp:244

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.11
Copyright © 1999-2012 The Apache Software Foundation.
All Rights Reserved.

Apache Logo