Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

XalanEXSLTMathImpl.hpp
Go to the documentation of this file.
1 /*
2  * Copyright 1999-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #if !defined(EXSLT_MATHIMPL_HEADER_GUARD_1357924680)
17 #define EXSLT_MATHIMPL_HEADER_GUARD_1357924680
18 
19 
20 
22 
23 
24 
26 
27 
28 
30 
31 
32 
33 XALAN_CPP_NAMESPACE_BEGIN
34 
35 
36 
38 {
39 public:
40 
42 
44  {
45  }
46 
47  virtual
49  {
50  }
51 
52  // These methods are inherited from Function ...
53 
54  virtual XObjectPtr
55  execute(
56  XPathExecutionContext& executionContext,
57  XalanNode* context,
58  const XObjectArgVectorType& args,
59  const LocatorType* locator) const;
60 
61 #if !defined(XALAN_NO_USING_DECLARATION)
62  using ParentType::execute;
63 #endif
64 
65 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
66  virtual Function*
67 #else
68  virtual XalanEXSLTFunctionAbs*
69 #endif
70  clone(MemoryManagerType& theManager) const
71  {
72  return XalanCopyConstruct(theManager, *this);
73  }
74 
75 protected:
76 
77  const XalanDOMString&
78  getError(XalanDOMString& theBuffer) const;
79 
80 private:
81 
82  // Not implemented...
84  operator=(const XalanEXSLTFunctionAbs&);
85 
86  bool
87  operator==(const XalanEXSLTFunctionAbs&) const;
88 };
89 
90 
91 
93 {
94 public:
95 
97 
99  {
100  }
101 
102  virtual
104  {
105  }
106 
107  // These methods are inherited from Function ...
108 
109  virtual XObjectPtr
110  execute(
111  XPathExecutionContext& executionContext,
112  XalanNode* context,
113  const XObjectArgVectorType& args,
114  const LocatorType* locator) const;
115 
116 #if !defined(XALAN_NO_USING_DECLARATION)
117  using ParentType::execute;
118 #endif
119 
120 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
121  virtual Function*
122 #else
123  virtual XalanEXSLTFunctionRandom*
124 #endif
125  clone(MemoryManagerType& theManager) const
126  {
127  return XalanCopyConstruct(theManager, *this);
128  }
129 
130 protected:
131 
132  const XalanDOMString&
133  getError(XalanDOMString& theBuffer) const;
134 
135 private:
136 
137  // Not implemented...
139  operator=(const XalanEXSLTFunctionRandom&);
140 
141  bool
142  operator==(const XalanEXSLTFunctionRandom&) const;
143 };
144 
145 
146 
148 {
149 public:
150 
152 
154  {
155  }
156 
157  virtual
159  {
160  }
161 
162  // These methods are inherited from Function ...
163 
164  virtual XObjectPtr
165  execute(
166  XPathExecutionContext& executionContext,
167  XalanNode* context,
168  const XObjectArgVectorType& args,
169  const LocatorType* locator) const;
170 
171 #if !defined(XALAN_NO_USING_DECLARATION)
172  using ParentType::execute;
173 #endif
174 
175 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
176  virtual Function*
177 #else
178  virtual XalanEXSLTFunctionAcos*
179 #endif
180  clone(MemoryManagerType& theManager) const
181  {
182  return XalanCopyConstruct(theManager, *this);
183  }
184 
185 protected:
186 
187  const XalanDOMString&
188  getError(XalanDOMString& theBuffer) const;
189 
190 private:
191 
192  // Not implemented...
194  operator=(const XalanEXSLTFunctionAcos&);
195 
196  bool
197  operator==(const XalanEXSLTFunctionAcos&) const;
198 };
199 
200 
201 
203 {
204 public:
205 
207 
209  {
210  }
211 
212  virtual
214  {
215  }
216 
217  // These methods are inherited from Function ...
218 
219  virtual XObjectPtr
220  execute(
221  XPathExecutionContext& executionContext,
222  XalanNode* context,
223  const XObjectArgVectorType& args,
224  const LocatorType* locator) const;
225 
226 #if !defined(XALAN_NO_USING_DECLARATION)
227  using ParentType::execute;
228 #endif
229 
230 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
231  virtual Function*
232 #else
233  virtual XalanEXSLTFunctionAsin*
234 #endif
235  clone(MemoryManagerType& theManager) const
236  {
237  return XalanCopyConstruct(theManager, *this);
238  }
239 
240 protected:
241 
242  const XalanDOMString&
243  getError(XalanDOMString& theBuffer) const;
244 
245 private:
246 
247  // Not implemented...
249  operator=(const XalanEXSLTFunctionAsin&);
250 
251  bool
252  operator==(const XalanEXSLTFunctionAsin&) const;
253 };
254 
255 
256 
258 {
259 public:
260 
262 
264  {
265  }
266 
267  virtual
269  {
270  }
271 
272  // These methods are inherited from Function ...
273 
274  virtual XObjectPtr
275  execute(
276  XPathExecutionContext& executionContext,
277  XalanNode* context,
278  const XObjectArgVectorType& args,
279  const LocatorType* locator) const;
280 
281 #if !defined(XALAN_NO_USING_DECLARATION)
282  using ParentType::execute;
283 #endif
284 
285 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
286  virtual Function*
287 #else
288  virtual XalanEXSLTFunctionAtan*
289 #endif
290  clone(MemoryManagerType& theManager) const
291  {
292  return XalanCopyConstruct(theManager, *this);
293  }
294 
295 protected:
296 
297  const XalanDOMString&
298  getError(XalanDOMString& theBuffer) const;
299 
300 private:
301 
302  // Not implemented...
304  operator=(const XalanEXSLTFunctionAtan&);
305 
306  bool
307  operator==(const XalanEXSLTFunctionAtan&) const;
308 };
309 
310 
311 
313 {
314 public:
315 
317 
319  {
320  }
321 
322  virtual
324  {
325  }
326 
327  // These methods are inherited from Function ...
328 
329  virtual XObjectPtr
330  execute(
331  XPathExecutionContext& executionContext,
332  XalanNode* context,
333  const XObjectArgVectorType& args,
334  const LocatorType* locator) const;
335 
336 #if !defined(XALAN_NO_USING_DECLARATION)
337  using ParentType::execute;
338 #endif
339 
340 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
341  virtual Function*
342 #else
343  virtual XalanEXSLTFunctionAtan2*
344 #endif
345  clone(MemoryManagerType& theManager) const
346  {
347  return XalanCopyConstruct(theManager, *this);
348  }
349 
350 protected:
351 
352  const XalanDOMString&
353  getError(XalanDOMString& theBuffer) const;
354 
355 private:
356 
357  // Not implemented...
359  operator=(const XalanEXSLTFunctionAtan2&);
360 
361  bool
362  operator==(const XalanEXSLTFunctionAtan2&) const;
363 };
364 
365 
366 
368 {
369 public:
370 
372 
374  {
375  }
376 
377  virtual
379  {
380  }
381 
382  // These methods are inherited from Function ...
383 
384  virtual XObjectPtr
385  execute(
386  XPathExecutionContext& executionContext,
387  XalanNode* context,
388  const XObjectArgVectorType& args,
389  const LocatorType* locator) const;
390 
391 #if !defined(XALAN_NO_USING_DECLARATION)
392  using ParentType::execute;
393 #endif
394 
395 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
396  virtual Function*
397 #else
399 #endif
400  clone(MemoryManagerType& theManager) const
401  {
402  return XalanCopyConstruct(theManager, *this);
403  }
404 
405 protected:
406 
407  const XalanDOMString&
408  getError(XalanDOMString& theBuffer) const
409  {
411  theBuffer,
412  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
413  "constant()");
414  }
415 
416 private:
417 
418  static const XalanDOMChar s_eString[];
419  static const XalanDOMChar s_ln10String[];
420  static const XalanDOMChar s_ln2String[];
421  static const XalanDOMChar s_log2EString[];
422  static const XalanDOMChar s_piString[];
423  static const XalanDOMChar s_sqrt1_2String[];
424  static const XalanDOMChar s_sqrt2String[];
425 
426  static const double s_eValues[];
427  static const double s_ln10Values[];
428  static const double s_ln2Values[];
429  static const double s_log2EValues[];
430  static const double s_piValues[];
431  static const double s_sqrt1_2Values[];
432  static const double s_sqrt2Values[];
433 
434 
435  // Not implemented...
437  operator=(const XalanEXSLTFunctionConstant&);
438 
439  bool
441 };
442 
443 
444 
446 {
447 public:
448 
450 
452  {
453  }
454 
455  virtual
457  {
458  }
459 
460  // These methods are inherited from Function ...
461 
462  virtual XObjectPtr
463  execute(
464  XPathExecutionContext& executionContext,
465  XalanNode* context,
466  const XObjectArgVectorType& args,
467  const LocatorType* locator) const;
468 
469 #if !defined(XALAN_NO_USING_DECLARATION)
470  using ParentType::execute;
471 #endif
472 
473 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
474  virtual Function*
475 #else
476  virtual XalanEXSLTFunctionCos*
477 #endif
478  clone(MemoryManagerType& theManager) const
479  {
480  return XalanCopyConstruct(theManager, *this);
481  }
482 
483 protected:
484 
485  const XalanDOMString&
486  getError(XalanDOMString& theBuffer) const;
487 
488 private:
489 
490  // Not implemented...
492  operator=(const XalanEXSLTFunctionCos&);
493 
494  bool
495  operator==(const XalanEXSLTFunctionCos&) const;
496 };
497 
498 
499 
501 {
502 public:
503 
505 
507  {
508  }
509 
510  virtual
512  {
513  }
514 
515  // These methods are inherited from Function ...
516 
517  virtual XObjectPtr
518  execute(
519  XPathExecutionContext& executionContext,
520  XalanNode* context,
521  const XObjectArgVectorType& args,
522  const LocatorType* locator) const;
523 
524 #if !defined(XALAN_NO_USING_DECLARATION)
525  using ParentType::execute;
526 #endif
527 
528 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
529  virtual Function*
530 #else
531  virtual XalanEXSLTFunctionExp*
532 #endif
533  clone(MemoryManagerType& theManager) const
534  {
535  return XalanCopyConstruct(theManager, *this);
536  }
537 
538 protected:
539 
540  const XalanDOMString&
541  getError(XalanDOMString& theBuffer) const;
542 
543 private:
544 
545  // Not implemented...
547  operator=(const XalanEXSLTFunctionExp&);
548 
549  bool
550  operator==(const XalanEXSLTFunctionExp&) const;
551 };
552 
553 
554 
556 {
557 public:
558 
560 
562  {
563  }
564 
565  virtual
567  {
568  }
569 
570  // These methods are inherited from Function ...
571 
572  virtual XObjectPtr
573  execute(
574  XPathExecutionContext& executionContext,
575  XalanNode* context,
576  const XObjectArgVectorType& args,
577  const LocatorType* locator) const;
578 
579 #if !defined(XALAN_NO_USING_DECLARATION)
580  using ParentType::execute;
581 #endif
582 
583 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
584  virtual Function*
585 #else
587 #endif
588  clone(MemoryManagerType& theManager) const
589  {
590  return XalanCopyConstruct(theManager, *this);
591  }
592 
593 protected:
594 
595  const XalanDOMString&
596  getError(XalanDOMString& theBuffer) const;
597 
598 private:
599 
600  // Not implemented...
602  operator=(const XalanEXSLTFunctionHighest&);
603 
604  bool
606 };
607 
608 
609 
611 {
612 public:
613 
615 
617  {
618  }
619 
620  virtual
622  {
623  }
624 
625  // These methods are inherited from Function ...
626 
627  virtual XObjectPtr
628  execute(
629  XPathExecutionContext& executionContext,
630  XalanNode* context,
631  const XObjectArgVectorType& args,
632  const LocatorType* locator) const;
633 
634 #if !defined(XALAN_NO_USING_DECLARATION)
635  using ParentType::execute;
636 #endif
637 
638 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
639  virtual Function*
640 #else
641  virtual XalanEXSLTFunctionLog*
642 #endif
643  clone(MemoryManagerType& theManager) const
644  {
645  return XalanCopyConstruct(theManager, *this);
646  }
647 
648 protected:
649 
650  const XalanDOMString&
651  getError(XalanDOMString& theBuffer) const;
652 
653 private:
654 
655  // Not implemented...
657  operator=(const XalanEXSLTFunctionLog&);
658 
659  bool
660  operator==(const XalanEXSLTFunctionLog&) const;
661 };
662 
663 
664 
666 {
667 public:
668 
670 
672  {
673  }
674 
675  virtual
677  {
678  }
679 
680  // These methods are inherited from Function ...
681 
682  virtual XObjectPtr
683  execute(
684  XPathExecutionContext& executionContext,
685  XalanNode* context,
686  const XObjectArgVectorType& args,
687  const LocatorType* locator) const;
688 
689 #if !defined(XALAN_NO_USING_DECLARATION)
690  using ParentType::execute;
691 #endif
692 
693 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
694  virtual Function*
695 #else
696  virtual XalanEXSLTFunctionLowest*
697 #endif
698  clone(MemoryManagerType& theManager) const
699  {
700  return XalanCopyConstruct(theManager, *this);
701  }
702 
703 protected:
704 
705  const XalanDOMString&
706  getError(XalanDOMString& theBuffer) const;
707 
708 private:
709 
710  // Not implemented...
712  operator=(const XalanEXSLTFunctionLowest&);
713 
714  bool
715  operator==(const XalanEXSLTFunctionLowest&) const;
716 };
717 
718 
719 
721 {
722 public:
723 
725 
727  {
728  }
729 
730  virtual
732  {
733  }
734 
735  // These methods are inherited from Function ...
736 
737  virtual XObjectPtr
738  execute(
739  XPathExecutionContext& executionContext,
740  XalanNode* context,
741  const XObjectArgVectorType& args,
742  const LocatorType* locator) const;
743 
744 #if !defined(XALAN_NO_USING_DECLARATION)
745  using ParentType::execute;
746 #endif
747 
748 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
749  virtual Function*
750 #else
751  virtual XalanEXSLTFunctionMax*
752 #endif
753  clone(MemoryManagerType& theManager) const
754  {
755  return XalanCopyConstruct(theManager, *this);
756  }
757 
758 protected:
759 
760  const XalanDOMString&
761  getError(XalanDOMString& theBuffer) const;
762 
763 private:
764 
765  // Not implemented...
767  operator=(const XalanEXSLTFunctionMax&);
768 
769  bool
770  operator==(const XalanEXSLTFunctionMax&) const;
771 };
772 
773 
774 
776 {
777 public:
778 
780 
782  {
783  }
784 
785  virtual
787  {
788  }
789 
790  // These methods are inherited from Function ...
791 
792  virtual XObjectPtr
793  execute(
794  XPathExecutionContext& executionContext,
795  XalanNode* context,
796  const XObjectArgVectorType& args,
797  const LocatorType* locator) const;
798 
799 #if !defined(XALAN_NO_USING_DECLARATION)
800  using ParentType::execute;
801 #endif
802 
803 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
804  virtual Function*
805 #else
806  virtual XalanEXSLTFunctionMin*
807 #endif
808  clone(MemoryManagerType& theManager) const
809  {
810  return XalanCopyConstruct(theManager, *this);
811  }
812 
813 protected:
814 
815  const XalanDOMString&
816  getError(XalanDOMString& theBuffer) const;
817 
818 private:
819 
820  // Not implemented...
822  operator=(const XalanEXSLTFunctionMin&);
823 
824  bool
825  operator==(const XalanEXSLTFunctionMin&) const;
826 };
827 
828 
829 
831 {
832 public:
833 
835 
837  {
838  }
839 
840  virtual
842  {
843  }
844 
845  // These methods are inherited from Function ...
846 
847  virtual XObjectPtr
848  execute(
849  XPathExecutionContext& executionContext,
850  XalanNode* context,
851  const XObjectArgVectorType& args,
852  const LocatorType* locator) const;
853 
854 #if !defined(XALAN_NO_USING_DECLARATION)
855  using ParentType::execute;
856 #endif
857 
858 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
859  virtual Function*
860 #else
861  virtual XalanEXSLTFunctionPower*
862 #endif
863  clone(MemoryManagerType& theManager) const
864  {
865  return XalanCopyConstruct(theManager, *this);
866  }
867 
868 protected:
869 
870  const XalanDOMString&
871  getError(XalanDOMString& theBuffer) const;
872 
873 private:
874 
875  // Not implemented...
877  operator=(const XalanEXSLTFunctionPower&);
878 
879  bool
880  operator==(const XalanEXSLTFunctionPower&) const;
881 };
882 
883 
884 
886 {
887 public:
888 
890 
892  {
893  }
894 
895  virtual
897  {
898  }
899 
900  // These methods are inherited from Function ...
901 
902  virtual XObjectPtr
903  execute(
904  XPathExecutionContext& executionContext,
905  XalanNode* context,
906  const XObjectArgVectorType& args,
907  const LocatorType* locator) const;
908 
909 #if !defined(XALAN_NO_USING_DECLARATION)
910  using ParentType::execute;
911 #endif
912 
913 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
914  virtual Function*
915 #else
916  virtual XalanEXSLTFunctionSin*
917 #endif
918  clone(MemoryManagerType& theManager) const
919  {
920  return XalanCopyConstruct(theManager, *this);
921  }
922 
923 protected:
924 
925  const XalanDOMString&
926  getError(XalanDOMString& theBuffer) const;
927 
928 private:
929 
930  // Not implemented...
932  operator=(const XalanEXSLTFunctionSin&);
933 
934  bool
935  operator==(const XalanEXSLTFunctionSin&) const;
936 };
937 
938 
939 
941 {
942 public:
943 
945 
947  {
948  }
949 
950  virtual
952  {
953  }
954 
955  // These methods are inherited from Function ...
956 
957  virtual XObjectPtr
958  execute(
959  XPathExecutionContext& executionContext,
960  XalanNode* context,
961  const XObjectArgVectorType& args,
962  const LocatorType* locator) const;
963 
964 #if !defined(XALAN_NO_USING_DECLARATION)
965  using ParentType::execute;
966 #endif
967 
968 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
969  virtual Function*
970 #else
971  virtual XalanEXSLTFunctionSqrt*
972 #endif
973  clone(MemoryManagerType& theManager) const
974  {
975  return XalanCopyConstruct(theManager, *this);
976  }
977 
978 protected:
979 
980  const XalanDOMString&
981  getError(XalanDOMString& theBuffer) const;
982 
983 private:
984 
985  // Not implemented...
987  operator=(const XalanEXSLTFunctionSqrt&);
988 
989  bool
990  operator==(const XalanEXSLTFunctionSqrt&) const;
991 };
992 
993 
994 
996 {
997 public:
998 
1000 
1002  {
1003  }
1004 
1005  virtual
1007  {
1008  }
1009 
1010  // These methods are inherited from Function ...
1011 
1012  virtual XObjectPtr
1013  execute(
1014  XPathExecutionContext& executionContext,
1015  XalanNode* context,
1016  const XObjectArgVectorType& args,
1017  const LocatorType* locator) const;
1018 
1019 #if !defined(XALAN_NO_USING_DECLARATION)
1020  using ParentType::execute;
1021 #endif
1022 
1023 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
1024  virtual Function*
1025 #else
1026  virtual XalanEXSLTFunctionTan*
1027 #endif
1028  clone(MemoryManagerType& theManager) const
1029  {
1030  return XalanCopyConstruct(theManager, *this);
1031  }
1032 
1033 protected:
1034 
1035  const XalanDOMString&
1036  getError(XalanDOMString& theBuffer) const;
1037 
1038 private:
1039 
1040  // Not implemented...
1042  operator=(const XalanEXSLTFunctionTan&);
1043 
1044  bool
1045  operator==(const XalanEXSLTFunctionTan&) const;
1046 };
1047 
1048 
1049 
1050 XALAN_CPP_NAMESPACE_END
1051 
1052 
1053 
1054 #endif // EXSLT_MATHIMPL_HEADER_GUARD_1357924680
XalanEXSLTFunctionAsin()
Definition: XalanEXSLTMathImpl.hpp:208
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:944
bool operator==(const XalanVector< Type > &theLHS, const XalanVector< Type > &theRHS)
Definition: XalanVector.hpp:1111
XalanEXSLTFunctionSin()
Definition: XalanEXSLTMathImpl.hpp:891
virtual XalanEXSLTFunctionRandom * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:125
virtual ~XalanEXSLTFunctionLog()
Definition: XalanEXSLTMathImpl.hpp:621
Definition: XalanNode.hpp:44
Definition: Function.hpp:52
Definition: XalanEXSLTMathImpl.hpp:312
XalanEXSLTFunctionRandom()
Definition: XalanEXSLTMathImpl.hpp:98
XalanEXSLTFunctionTan()
Definition: XalanEXSLTMathImpl.hpp:1001
XALAN_CPP_NAMESPACE_BEGIN typedef XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager MemoryManagerType
Definition: XalanMemoryManagement.hpp:39
virtual ~XalanEXSLTFunctionCos()
Definition: XalanEXSLTMathImpl.hpp:456
Definition: XalanEXSLTMathImpl.hpp:367
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:999
virtual XalanEXSLTFunctionExp * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:533
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:614
static XalanDOMString & getMessage(XalanDOMString &theResultMessage, XalanMessages::Codes msgToLoad, const char *repText1, const char *repText2=0, const char *repText3=0, const char *repText4=0)
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:96
Definition: XalanEXSLTMathImpl.hpp:995
Definition: XalanEXSLTMathImpl.hpp:610
XalanEXSLTFunctionAcos()
Definition: XalanEXSLTMathImpl.hpp:153
Definition: XalanEXSLTMathImpl.hpp:37
virtual XalanEXSLTFunctionLog * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:643
XalanEXSLTFunctionPower()
Definition: XalanEXSLTMathImpl.hpp:836
Definition: XalanEXSLTMathImpl.hpp:257
virtual const XalanDOMString & getError(XalanDOMString &theBuffer) const =0
Get the error message to report when the function is called with the wrong number of arguments...
virtual ~XalanEXSLTFunctionAtan()
Definition: XalanEXSLTMathImpl.hpp:268
virtual ~XalanEXSLTFunctionAbs()
Definition: XalanEXSLTMathImpl.hpp:48
virtual XObjectPtr execute(XPathExecutionContext &executionContext, XalanNode *context, const XObjectArgVectorType &args, const LocatorType *locator) const
Execute an XPath function object.
Class to hold XObjectPtr return types.
Definition: XObject.hpp:584
Type * XalanCopyConstruct(MemoryManager &theMemoryManager, const Type &theSource)
Definition: XalanMemoryManagement.hpp:334
virtual ~XalanEXSLTFunctionConstant()
Definition: XalanEXSLTMathImpl.hpp:378
Definition: XPathExecutionContext.hpp:72
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:206
virtual XalanEXSLTFunctionConstant * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:400
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:371
Definition: XalanEXSLTMathImpl.hpp:665
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:504
virtual ~XalanEXSLTFunctionSin()
Definition: XalanEXSLTMathImpl.hpp:896
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:724
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:151
virtual XalanEXSLTFunctionAcos * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:180
virtual XalanEXSLTFunctionMax * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:753
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:316
const XalanDOMString & getError(XalanDOMString &theBuffer) const
Get the error message to report when the function is called with the wrong number of arguments...
Definition: XalanEXSLTMathImpl.hpp:408
Definition: XalanEXSLTMathImpl.hpp:830
virtual ~XalanEXSLTFunctionLowest()
Definition: XalanEXSLTMathImpl.hpp:676
virtual XalanEXSLTFunctionCos * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:478
XalanEXSLTFunctionHighest()
Definition: XalanEXSLTMathImpl.hpp:561
XalanEXSLTFunctionLog()
Definition: XalanEXSLTMathImpl.hpp:616
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:779
virtual XalanEXSLTFunctionLowest * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:698
virtual ~XalanEXSLTFunctionAsin()
Definition: XalanEXSLTMathImpl.hpp:213
Definition: XalanEXSLTMathImpl.hpp:445
virtual ~XalanEXSLTFunctionHighest()
Definition: XalanEXSLTMathImpl.hpp:566
virtual XalanEXSLTFunctionAbs * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:70
virtual XalanEXSLTFunctionAtan2 * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:345
Definition: XalanEXSLTMathImpl.hpp:720
virtual ~XalanEXSLTFunctionRandom()
Definition: XalanEXSLTMathImpl.hpp:103
XERCES_CPP_NAMESPACE_QUALIFIER Locator LocatorType
Definition: FormatterListener.hpp:47
#define XALAN_EXSLT_EXPORT
Definition: XalanEXSLTDefinitions.hpp:33
virtual XalanEXSLTFunctionSin * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:918
XalanEXSLTFunctionAtan()
Definition: XalanEXSLTMathImpl.hpp:263
XalanEXSLTFunctionSqrt()
Definition: XalanEXSLTMathImpl.hpp:946
virtual XalanEXSLTFunctionTan * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:1028
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:834
Definition: XalanEXSLTMathImpl.hpp:555
XalanEXSLTFunctionConstant()
Definition: XalanEXSLTMathImpl.hpp:373
virtual ~XalanEXSLTFunctionSqrt()
Definition: XalanEXSLTMathImpl.hpp:951
virtual ~XalanEXSLTFunctionAtan2()
Definition: XalanEXSLTMathImpl.hpp:323
XalanEXSLTFunctionCos()
Definition: XalanEXSLTMathImpl.hpp:451
Definition: XalanEXSLTMathImpl.hpp:92
virtual XalanEXSLTFunctionMin * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:808
virtual ~XalanEXSLTFunctionPower()
Definition: XalanEXSLTMathImpl.hpp:841
XalanEXSLTFunctionAbs()
Definition: XalanEXSLTMathImpl.hpp:43
virtual XalanEXSLTFunctionAsin * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:235
virtual ~XalanEXSLTFunctionTan()
Definition: XalanEXSLTMathImpl.hpp:1006
Definition: XalanEXSLTMathImpl.hpp:147
virtual ~XalanEXSLTFunctionMin()
Definition: XalanEXSLTMathImpl.hpp:786
XalanEXSLTFunctionAtan2()
Definition: XalanEXSLTMathImpl.hpp:318
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:449
Definition: XalanDOMString.hpp:42
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:41
XalanEXSLTFunctionMax()
Definition: XalanEXSLTMathImpl.hpp:726
Definition: XalanEXSLTMathImpl.hpp:775
virtual XalanEXSLTFunctionAtan * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:290
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:559
Definition: XalanEXSLTMathImpl.hpp:885
XalanEXSLTFunctionExp()
Definition: XalanEXSLTMathImpl.hpp:506
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:669
XalanEXSLTFunctionLowest()
Definition: XalanEXSLTMathImpl.hpp:671
Definition: XalanEXSLTMathImpl.hpp:202
virtual ~XalanEXSLTFunctionAcos()
Definition: XalanEXSLTMathImpl.hpp:158
XalanEXSLTFunctionMin()
Definition: XalanEXSLTMathImpl.hpp:781
virtual ~XalanEXSLTFunctionMax()
Definition: XalanEXSLTMathImpl.hpp:731
virtual ~XalanEXSLTFunctionExp()
Definition: XalanEXSLTMathImpl.hpp:511
Definition: XalanEXSLTMathImpl.hpp:940
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:261
virtual XalanEXSLTFunctionSqrt * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:973
Definition: XalanEXSLTMathImpl.hpp:500
virtual XalanEXSLTFunctionPower * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:863
virtual XalanEXSLTFunctionHighest * clone(MemoryManagerType &theManager) const
Create a copy of the function object.
Definition: XalanEXSLTMathImpl.hpp:588
Function ParentType
Definition: XalanEXSLTMathImpl.hpp:889

Interpreting class diagrams

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

dot

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

Apache Logo