Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.11


XalanEXSLTMathImpl.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(EXSLT_MATHIMPL_HEADER_GUARD_1357924680)
19 #define EXSLT_MATHIMPL_HEADER_GUARD_1357924680
20 
21 
22 
24 
25 
26 
28 
29 
30 
32 
33 
34 
35 XALAN_CPP_NAMESPACE_BEGIN
36 
37 
38 
40 {
41 public:
42 
44 
46  {
47  }
48 
49  virtual
51  {
52  }
53 
54  // These methods are inherited from Function ...
55 
56  virtual XObjectPtr
57  execute(
58  XPathExecutionContext& executionContext,
59  XalanNode* context,
60  const XObjectArgVectorType& args,
61  const Locator* locator) const;
62 
63  using ParentType::execute;
64 
65 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
66  virtual Function*
67 #else
68  virtual XalanEXSLTFunctionAbs*
69 #endif
70  clone(MemoryManager& 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 Locator* locator) const;
115 
116  using ParentType::execute;
117 
118 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
119  virtual Function*
120 #else
121  virtual XalanEXSLTFunctionRandom*
122 #endif
123  clone(MemoryManager& theManager) const
124  {
125  return XalanCopyConstruct(theManager, *this);
126  }
127 
128 protected:
129 
130  const XalanDOMString&
131  getError(XalanDOMString& theBuffer) const;
132 
133 private:
134 
135  // Not implemented...
137  operator=(const XalanEXSLTFunctionRandom&);
138 
139  bool
140  operator==(const XalanEXSLTFunctionRandom&) const;
141 };
142 
143 
144 
146 {
147 public:
148 
150 
152  {
153  }
154 
155  virtual
157  {
158  }
159 
160  // These methods are inherited from Function ...
161 
162  virtual XObjectPtr
163  execute(
164  XPathExecutionContext& executionContext,
165  XalanNode* context,
166  const XObjectArgVectorType& args,
167  const Locator* locator) const;
168 
169  using ParentType::execute;
170 
171 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
172  virtual Function*
173 #else
174  virtual XalanEXSLTFunctionAcos*
175 #endif
176  clone(MemoryManager& theManager) const
177  {
178  return XalanCopyConstruct(theManager, *this);
179  }
180 
181 protected:
182 
183  const XalanDOMString&
184  getError(XalanDOMString& theBuffer) const;
185 
186 private:
187 
188  // Not implemented...
190  operator=(const XalanEXSLTFunctionAcos&);
191 
192  bool
193  operator==(const XalanEXSLTFunctionAcos&) const;
194 };
195 
196 
197 
199 {
200 public:
201 
203 
205  {
206  }
207 
208  virtual
210  {
211  }
212 
213  // These methods are inherited from Function ...
214 
215  virtual XObjectPtr
216  execute(
217  XPathExecutionContext& executionContext,
218  XalanNode* context,
219  const XObjectArgVectorType& args,
220  const Locator* locator) const;
221 
222  using ParentType::execute;
223 
224 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
225  virtual Function*
226 #else
227  virtual XalanEXSLTFunctionAsin*
228 #endif
229  clone(MemoryManager& theManager) const
230  {
231  return XalanCopyConstruct(theManager, *this);
232  }
233 
234 protected:
235 
236  const XalanDOMString&
237  getError(XalanDOMString& theBuffer) const;
238 
239 private:
240 
241  // Not implemented...
243  operator=(const XalanEXSLTFunctionAsin&);
244 
245  bool
246  operator==(const XalanEXSLTFunctionAsin&) const;
247 };
248 
249 
250 
252 {
253 public:
254 
256 
258  {
259  }
260 
261  virtual
263  {
264  }
265 
266  // These methods are inherited from Function ...
267 
268  virtual XObjectPtr
269  execute(
270  XPathExecutionContext& executionContext,
271  XalanNode* context,
272  const XObjectArgVectorType& args,
273  const Locator* locator) const;
274 
275  using ParentType::execute;
276 
277 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
278  virtual Function*
279 #else
280  virtual XalanEXSLTFunctionAtan*
281 #endif
282  clone(MemoryManager& theManager) const
283  {
284  return XalanCopyConstruct(theManager, *this);
285  }
286 
287 protected:
288 
289  const XalanDOMString&
290  getError(XalanDOMString& theBuffer) const;
291 
292 private:
293 
294  // Not implemented...
296  operator=(const XalanEXSLTFunctionAtan&);
297 
298  bool
299  operator==(const XalanEXSLTFunctionAtan&) const;
300 };
301 
302 
303 
305 {
306 public:
307 
309 
311  {
312  }
313 
314  virtual
316  {
317  }
318 
319  // These methods are inherited from Function ...
320 
321  virtual XObjectPtr
322  execute(
323  XPathExecutionContext& executionContext,
324  XalanNode* context,
325  const XObjectArgVectorType& args,
326  const Locator* locator) const;
327 
328  using ParentType::execute;
329 
330 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
331  virtual Function*
332 #else
333  virtual XalanEXSLTFunctionAtan2*
334 #endif
335  clone(MemoryManager& theManager) const
336  {
337  return XalanCopyConstruct(theManager, *this);
338  }
339 
340 protected:
341 
342  const XalanDOMString&
343  getError(XalanDOMString& theBuffer) const;
344 
345 private:
346 
347  // Not implemented...
349  operator=(const XalanEXSLTFunctionAtan2&);
350 
351  bool
352  operator==(const XalanEXSLTFunctionAtan2&) const;
353 };
354 
355 
356 
358 {
359 public:
360 
362 
364  {
365  }
366 
367  virtual
369  {
370  }
371 
372  // These methods are inherited from Function ...
373 
374  virtual XObjectPtr
375  execute(
376  XPathExecutionContext& executionContext,
377  XalanNode* context,
378  const XObjectArgVectorType& args,
379  const Locator* locator) const;
380 
381  using ParentType::execute;
382 
383 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
384  virtual Function*
385 #else
387 #endif
388  clone(MemoryManager& theManager) const
389  {
390  return XalanCopyConstruct(theManager, *this);
391  }
392 
393 protected:
394 
395  const XalanDOMString&
396  getError(XalanDOMString& theBuffer) const
397  {
399  theBuffer,
400  XalanMessages::EXSLTFunctionAcceptsTwoArguments_1Param,
401  "constant()");
402  }
403 
404 private:
405 
406  static const XalanDOMChar s_eString[];
407  static const XalanDOMChar s_ln10String[];
408  static const XalanDOMChar s_ln2String[];
409  static const XalanDOMChar s_log2EString[];
410  static const XalanDOMChar s_piString[];
411  static const XalanDOMChar s_sqrt1_2String[];
412  static const XalanDOMChar s_sqrt2String[];
413 
414  static const double s_eValues[];
415  static const double s_ln10Values[];
416  static const double s_ln2Values[];
417  static const double s_log2EValues[];
418  static const double s_piValues[];
419  static const double s_sqrt1_2Values[];
420  static const double s_sqrt2Values[];
421 
422 
423  // Not implemented...
425  operator=(const XalanEXSLTFunctionConstant&);
426 
427  bool
429 };
430 
431 
432 
434 {
435 public:
436 
438 
440  {
441  }
442 
443  virtual
445  {
446  }
447 
448  // These methods are inherited from Function ...
449 
450  virtual XObjectPtr
451  execute(
452  XPathExecutionContext& executionContext,
453  XalanNode* context,
454  const XObjectArgVectorType& args,
455  const Locator* locator) const;
456 
457  using ParentType::execute;
458 
459 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
460  virtual Function*
461 #else
462  virtual XalanEXSLTFunctionCos*
463 #endif
464  clone(MemoryManager& theManager) const
465  {
466  return XalanCopyConstruct(theManager, *this);
467  }
468 
469 protected:
470 
471  const XalanDOMString&
472  getError(XalanDOMString& theBuffer) const;
473 
474 private:
475 
476  // Not implemented...
478  operator=(const XalanEXSLTFunctionCos&);
479 
480  bool
481  operator==(const XalanEXSLTFunctionCos&) const;
482 };
483 
484 
485 
487 {
488 public:
489 
491 
493  {
494  }
495 
496  virtual
498  {
499  }
500 
501  // These methods are inherited from Function ...
502 
503  virtual XObjectPtr
504  execute(
505  XPathExecutionContext& executionContext,
506  XalanNode* context,
507  const XObjectArgVectorType& args,
508  const Locator* locator) const;
509 
510  using ParentType::execute;
511 
512 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
513  virtual Function*
514 #else
515  virtual XalanEXSLTFunctionExp*
516 #endif
517  clone(MemoryManager& theManager) const
518  {
519  return XalanCopyConstruct(theManager, *this);
520  }
521 
522 protected:
523 
524  const XalanDOMString&
525  getError(XalanDOMString& theBuffer) const;
526 
527 private:
528 
529  // Not implemented...
531  operator=(const XalanEXSLTFunctionExp&);
532 
533  bool
534  operator==(const XalanEXSLTFunctionExp&) const;
535 };
536 
537 
538 
540 {
541 public:
542 
544 
546  {
547  }
548 
549  virtual
551  {
552  }
553 
554  // These methods are inherited from Function ...
555 
556  virtual XObjectPtr
557  execute(
558  XPathExecutionContext& executionContext,
559  XalanNode* context,
560  const XObjectArgVectorType& args,
561  const Locator* locator) const;
562 
563  using ParentType::execute;
564 
565 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
566  virtual Function*
567 #else
569 #endif
570  clone(MemoryManager& theManager) const
571  {
572  return XalanCopyConstruct(theManager, *this);
573  }
574 
575 protected:
576 
577  const XalanDOMString&
578  getError(XalanDOMString& theBuffer) const;
579 
580 private:
581 
582  // Not implemented...
584  operator=(const XalanEXSLTFunctionHighest&);
585 
586  bool
588 };
589 
590 
591 
593 {
594 public:
595 
597 
599  {
600  }
601 
602  virtual
604  {
605  }
606 
607  // These methods are inherited from Function ...
608 
609  virtual XObjectPtr
610  execute(
611  XPathExecutionContext& executionContext,
612  XalanNode* context,
613  const XObjectArgVectorType& args,
614  const Locator* locator) const;
615 
616  using ParentType::execute;
617 
618 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
619  virtual Function*
620 #else
621  virtual XalanEXSLTFunctionLog*
622 #endif
623  clone(MemoryManager& theManager) const
624  {
625  return XalanCopyConstruct(theManager, *this);
626  }
627 
628 protected:
629 
630  const XalanDOMString&
631  getError(XalanDOMString& theBuffer) const;
632 
633 private:
634 
635  // Not implemented...
637  operator=(const XalanEXSLTFunctionLog&);
638 
639  bool
640  operator==(const XalanEXSLTFunctionLog&) const;
641 };
642 
643 
644 
646 {
647 public:
648 
650 
652  {
653  }
654 
655  virtual
657  {
658  }
659 
660  // These methods are inherited from Function ...
661 
662  virtual XObjectPtr
663  execute(
664  XPathExecutionContext& executionContext,
665  XalanNode* context,
666  const XObjectArgVectorType& args,
667  const Locator* locator) const;
668 
669  using ParentType::execute;
670 
671 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
672  virtual Function*
673 #else
674  virtual XalanEXSLTFunctionLowest*
675 #endif
676  clone(MemoryManager& theManager) const
677  {
678  return XalanCopyConstruct(theManager, *this);
679  }
680 
681 protected:
682 
683  const XalanDOMString&
684  getError(XalanDOMString& theBuffer) const;
685 
686 private:
687 
688  // Not implemented...
690  operator=(const XalanEXSLTFunctionLowest&);
691 
692  bool
693  operator==(const XalanEXSLTFunctionLowest&) const;
694 };
695 
696 
697 
699 {
700 public:
701 
703 
705  {
706  }
707 
708  virtual
710  {
711  }
712 
713  // These methods are inherited from Function ...
714 
715  virtual XObjectPtr
716  execute(
717  XPathExecutionContext& executionContext,
718  XalanNode* context,
719  const XObjectArgVectorType& args,
720  const Locator* locator) const;
721 
722  using ParentType::execute;
723 
724 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
725  virtual Function*
726 #else
727  virtual XalanEXSLTFunctionMax*
728 #endif
729  clone(MemoryManager& theManager) const
730  {
731  return XalanCopyConstruct(theManager, *this);
732  }
733 
734 protected:
735 
736  const XalanDOMString&
737  getError(XalanDOMString& theBuffer) const;
738 
739 private:
740 
741  // Not implemented...
743  operator=(const XalanEXSLTFunctionMax&);
744 
745  bool
746  operator==(const XalanEXSLTFunctionMax&) const;
747 };
748 
749 
750 
752 {
753 public:
754 
756 
758  {
759  }
760 
761  virtual
763  {
764  }
765 
766  // These methods are inherited from Function ...
767 
768  virtual XObjectPtr
769  execute(
770  XPathExecutionContext& executionContext,
771  XalanNode* context,
772  const XObjectArgVectorType& args,
773  const Locator* locator) const;
774 
775  using ParentType::execute;
776 
777 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
778  virtual Function*
779 #else
780  virtual XalanEXSLTFunctionMin*
781 #endif
782  clone(MemoryManager& theManager) const
783  {
784  return XalanCopyConstruct(theManager, *this);
785  }
786 
787 protected:
788 
789  const XalanDOMString&
790  getError(XalanDOMString& theBuffer) const;
791 
792 private:
793 
794  // Not implemented...
796  operator=(const XalanEXSLTFunctionMin&);
797 
798  bool
799  operator==(const XalanEXSLTFunctionMin&) const;
800 };
801 
802 
803 
805 {
806 public:
807 
809 
811  {
812  }
813 
814  virtual
816  {
817  }
818 
819  // These methods are inherited from Function ...
820 
821  virtual XObjectPtr
822  execute(
823  XPathExecutionContext& executionContext,
824  XalanNode* context,
825  const XObjectArgVectorType& args,
826  const Locator* locator) const;
827 
828  using ParentType::execute;
829 
830 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
831  virtual Function*
832 #else
833  virtual XalanEXSLTFunctionPower*
834 #endif
835  clone(MemoryManager& theManager) const
836  {
837  return XalanCopyConstruct(theManager, *this);
838  }
839 
840 protected:
841 
842  const XalanDOMString&
843  getError(XalanDOMString& theBuffer) const;
844 
845 private:
846 
847  // Not implemented...
849  operator=(const XalanEXSLTFunctionPower&);
850 
851  bool
852  operator==(const XalanEXSLTFunctionPower&) const;
853 };
854 
855 
856 
858 {
859 public:
860 
862 
864  {
865  }
866 
867  virtual
869  {
870  }
871 
872  // These methods are inherited from Function ...
873 
874  virtual XObjectPtr
875  execute(
876  XPathExecutionContext& executionContext,
877  XalanNode* context,
878  const XObjectArgVectorType& args,
879  const Locator* locator) const;
880 
881  using ParentType::execute;
882 
883 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
884  virtual Function*
885 #else
886  virtual XalanEXSLTFunctionSin*
887 #endif
888  clone(MemoryManager& theManager) const
889  {
890  return XalanCopyConstruct(theManager, *this);
891  }
892 
893 protected:
894 
895  const XalanDOMString&
896  getError(XalanDOMString& theBuffer) const;
897 
898 private:
899 
900  // Not implemented...
902  operator=(const XalanEXSLTFunctionSin&);
903 
904  bool
905  operator==(const XalanEXSLTFunctionSin&) const;
906 };
907 
908 
909 
911 {
912 public:
913 
915 
917  {
918  }
919 
920  virtual
922  {
923  }
924 
925  // These methods are inherited from Function ...
926 
927  virtual XObjectPtr
928  execute(
929  XPathExecutionContext& executionContext,
930  XalanNode* context,
931  const XObjectArgVectorType& args,
932  const Locator* locator) const;
933 
934  using ParentType::execute;
935 
936 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
937  virtual Function*
938 #else
939  virtual XalanEXSLTFunctionSqrt*
940 #endif
941  clone(MemoryManager& theManager) const
942  {
943  return XalanCopyConstruct(theManager, *this);
944  }
945 
946 protected:
947 
948  const XalanDOMString&
949  getError(XalanDOMString& theBuffer) const;
950 
951 private:
952 
953  // Not implemented...
955  operator=(const XalanEXSLTFunctionSqrt&);
956 
957  bool
958  operator==(const XalanEXSLTFunctionSqrt&) const;
959 };
960 
961 
962 
964 {
965 public:
966 
968 
970  {
971  }
972 
973  virtual
975  {
976  }
977 
978  // These methods are inherited from Function ...
979 
980  virtual XObjectPtr
981  execute(
982  XPathExecutionContext& executionContext,
983  XalanNode* context,
984  const XObjectArgVectorType& args,
985  const Locator* locator) const;
986 
987  using ParentType::execute;
988 
989 #if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
990  virtual Function*
991 #else
992  virtual XalanEXSLTFunctionTan*
993 #endif
994  clone(MemoryManager& theManager) const
995  {
996  return XalanCopyConstruct(theManager, *this);
997  }
998 
999 protected:
1000 
1001  const XalanDOMString&
1002  getError(XalanDOMString& theBuffer) const;
1003 
1004 private:
1005 
1006  // Not implemented...
1008  operator=(const XalanEXSLTFunctionTan&);
1009 
1010  bool
1011  operator==(const XalanEXSLTFunctionTan&) const;
1012 };
1013 
1014 
1015 
1016 XALAN_CPP_NAMESPACE_END
1017 
1018 
1019 
1020 #endif // EXSLT_MATHIMPL_HEADER_GUARD_1357924680
virtual XalanEXSLTFunctionTan * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionPower * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionExp * clone(MemoryManager &theManager) const
Create a copy of the function object.
static XalanDOMString & getMessage(XalanDOMString &theResultMessage, XalanMessages::Codes msgToLoad, const char *repText1, const char *repText2=0, const char *repText3=0, const char *repText4=0)
virtual XalanEXSLTFunctionSin * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionAcos * clone(MemoryManager &theManager) const
Create a copy of the function object.
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 XObjectPtr execute(XPathExecutionContext &executionContext, XalanNode *context, const XObjectArgVectorType &args, const Locator *locator) const
Execute an XPath function object.
Class to hold XObjectPtr return types.
Definition: XObject.hpp:883
virtual XalanEXSLTFunctionConstant * clone(MemoryManager &theManager) const
Create a copy of the function object.
Type * XalanCopyConstruct(MemoryManager &theMemoryManager, const Type &theSource)
virtual XalanEXSLTFunctionLowest * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionMin * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionRandom * clone(MemoryManager &theManager) const
Create a copy of the function object.
const XalanDOMString & getError(XalanDOMString &theBuffer) const
Get the error message to report when the function is called with the wrong number of arguments...
virtual XalanEXSLTFunctionMax * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionAsin * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionAtan2 * clone(MemoryManager &theManager) const
Create a copy of the function object.
#define XALAN_EXSLT_EXPORT
virtual XalanEXSLTFunctionAtan * clone(MemoryManager &theManager) const
Create a copy of the function object.
bool operator==(const ElemAttributeSet &theLHS, const ElemAttributeSet &theRHS)
virtual XalanEXSLTFunctionHighest * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionCos * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionAbs * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionLog * clone(MemoryManager &theManager) const
Create a copy of the function object.
virtual XalanEXSLTFunctionSqrt * clone(MemoryManager &theManager) const
Create a copy of the function object.

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