COPASI API  4.16.103
CCopasiXMLParser.h
Go to the documentation of this file.
1 // Copyright (C) 2010 - 2015 by Pedro Mendes, Virginia Tech Intellectual
2 // Properties, Inc., University of Heidelberg, and The University
3 // of Manchester.
4 // All rights reserved.
5 
6 // Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual
7 // Properties, Inc., EML Research, gGmbH, University of Heidelberg,
8 // and The University of Manchester.
9 // All rights reserved.
10 
11 // Copyright (C) 2003 - 2007 by Pedro Mendes, Virginia Tech Intellectual
12 // Properties, Inc. and EML Research, gGmbH.
13 // All rights reserved.
14 
15 /**
16  * CCopasiXMLParser class.
17  * This class is the parses a COPASI XML file.
18  *
19  * Created for COPASI by Stefan Hoops 2003
20  * Copyright Stefan Hoops
21  */
22 
23 #ifndef COPASI_CCopasiXMLParser
24 #define COPASI_CCopasiXMLParser
25 
26 #include <stack>
27 #include <map>
28 #include <string>
29 #include <sstream>
30 #include <vector>
31 
33 #include "copasi/xml/CXMLHandler.h"
38 
39 class CCompartment;
40 class CMetab;
41 class CModel;
42 class CModelEntity;
43 class CModelValue;
44 class CEvent;
45 class CEventAssignment;
46 class CReaction;
47 class CEvaluationTree;
48 class CFunction;
49 class CExpression;
50 class CFunctionParameter;
51 class CCopasiXMLParser;
55 class CPlotItem;
57 class CCopasiParameter;
59 class CVersion;
60 class CSlider;
61 class SCopasiXMLGUI;
63 class CCopasiTask;
65 class CLayout;
66 class CLCompartmentGlyph;
67 class CLMetabGlyph;
68 class CLReactionGlyph;
69 class CLGeneralGlyph;
70 class CLTextGlyph;
71 class CLGraphicalObject;
72 class CLCurve;
73 class CLLineSegment;
75 class CCopasiDataModel;
76 class CModelParameterSet;
78 class CModelParameter;
80 class CLGradientBase;
82 class CLStyle;
83 class CLGroup;
84 class CLText;
85 class CLRenderPoint;
86 
88 {
89 public:
90  // Operations
91  /**
92  * Default Constructor
93  */
95 
96  // Attributes
97  /**
98  * The version of the parsed file
99  */
101 
102  /**
103  * The model which is build during parsing.
104  */
106 
107  /**
108  * Storage for a comment.
109  */
110  std::string CharacterData;
111 
112  /**
113  * Storage for assignments.
114  */
115  std::vector<std::pair<std::string, std::string> > mAssignments;
116 
117  /**
118  * Pointer to a vector of functions which has been loaded or is to be saved.
119  * The ownership is handed to the user.
120  */
122 
123  /**
124  * Pointer to the currently processed function.
125  */
127 
128  /**
129  * Pointer to the currently processed function.
130  */
132 
133  /**
134  * The description of the function.
135  */
136  std::string FunctionDescription;
137 
138  /**
139  * Indicates whether the current function was already in the list;
140  */
142 
143  /**
144  * A map of new function to old keys parameter definitions
145  */
146  std::map< size_t, std::string > mFunctionParameterKeyMap;
147 
148  /**
149  * Pointer to the currently processed expression. This is only needed for old files
150  * containing the objective function as part of the list of function definitions
151  */
153 
154  /**
155  * A map of a key to the infix of the objective function. This is only needed for old files
156  * containing the objective function as part of the list of function definitions
157  */
158  std::map< std::string, CExpression * > mKey2ObjectiveFunction;
159 
160  /**
161  * Pointer to the currently processed reaction.
162  */
164 
165  /**
166  * Pointer to the currently processed event
167  */
169 
170  /**
171  * Pointer to the currently processed event assignment
172  */
174 
175  /**
176  * The keys of the source parameters for a call parameter.
177  */
178  std::map< std::string, std::vector< std::string > > SourceParameterKeys;
180  /**
181  * A map relating CopasiXML function keys with internal keys
182  */
183  // std::map< std::string, std::string > KeyMap;
185 
186  /**
187  * A map relating StateVariables to model entities.
188  */
189  std::vector< CModelEntity * > StateVariableList;
190 
191  /**
192  * Pointer to a vector of tasks which has been loaded or is to be saved.
193  * The ownership is handed to the user.
194  */
196 
197  /**
198  * Pointer to a vector of reports which has been loaded or is to be saved.
199  * The ownership is handed to the user.
200  */
202 
203  /**
204  * Pointer to a vector of plots which has been loaded or is to be saved.
205  * The ownership is handed to the user.
206  */
208 
209  /**
210  * Pointer to the currently processed report
211  */
214  /**
215  * Pointer to the currently processed task
216  */
219  /**
220  * Pointer to the currently processed parameter
221  */
223 
224  /**
225  * Stack of parameter groups which is needed since nesting
226  * of groups is possible.
227  */
228  std::stack< CCopasiParameterGroup * > ParameterGroupStack;
229 
230  /**
231  * Stack of Model Parameter Groups which is needed since nesting
232  * of groups is possible.
233  */
234  std::stack< CModelParameterGroup * > ModelParameterGroupStack;
235 
236  /**
237  * The currently handeled Model Parameter
238  */
240 
241  /**
242  * Pointer to the currently processed plot
243  */
245 
246  /**
247  * Pointer to the currently processed plot item.
248  */
250 
251  /**
252  * Pointer to the currently processed channel.
253  */
255 
256  /**
257  * Vector of parameters of type key which could not be updated due to missing target objects
258  * at time of read.
259  */
260  std::vector< std::string > UnmappedKeyParameters;
261 
262  /**
263  * Pointer to a list of Layouts which has been loaded or is to be saved.
264  * The ownership is handed to the user.
265  */
267 
268  /**
269  * Pointer to the currently processed layout
270  */
272 
277  //CLGraphicalObject * pAdditionalGO;
288  std::vector<CLRenderPoint*>* pListOfCurveElements;
289 
290  /**
291  * Nesting level of the currently processed parameter group
292  */
294 
295  /**
296  * A map that stores a vector of tasks that reference a certain key
297  * together with the key to the reference.
298  */
299  std::map<std::string , std::vector < CCopasiTask* > > taskReferenceMap;
300 
301  /**
302  * A map that stores a vector of pairs of header,body or footer addresses
303  * with the index together with the key to the reference.
304  */
305  std::map<std::string , std::vector < std::pair < std::vector <CRegisteredObjectName >*, size_t > > > reportReferenceMap;
306 
308 
309  /**
310  * A pointer to the datamodel.
311  */
313 };
314 
315 class CCopasiXMLParser : public CExpat
316 {
317  // Attributes
318 private:
319  /**
320  * Attributes accessible through the whole parser.
321  */
323 
324  /**
325  * The character data.
326  */
327  std::string mCharacterData;
328 
329  /**
330  * The character data.
331  */
333 
334  /**
335  * The element handler stack
336  */
337  std::stack< CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon > * > mElementHandlerStack;
338 
339 #ifdef COPASI_TEMPLATE
340  class TEMPLATEElement:
341  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
342  {
343  // Attributes
344  private:
345  /**
346  * Enum of invoked parsers
347  */
348  enum Element
349  {
350  TEMPLATE = 0,
351  etc
352  };
353 
354  // Operations
355  public:
356  /**
357  * Constructor
358  */
359  TEMPLATEElement(CCopasiXMLParser & parser,
360  SCopasiXMLParserCommon & common);
361 
362  /**
363  * Destructor
364  */
365  virtual ~TEMPLATEElement();
366 
367  /**
368  * Start element handler
369  * @param const XML_Char *pszName
370  * @param const XML_Char **papszAttrs
371  */
372  virtual void start(const XML_Char *pszName,
373  const XML_Char **papszAttrs);
374 
375  /**
376  * End element handler
377  * @param const XML_Char *pszName
378  */
379  virtual void end(const XML_Char *pszName);
380 
381  private:
382  /**
383  * A pointer to the etcElement handler
384  */
385  etcElement * mpetcElement;
386  };
387 
388 #endif // COPASI_TEMPLATE
389 
391  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
392  {
393  // Attributes
394  private:
395  /**
396  * Enum of invoked parsers
397  */
398  enum Element
399  {
401  };
402 
403  /**
404  * The line number the unknown element was encountered.
405  */
406  size_t mLineNumber;
407 
408  // Operations
409  public:
410  /**
411  * Constructor
412  */
414  SCopasiXMLParserCommon & common);
415 
416  /**
417  * Destructor
418  */
419  virtual ~UnknownElement();
420 
421  /**
422  * Start element handler
423  * @param const XML_Char *pszName
424  * @param const XML_Char **papszAttrs
425  */
426  virtual void start(const XML_Char *pszName,
427  const XML_Char **papszAttrs);
428 
429  /**
430  * End element handler
431  * @param const XML_Char *pszName
432  */
433  virtual void end(const XML_Char *pszName);
434  };
435 
436 public:
437  /**
438  * The unknown element handler
439  */
441 
442 private:
443 
444  class CharacterDataElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
445  {
446  // Attributes
447  private:
448  /**
449  * Text
450  */
451  enum Element
452  {
454  };
455 
456  // Operations
457  public:
458  /**
459  * Constructor
460  */
462  SCopasiXMLParserCommon & common);
463 
464  /**
465  * Destructor
466  */
467  virtual ~CharacterDataElement();
468 
469  /**
470  * Start element handler
471  * @param const XML_Char *pszName
472  * @param const XML_Char **papszAttrs
473  */
474  virtual void start(const XML_Char *pszName,
475  const XML_Char **papszAttrs);
476 
477  /**
478  * End element handler
479  * @param const XML_Char *pszName
480  */
481  virtual void end(const XML_Char *pszName);
482 
483  private:
484  std::string mCurrentElementName;
485  };
486 
487 public:
488  /**
489  * The character data element handler
490  */
492 
494 
496 
497 private:
498 
500  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
501  {
502  // Attributes
503  private:
504  /**
505  * Enum of invoked parsers
506  */
507  enum Element
508  {
511  };
512 
513  // Operations
514  public:
515  /**
516  * Constructor
517  */
519  SCopasiXMLParserCommon & common);
520 
521  /**
522  * Destructor
523  */
524  virtual ~InitialStateElement();
525 
526  /**
527  * Start element handler
528  * @param const XML_Char *pszName
529  * @param const XML_Char **papszAttrs
530  */
531  virtual void start(const XML_Char *pszName,
532  const XML_Char **papszAttrs);
533 
534  /**
535  * End element handler
536  * @param const XML_Char *pszName
537  */
538  virtual void end(const XML_Char *pszName);
539  };
540 
542  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
543  {
544  // Attributes
545  private:
546  /**
547  * Enum of invoked parsers
548  */
549  enum Element
550  {
552  };
553 
554  // Operations
555  public:
556  /**
557  * Constructor
558  */
560  SCopasiXMLParserCommon & common);
561 
562  /**
563  * Destructor
564  */
566 
567  /**
568  * Start element handler
569  * @param const XML_Char *pszName
570  * @param const XML_Char **papszAttrs
571  */
572  virtual void start(const XML_Char *pszName,
573  const XML_Char **papszAttrs);
574 
575  /**
576  * End element handler
577  * @param const XML_Char *pszName
578  */
579  virtual void end(const XML_Char *pszName);
580  };
581 
583  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
584  {
585  // Attributes
586  private:
587  /**
588  * Enum of invoked parsers
589  */
590  enum Element
591  {
594  };
595 
596  // Operations
597  public:
598  /**
599  * Constructor
600  */
602  SCopasiXMLParserCommon & common);
603 
604  /**
605  * Destructor
606  */
607  virtual ~StateTemplateElement();
608 
609  /**
610  * Start element handler
611  * @param const XML_Char *pszName
612  * @param const XML_Char **papszAttrs
613  */
614  virtual void start(const XML_Char *pszName,
615  const XML_Char **papszAttrs);
616 
617  /**
618  * End element handler
619  * @param const XML_Char *pszName
620  */
621  virtual void end(const XML_Char *pszName);
622  };
623 
625  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
626  {
627  // Attributes
628  private:
629  /**
630  * Enum of invoked parsers
631  */
632  enum Element
633  {
635  };
636 
637  // Operations
638  public:
639  /**
640  * Constructor
641  */
643  SCopasiXMLParserCommon & common);
644 
645  /**
646  * Destructor
647  */
648  virtual ~SourceParameterElement();
649 
650  /**
651  * Start element handler
652  * @param const XML_Char *pszName
653  * @param const XML_Char **papszAttrs
654  */
655  virtual void start(const XML_Char *pszName,
656  const XML_Char **papszAttrs);
657 
658  /**
659  * End element handler
660  * @param const XML_Char *pszName
661  */
662  virtual void end(const XML_Char *pszName);
663  };
664 
666  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
667  {
668  // Attributes
669  private:
670  /**
671  * Enum of invoked parsers
672  */
673  enum Element
674  {
677  };
678 
679  // Operations
680  public:
681  /**
682  * Constructor
683  */
685  SCopasiXMLParserCommon & common);
686 
687  /**
688  * Destructor
689  */
690  virtual ~CallParameterElement();
691 
692  /**
693  * Start element handler
694  * @param const XML_Char *pszName
695  * @param const XML_Char **papszAttrs
696  */
697  virtual void start(const XML_Char *pszName,
698  const XML_Char **papszAttrs);
699 
700  /**
701  * End element handler
702  * @param const XML_Char *pszName
703  */
704  virtual void end(const XML_Char *pszName);
705  };
706 
708  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
709  {
710  // Attributes
711  private:
712  /**
713  * Enum of invoked parsers
714  */
715  enum Element
716  {
719  };
720 
721  // Operations
722  public:
723  /**
724  * Constructor
725  */
727  SCopasiXMLParserCommon & common);
728 
729  /**
730  * Destructor
731  */
733 
734  /**
735  * Start element handler
736  * @param const XML_Char *pszName
737  * @param const XML_Char **papszAttrs
738  */
739  virtual void start(const XML_Char *pszName,
740  const XML_Char **papszAttrs);
741 
742  /**
743  * End element handler
744  * @param const XML_Char *pszName
745  */
746  virtual void end(const XML_Char *pszName);
747  };
748 
750  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
751  {
752  // Attributes
753  private:
754  /**
755  * Enum of invoked parsers
756  */
757  enum Element
758  {
761  };
762 
763  // Operations
764  public:
765  /**
766  * Constructor
767  */
769  SCopasiXMLParserCommon & common);
770 
771  /**
772  * Destructor
773  */
774  virtual ~KineticLawElement();
775 
776  /**
777  * Start element handler
778  * @param const XML_Char *pszName
779  * @param const XML_Char **papszAttrs
780  */
781  virtual void start(const XML_Char *pszName,
782  const XML_Char **papszAttrs);
783 
784  /**
785  * End element handler
786  * @param const XML_Char *pszName
787  */
788  virtual void end(const XML_Char *pszName);
789  };
790 
792  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
793  {
794  // Attributes
795  private:
796  /**
797  * Enum of invoked parsers
798  */
799  enum Element
800  {
802  };
803 
804  // Operations
805  public:
806  /**
807  * Constructor
808  */
810  SCopasiXMLParserCommon & common);
811 
812  /**
813  * Destructor
814  */
815  virtual ~ConstantElement();
816 
817  /**
818  * Start element handler
819  * @param const XML_Char *pszName
820  * @param const XML_Char **papszAttrs
821  */
822  virtual void start(const XML_Char *pszName,
823  const XML_Char **papszAttrs);
824 
825  /**
826  * End element handler
827  * @param const XML_Char *pszName
828  */
829  virtual void end(const XML_Char *pszName);
830  };
831 
833  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
834  {
835  // Attributes
836  private:
837  /**
838  * Enum of invoked parsers
839  */
840  enum Element
841  {
844  };
845 
846  // Operations
847  public:
848  /**
849  * Constructor
850  */
852  SCopasiXMLParserCommon & common);
853 
854  /**
855  * Destructor
856  */
857  virtual ~ListOfConstantsElement();
858 
859  /**
860  * Start element handler
861  * @param const XML_Char *pszName
862  * @param const XML_Char **papszAttrs
863  */
864  virtual void start(const XML_Char *pszName,
865  const XML_Char **papszAttrs);
866 
867  /**
868  * End element handler
869  * @param const XML_Char *pszName
870  */
871  virtual void end(const XML_Char *pszName);
872  };
873 
875  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
876  {
877  // Attributes
878  private:
879  /**
880  * Enum of invoked parsers
881  */
882  enum Element
883  {
885  };
886 
887  // Operations
888  public:
889  /**
890  * Constructor
891  */
893  SCopasiXMLParserCommon & common);
894 
895  /**
896  * Destructor
897  */
898  virtual ~ModifierElement();
899 
900  /**
901  * Start element handler
902  * @param const XML_Char *pszName
903  * @param const XML_Char **papszAttrs
904  */
905  virtual void start(const XML_Char *pszName,
906  const XML_Char **papszAttrs);
907 
908  /**
909  * End element handler
910  * @param const XML_Char *pszName
911  */
912  virtual void end(const XML_Char *pszName);
913  };
914 
916  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
917  {
918  // Attributes
919  private:
920  /**
921  * Enum of invoked parsers
922  */
923  enum Element
924  {
927  };
928 
929  // Operations
930  public:
931  /**
932  * Constructor
933  */
935  SCopasiXMLParserCommon & common);
936 
937  /**
938  * Destructor
939  */
940  virtual ~ListOfModifiersElement();
941 
942  /**
943  * Start element handler
944  * @param const XML_Char *pszName
945  * @param const XML_Char **papszAttrs
946  */
947  virtual void start(const XML_Char *pszName,
948  const XML_Char **papszAttrs);
949 
950  /**
951  * End element handler
952  * @param const XML_Char *pszName
953  */
954  virtual void end(const XML_Char *pszName);
955  };
956 
958  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
959  {
960  // Attributes
961  private:
962  /**
963  * Enum of invoked parsers
964  */
965  enum Element
966  {
968  };
969 
970  // Operations
971  public:
972  /**
973  * Constructor
974  */
976  SCopasiXMLParserCommon & common);
977 
978  /**
979  * Destructor
980  */
981  virtual ~ProductElement();
982 
983  /**
984  * Start element handler
985  * @param const XML_Char *pszName
986  * @param const XML_Char **papszAttrs
987  */
988  virtual void start(const XML_Char *pszName,
989  const XML_Char **papszAttrs);
990 
991  /**
992  * End element handler
993  * @param const XML_Char *pszName
994  */
995  virtual void end(const XML_Char *pszName);
996  };
997 
999  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1000  {
1001  // Attributes
1002  private:
1003  /**
1004  * Enum of invoked parsers
1005  */
1006  enum Element
1007  {
1010  };
1011 
1012  // Operations
1013  public:
1014  /**
1015  * Constructor
1016  */
1018  SCopasiXMLParserCommon & common);
1019 
1020  /**
1021  * Destructor
1022  */
1023  virtual ~ListOfProductsElement();
1024 
1025  /**
1026  * Start element handler
1027  * @param const XML_Char *pszName
1028  * @param const XML_Char **papszAttrs
1029  */
1030  virtual void start(const XML_Char *pszName,
1031  const XML_Char **papszAttrs);
1032 
1033  /**
1034  * End element handler
1035  * @param const XML_Char *pszName
1036  */
1037  virtual void end(const XML_Char *pszName);
1038  };
1039 
1041  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1042  {
1043  // Attributes
1044  private:
1045  /**
1046  * Enum of invoked parsers
1047  */
1048  enum Element
1049  {
1051  };
1052 
1053  // Operations
1054  public:
1055  /**
1056  * Constructor
1057  */
1059  SCopasiXMLParserCommon & common);
1060 
1061  /**
1062  * Destructor
1063  */
1064  virtual ~SubstrateElement();
1065 
1066  /**
1067  * Start element handler
1068  * @param const XML_Char *pszName
1069  * @param const XML_Char **papszAttrs
1070  */
1071  virtual void start(const XML_Char *pszName,
1072  const XML_Char **papszAttrs);
1073 
1074  /**
1075  * End element handler
1076  * @param const XML_Char *pszName
1077  */
1078  virtual void end(const XML_Char *pszName);
1079  };
1080 
1082  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1083  {
1084  // Attributes
1085  private:
1086  /**
1087  * Enum of invoked parsers
1088  */
1089  enum Element
1090  {
1093  };
1094 
1095  // Operations
1096  public:
1097  /**
1098  * Constructor
1099  */
1101  SCopasiXMLParserCommon & common);
1102 
1103  /**
1104  * Destructor
1105  */
1106  virtual ~ListOfSubstratesElement();
1107 
1108  /**
1109  * Start element handler
1110  * @param const XML_Char *pszName
1111  * @param const XML_Char **papszAttrs
1112  */
1113  virtual void start(const XML_Char *pszName,
1114  const XML_Char **papszAttrs);
1115 
1116  /**
1117  * End element handler
1118  * @param const XML_Char *pszName
1119  */
1120  virtual void end(const XML_Char *pszName);
1121  };
1122 
1124  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1125  {
1126  // Attributes
1127  private:
1128  /**
1129  * Enum of invoked parsers
1130  */
1131  enum Element
1132  {
1142  };
1143 
1144  /**
1145  * Pointer to ListOfSubstratesElement element handler.
1146  */
1148 
1149  /**
1150  * Pointer to ListOfProductsElement element handler.
1151  */
1153 
1154  /**
1155  * Pointer to ListOfModifiersElement element handler.
1156  */
1158 
1159  /**
1160  * Pointer to ListOfConstantsElement element handler.
1161  */
1163 
1164  /**
1165  * Pointer to ListOfConstantsElement element handler.
1166  */
1168 
1169  /**
1170  * The key in the CopasiML gile
1171  */
1172  std::string mKey;
1173 
1174  // Operations
1175  public:
1176  /**
1177  * Constructor
1178  */
1180  SCopasiXMLParserCommon & common);
1181 
1182  /**
1183  * Destructor
1184  */
1185  virtual ~ReactionElement();
1186 
1187  /**
1188  * Start element handler
1189  * @param const XML_Char *pszName
1190  * @param const XML_Char **papszAttrs
1191  */
1192  virtual void start(const XML_Char *pszName,
1193  const XML_Char **papszAttrs);
1194 
1195  /**
1196  * End element handler
1197  * @param const XML_Char *pszName
1198  */
1199  virtual void end(const XML_Char *pszName);
1200  };
1201 
1203  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1204  {
1205  // Attributes
1206  private:
1207  /**
1208  * Enum of invoked parsers
1209  */
1210  enum Element
1211  {
1214  };
1215 
1216  // Operations
1217  public:
1218  /**
1219  * Constructor
1220  */
1222  SCopasiXMLParserCommon & common);
1223 
1224  /**
1225  * Destructor
1226  */
1227  virtual ~ListOfReactionsElement();
1228 
1229  /**
1230  * Start element handler
1231  * @param const XML_Char *pszName
1232  * @param const XML_Char **papszAttrs
1233  */
1234  virtual void start(const XML_Char *pszName,
1235  const XML_Char **papszAttrs);
1236 
1237  /**
1238  * End element handler
1239  * @param const XML_Char *pszName
1240  */
1241  virtual void end(const XML_Char *pszName);
1242  };
1243 
1245  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1246  {
1247  // Attributes
1248  private:
1249  /**
1250  * Enum of invoked parsers
1251  */
1252  enum Element
1253  {
1260  };
1261 
1262  // Operations
1263  public:
1264  /**
1265  * Constructor
1266  */
1268  SCopasiXMLParserCommon & common);
1269 
1270  /**
1271  * Destructor
1272  */
1273  virtual ~MetaboliteElement();
1274 
1275  /**
1276  * Start element handler
1277  * @param const XML_Char *pszName
1278  * @param const XML_Char **papszAttrs
1279  */
1280  virtual void start(const XML_Char *pszName,
1281  const XML_Char **papszAttrs);
1282 
1283  /**
1284  * End element handler
1285  * @param const XML_Char *pszName
1286  */
1287  virtual void end(const XML_Char *pszName);
1288 
1289  private:
1290  /**
1291  * A pointer to the current metabolite.
1292  */
1294 
1295  /**
1296  * The key in the CopasiML file
1297  */
1298  std::string mKey;
1299  };
1300 
1302  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1303  {
1304  // Attributes
1305  private:
1306  /**
1307  * Enum of invoked parsers
1308  */
1309  enum Element
1310  {
1313  };
1314 
1315  // Operations
1316  public:
1317  /**
1318  * Constructor
1319  */
1321  SCopasiXMLParserCommon & common);
1322 
1323  /**
1324  * Destructor
1325  */
1326  virtual ~ListOfMetabolitesElement();
1327 
1328  /**
1329  * Start element handler
1330  * @param const XML_Char *pszName
1331  * @param const XML_Char **papszAttrs
1332  */
1333  virtual void start(const XML_Char *pszName,
1334  const XML_Char **papszAttrs);
1335 
1336  /**
1337  * End element handler
1338  * @param const XML_Char *pszName
1339  */
1340  virtual void end(const XML_Char *pszName);
1341  };
1342 
1344  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1345  {
1346  // Attributes
1347  private:
1348  /**
1349  * Enum of invoked parsers
1350  */
1351  enum Element
1352  {
1359  };
1360 
1361  // Operations
1362  public:
1363  /**
1364  * Constructor
1365  */
1367  SCopasiXMLParserCommon & common);
1368 
1369  /**
1370  * Destructor
1371  */
1372  virtual ~CompartmentElement();
1373 
1374  /**
1375  * Start element handler
1376  * @param const XML_Char *pszName
1377  * @param const XML_Char **papszAttrs
1378  */
1379  virtual void start(const XML_Char *pszName,
1380  const XML_Char **papszAttrs);
1381 
1382  /**
1383  * End element handler
1384  * @param const XML_Char *pszName
1385  */
1386  virtual void end(const XML_Char *pszName);
1387 
1388  private:
1389  /**
1390  * A pointer to the current compartment
1391  */
1393 
1394  /**
1395  * The key in the CopasiML file
1396  */
1397  std::string mKey;
1398  };
1399 
1401  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1402  {
1403  // Attributes
1404  private:
1405  /**
1406  * Enum of invoked parsers
1407  */
1408  enum Element
1409  {
1412  };
1413 
1414  // Operations
1415  public:
1416  /**
1417  * Constructor
1418  */
1420  SCopasiXMLParserCommon & common);
1421 
1422  /**
1423  * Destructor
1424  */
1425  virtual ~ListOfCompartmentsElement();
1426 
1427  /**
1428  * Start element handler
1429  * @param const XML_Char *pszName
1430  * @param const XML_Char **papszAttrs
1431  */
1432  virtual void start(const XML_Char *pszName,
1433  const XML_Char **papszAttrs);
1434 
1435  /**
1436  * End element handler
1437  * @param const XML_Char *pszName
1438  */
1439  virtual void end(const XML_Char *pszName);
1440  };
1441 
1442  class MathMLElement;
1443 
1445  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1446  {
1447  // Attributes
1448  private:
1449  /**
1450  * Enum of invoked parsers
1451  */
1452  enum Element
1453  {
1461  };
1462 
1465 
1466  /**
1467  * The key in the CopasiML file
1468  */
1469  std::string mKey;
1470 
1471  // Operations
1472  public:
1473  /**
1474  * Constructor
1475  */
1477  SCopasiXMLParserCommon & common);
1478 
1479  /**
1480  * Destructor
1481  */
1482  virtual ~ModelValueElement();
1483 
1484  /**
1485  * Start element handler
1486  * @param const XML_Char *pszName
1487  * @param const XML_Char **papszAttrs
1488  */
1489  virtual void start(const XML_Char *pszName,
1490  const XML_Char **papszAttrs);
1491 
1492  /**
1493  * End element handler
1494  * @param const XML_Char *pszName
1495  */
1496  virtual void end(const XML_Char *pszName);
1497  };
1498 
1500  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1501  {
1502  // Attributes
1503  private:
1504  /**
1505  * Enum of invoked parsers
1506  */
1507  enum Element
1508  {
1511  };
1512 
1513  // Operations
1514  public:
1515  /**
1516  * Constructor
1517  */
1519  SCopasiXMLParserCommon & common);
1520 
1521  /**
1522  * Destructor
1523  */
1524  virtual ~ListOfModelValuesElement();
1525 
1526  /**
1527  * Start element handler
1528  * @param const XML_Char *pszName
1529  * @param const XML_Char **papszAttrs
1530  */
1531  virtual void start(const XML_Char *pszName,
1532  const XML_Char **papszAttrs);
1533 
1534  /**
1535  * End element handler
1536  * @param const XML_Char *pszName
1537  */
1538  virtual void end(const XML_Char *pszName);
1539  };
1540 
1542  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1543  {
1544  // Attributes
1545  private:
1546  /**
1547  * Enum of invoked parsers
1548  */
1549  enum Element
1550  {
1553  };
1554 
1555  // Operations
1556  public:
1557  /**
1558  * Constructor
1559  */
1561  SCopasiXMLParserCommon & common);
1562 
1563  /**
1564  * Destructor
1565  */
1566  virtual ~ListOfAssignmentsElement();
1567 
1568  /**
1569  * Start element handler
1570  * @param const XML_Char *pszName
1571  * @param const XML_Char **papszAttrs
1572  */
1573  virtual void start(const XML_Char *pszName,
1574  const XML_Char **papszAttrs);
1575 
1576  /**
1577  * End element handler
1578  * @param const XML_Char *pszName
1579  */
1580  virtual void end(const XML_Char *pszName);
1581 
1582  // std::vector<std::pair<std::string, std::string> > mAssignments;
1583  };
1584 
1586  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1587  {
1588  // Attributes
1589  private:
1590  /**
1591  * Enum of invoked parsers
1592  */
1593  enum Element
1594  {
1595  Event = 0,
1602  };
1603 
1604  /**
1605  * The key in the CopasiML file
1606  */
1607  std::string mKey;
1608 
1610 
1611  // Operations
1612  public:
1613  /**
1614  * Constructor
1615  */
1616  EventElement(CCopasiXMLParser & parser,
1617  SCopasiXMLParserCommon & common);
1618 
1619  /**
1620  * Destructor
1621  */
1622  virtual ~EventElement();
1623 
1624  /**
1625  * Start element handler
1626  * @param const XML_Char *pszName
1627  * @param const XML_Char **papszAttrs
1628  */
1629  virtual void start(const XML_Char *pszName,
1630  const XML_Char **papszAttrs);
1631 
1632  /**
1633  * End element handler
1634  * @param const XML_Char *pszName
1635  */
1636  virtual void end(const XML_Char *pszName);
1637  };
1638 
1640  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1641  {
1642  // Attributes
1643  private:
1644  /**
1645  * Enum of invoked parsers
1646  */
1647  enum Element
1648  {
1651  };
1652 
1653  /**
1654  * A set of event orders used to enforce uniqueness
1655  */
1656  std::set< size_t > mEventOrders;
1657 
1658  // Operations
1659  public:
1660  /**
1661  * Constructor
1662  */
1664  SCopasiXMLParserCommon & common);
1665 
1666  /**
1667  * Destructor
1668  */
1669  virtual ~ListOfEventsElement();
1670 
1671  /**
1672  * Start element handler
1673  * @param const XML_Char *pszName
1674  * @param const XML_Char **papszAttrs
1675  */
1676  virtual void start(const XML_Char *pszName,
1677  const XML_Char **papszAttrs);
1678 
1679  /**
1680  * End element handler
1681  * @param const XML_Char *pszName
1682  */
1683  virtual void end(const XML_Char *pszName);
1684  };
1685 
1687  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1688  {
1689  // Attributes
1690  private:
1691  /**
1692  * Enum of invoked parsers
1693  */
1694  enum Element
1695  {
1698  };
1699 
1700  /**
1701  * The key in the CopasiML file
1702  */
1703  std::string mKey;
1704 
1705  std::pair<std::string, std::string> mAssignmentPair;
1706  // Operations
1707  public:
1708  /**
1709  * Constructor
1710  */
1712  SCopasiXMLParserCommon & common);
1713 
1714  /**
1715  * Destructor
1716  */
1717  virtual ~AssignmentElement();
1718 
1719  /**
1720  * Start element handler
1721  * @param const XML_Char *pszName
1722  * @param const XML_Char **papszAttrs
1723  */
1724  virtual void start(const XML_Char *pszName,
1725  const XML_Char **papszAttrs);
1726 
1727  /**
1728  * End element handler
1729  * @param const XML_Char *pszName
1730  */
1731  virtual void end(const XML_Char *pszName);
1732  };
1733 
1735  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1736  {
1737  // Attributes
1738  private:
1739  /**
1740  * Enum of invoked parsers
1741  */
1742  enum Element
1743  {
1744  Comment = 0,
1746  };
1747 
1748  /**
1749  * String stream to handle xhtml comments
1750  */
1751  std::ostringstream mXhtml;
1752 
1753  /**
1754  * The level of nested xhtml elements.
1755  */
1756  size_t mLevel;
1757 
1758  /**
1759  * Information whether an element is empty
1760  */
1761  std::stack< bool > mElementEmpty;
1762 
1763  // Operations
1764  public:
1765  /**
1766  * Constructor
1767  */
1769  SCopasiXMLParserCommon & common);
1770 
1771  /**
1772  * Destructor
1773  */
1774  virtual ~CommentElement();
1775 
1776  /**
1777  * Start element handler
1778  * @param const XML_Char *pszName
1779  * @param const XML_Char **papszAttrs
1780  */
1781  virtual void start(const XML_Char *pszName,
1782  const XML_Char **papszAttrs);
1783 
1784  /**
1785  * End element handler
1786  * @param const XML_Char *pszName
1787  */
1788  virtual void end(const XML_Char *pszName);
1789  };
1790 
1791 public:
1792  /**
1793  * The comment element handler
1794  */
1796 
1797 private:
1799 
1800 private:
1802  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1803  {
1804  // Attributes
1805  private:
1806  /**
1807  * Enum of invoked parsers
1808  */
1809  enum Element
1810  {
1811  Model = 0,
1824  };
1825 
1826  /**
1827  * The key in the CopasiML file
1828  */
1829  std::string mKey;
1830 
1831  // Operations
1832  public:
1833  /**
1834  * Constructor
1835  */
1836  ModelElement(CCopasiXMLParser & parser,
1837  SCopasiXMLParserCommon & common);
1838 
1839  /**
1840  * Destructor
1841  */
1842  virtual ~ModelElement();
1843 
1844  /**
1845  * Start element handler
1846  * @param const XML_Char *pszName
1847  * @param const XML_Char **papszAttrs
1848  */
1849  virtual void start(const XML_Char *pszName,
1850  const XML_Char **papszAttrs);
1851 
1852  /**
1853  * End element handler
1854  * @param const XML_Char *pszName
1855  */
1856  virtual void end(const XML_Char *pszName);
1857  };
1858 
1859  class ChannelSpecElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1860  {
1861  // Attributes
1862  private:
1863  /**
1864  *
1865  */
1866  enum Element
1867  {
1869  };
1870 
1871  // Operations
1872  public:
1873  /**
1874  * Constructor
1875  */
1877  SCopasiXMLParserCommon & common);
1878 
1879  /**
1880  * Destructor
1881  */
1882  virtual ~ChannelSpecElement();
1883 
1884  /**
1885  * Start element handler
1886  * @param const XML_Char *pszName
1887  * @param const XML_Char **papszAttrs
1888  */
1889  virtual void start(const XML_Char *pszName,
1890  const XML_Char **papszAttrs);
1891 
1892  /**
1893  * End element handler
1894  * @param const XML_Char *pszName
1895  */
1896  virtual void end(const XML_Char *pszName);
1897  };
1898 
1899  class PlotItemElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1900  {
1901  // Attributes
1902  private:
1903  /**
1904  *
1905  */
1906  enum Element
1907  {
1912  };
1913 
1914  /**
1915  * Pointer to the Parameter Element Handler
1916  */
1918 
1919  /**
1920  * Pointer to the Parameter Group Element Handler
1921  */
1923 
1924  /**
1925  * Pointer to the List Of Channels Element Handler
1926  */
1928 
1929  /**
1930  * The line number the unknown parameter was encountered.
1931  */
1932  size_t mLineNumber;
1933 
1934  // Operations
1935  public:
1936  /**
1937  * Constructor
1938  */
1940  SCopasiXMLParserCommon & common);
1941 
1942  /**
1943  * Destructor
1944  */
1945  virtual ~PlotItemElement();
1946 
1947  /**
1948  * Start element handler
1949  * @param const XML_Char *pszName
1950  * @param const XML_Char **papszAttrs
1951  */
1952  virtual void start(const XML_Char *pszName,
1953  const XML_Char **papszAttrs);
1954 
1955  /**
1956  * End element handler
1957  * @param const XML_Char *pszName
1958  */
1959  virtual void end(const XML_Char *pszName);
1960  };
1961 
1962  class ListOfChannelsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
1963  {
1964  // Attributes
1965  private:
1966  /**
1967  *
1968  */
1969  enum Element
1970  {
1973  };
1974 
1975  // Operations
1976  public:
1977  /**
1978  * Constructor
1979  */
1981  SCopasiXMLParserCommon & common);
1982 
1983  /**
1984  * Destructor
1985  */
1986  virtual ~ListOfChannelsElement();
1987 
1988  /**
1989  * Start element handler
1990  * @param const XML_Char *pszName
1991  * @param const XML_Char **papszAttrs
1992  */
1993  virtual void start(const XML_Char *pszName,
1994  const XML_Char **papszAttrs);
1995 
1996  /**
1997  * End element handler
1998  * @param const XML_Char *pszName
1999  */
2000  virtual void end(const XML_Char *pszName);
2001  };
2002 
2003  class ListOfPlotItemsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2004  {
2005  // Attributes
2006  private:
2007  /**
2008  *
2009  */
2010  enum Element
2011  {
2014  };
2015 
2016  // Operations
2017  public:
2018  /**
2019  * Constructor
2020  */
2022  SCopasiXMLParserCommon & common);
2023 
2024  /**
2025  * Destructor
2026  */
2027  virtual ~ListOfPlotItemsElement();
2028 
2029  /**
2030  * Start element handler
2031  * @param const XML_Char *pszName
2032  * @param const XML_Char **papszAttrs
2033  */
2034  virtual void start(const XML_Char *pszName,
2035  const XML_Char **papszAttrs);
2036 
2037  /**
2038  * End element handler
2039  * @param const XML_Char *pszName
2040  */
2041  virtual void end(const XML_Char *pszName);
2042  };
2043 
2044  class PlotSpecificationElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2045  {
2046  // Attributes
2047  private:
2048  /**
2049  *
2050  */
2051  enum Element
2052  {
2058  };
2059 
2060  /**
2061  * The line number the unknown parameter was encountered.
2062  */
2063  size_t mLineNumber;
2064 
2065  // Operations
2066  public:
2067  /**
2068  * Constructor
2069  */
2071  SCopasiXMLParserCommon & common);
2072 
2073  /**
2074  * Destructor
2075  */
2076  virtual ~PlotSpecificationElement();
2077 
2078  /**
2079  * Start element handler
2080  * @param const XML_Char *pszName
2081  * @param const XML_Char **papszAttrs
2082  */
2083  virtual void start(const XML_Char *pszName,
2084  const XML_Char **papszAttrs);
2085 
2086  /**
2087  * End element handler
2088  * @param const XML_Char *pszName
2089  */
2090  virtual void end(const XML_Char *pszName);
2091  };
2092 
2093  class ListOfPlotsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2094  {
2095  // Attributes
2096  private:
2097  /**
2098  *
2099  */
2100  enum Element
2101  {
2104  };
2105 
2106  // Operations
2107  public:
2108  /**
2109  * Constructor
2110  */
2112  SCopasiXMLParserCommon & common);
2113 
2114  /**
2115  * Destructor
2116  */
2117  virtual ~ListOfPlotsElement();
2118 
2119  /**
2120  * Start element handler
2121  * @param const XML_Char *pszName
2122  * @param const XML_Char **papszAttrs
2123  */
2124  virtual void start(const XML_Char *pszName,
2125  const XML_Char **papszAttrs);
2126 
2127  /**
2128  * End element handler
2129  * @param const XML_Char *pszName
2130  */
2131  virtual void end(const XML_Char *pszName);
2132  };
2133 
2134  class ListOfTasksElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2135  {
2136  // Attributes
2137  private:
2138  /**
2139  *
2140  */
2141  enum Element
2142  {
2145  };
2146 
2147  // Operations
2148  public:
2149  /**
2150  * Constructor
2151  */
2153  SCopasiXMLParserCommon & common);
2154 
2155  /**
2156  * Destructor
2157  */
2158  virtual ~ListOfTasksElement();
2159 
2160  /**
2161  * Start element handler
2162  * @param const XML_Char *pszName
2163  * @param const XML_Char **papszAttrs
2164  */
2165  virtual void start(const XML_Char *pszName,
2166  const XML_Char **papszAttrs);
2167 
2168  /**
2169  * End element handler
2170  * @param const XML_Char *pszName
2171  */
2172  virtual void end(const XML_Char *pszName);
2173  };
2174 
2176  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2177  {
2178  // Attributes
2179  private:
2180  /**
2181  * Enum of invoked parsers
2182  */
2183  enum Element
2184  {
2186  };
2187 
2188  // Operations
2189  public:
2190  /**
2191  * Constructor
2192  */
2194  SCopasiXMLParserCommon & common);
2195 
2196  /**
2197  * Destructor
2198  */
2199  virtual ~ReportInstanceElement();
2200 
2201  /**
2202  * Start element handler
2203  * @param const XML_Char *pszName
2204  * @param const XML_Char **papszAttrs
2205  */
2206  virtual void start(const XML_Char *pszName,
2207  const XML_Char **papszAttrs);
2208 
2209  /**
2210  * End element handler
2211  * @param const XML_Char *pszName
2212  */
2213  virtual void end(const XML_Char *pszName);
2214  };
2215 
2217  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2218  {
2219  // Attributes
2220  private:
2221  /**
2222  * Enum of invoked parsers
2223  */
2224  enum Element
2225  {
2227  };
2228 
2229  // Operations
2230  public:
2231  /**
2232  * Constructor
2233  */
2235  SCopasiXMLParserCommon & common);
2236 
2237  /**
2238  * Destructor
2239  */
2240  virtual ~ParameterElement();
2241 
2242  /**
2243  * Start element handler
2244  * @param const XML_Char *pszName
2245  * @param const XML_Char **papszAttrs
2246  */
2247  virtual void start(const XML_Char *pszName,
2248  const XML_Char **papszAttrs);
2249 
2250  /**
2251  * End element handler
2252  * @param const XML_Char *pszName
2253  */
2254  virtual void end(const XML_Char *pszName);
2255  };
2256 
2258  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2259  {
2260  // Attributes
2261  private:
2262  /**
2263  * Enum of invoked parsers
2264  */
2265  enum Element
2266  {
2268  };
2269 
2270  // Operations
2271  public:
2272  /**
2273  * Constructor
2274  */
2276  SCopasiXMLParserCommon & common);
2277 
2278  /**
2279  * Destructor
2280  */
2281  virtual ~ParameterTextElement();
2282 
2283  /**
2284  * Start element handler
2285  * @param const XML_Char *pszName
2286  * @param const XML_Char **papszAttrs
2287  */
2288  virtual void start(const XML_Char *pszName,
2289  const XML_Char **papszAttrs);
2290 
2291  /**
2292  * End element handler
2293  * @param const XML_Char *pszName
2294  */
2295  virtual void end(const XML_Char *pszName);
2296  };
2297 
2299  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2300  {
2301  // Attributes
2302  private:
2303  /**
2304  * Enum of invoked parsers
2305  */
2306  enum Element
2307  {
2310  };
2311 
2315 
2317 
2318  // Operations
2319  public:
2320  /**
2321  * Constructor
2322  */
2324  SCopasiXMLParserCommon & common);
2325 
2326  /**
2327  * Destructor
2328  */
2329  virtual ~ParameterGroupElement();
2330 
2331  /**
2332  * Start element handler
2333  * @param const XML_Char *pszName
2334  * @param const XML_Char **papszAttrs
2335  */
2336  virtual void start(const XML_Char *pszName,
2337  const XML_Char **papszAttrs);
2338 
2339  /**
2340  * End element handler
2341  * @param const XML_Char *pszName
2342  */
2343  virtual void end(const XML_Char *pszName);
2344 
2345  /**
2346  * Set the derived element for which the handler is called such as methods and problems
2347  * @param CCopasiParameterGroup * pDerivedElement
2348  */
2349  void setDerivedElement(CCopasiParameterGroup * pDerivedElement);
2350  };
2351 
2353  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2354  {
2355  // Attributes
2356  private:
2357  /**
2358  * Enum of invoked parsers
2359  */
2360  enum Element
2361  {
2362  Method = 0,
2364  };
2365 
2367 
2368  /**
2369  * The line number the unknown parameter was encountered.
2370  */
2371  size_t mLineNumber;
2372 
2373  // Operations
2374  public:
2375  /**
2376  * Constructor
2377  */
2379  SCopasiXMLParserCommon & common);
2380 
2381  /**
2382  * Destructor
2383  */
2384  virtual ~MethodElement();
2385 
2386  /**
2387  * Start element handler
2388  * @param const XML_Char *pszName
2389  * @param const XML_Char **papszAttrs
2390  */
2391  virtual void start(const XML_Char *pszName,
2392  const XML_Char **papszAttrs);
2393 
2394  /**
2395  * End element handler
2396  * @param const XML_Char *pszName
2397  */
2398  virtual void end(const XML_Char *pszName);
2399  };
2400 
2402  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2403  {
2404  // Attributes
2405  private:
2406  /**
2407  * Enum of invoked parsers
2408  */
2409  enum Element
2410  {
2411  Task = 0,
2415  };
2416 
2420 
2421  // Operations
2422  public:
2423  /**
2424  * Constructor
2425  */
2426  TaskElement(CCopasiXMLParser & parser,
2427  SCopasiXMLParserCommon & common);
2428 
2429  /**
2430  * Destructor
2431  */
2432  virtual ~TaskElement();
2433 
2434  /**
2435  * Start element handler
2436  * @param const XML_Char *pszName
2437  * @param const XML_Char **papszAttrs
2438  */
2439  virtual void start(const XML_Char *pszName,
2440  const XML_Char **papszAttrs);
2441 
2442  /**
2443  * End element handler
2444  * @param const XML_Char *pszName
2445  */
2446  virtual void end(const XML_Char *pszName);
2447  };
2448 
2449  class ListOfReportsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2450  {
2451  // Attributes
2452  private:
2453  /**
2454  *
2455  */
2456  enum Element
2457  {
2460  };
2461 
2462  // Operations
2463  public:
2464  /**
2465  * Constructor
2466  */
2468  SCopasiXMLParserCommon & common);
2469 
2470  /**
2471  * Destructor
2472  */
2473  virtual ~ListOfReportsElement();
2474 
2475  /**
2476  * Start element handler
2477  * @param const XML_Char *pszName
2478  * @param const XML_Char **papszAttrs
2479  */
2480  virtual void start(const XML_Char *pszName,
2481  const XML_Char **papszAttrs);
2482 
2483  /**
2484  * End element handler
2485  * @param const XML_Char *pszName
2486  */
2487  virtual void end(const XML_Char *pszName);
2488  };
2489 
2490  class ObjectElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2491  {
2492  // Attributes
2493  private:
2494  /**
2495  * Object
2496  */
2497  enum Element
2498  {
2500  };
2501 
2502  // Operations
2503  public:
2504  /**
2505  * Constructor
2506  */
2508  SCopasiXMLParserCommon & common);
2509 
2510  /**
2511  * Destructor
2512  */
2513  virtual ~ObjectElement();
2514 
2515  /**
2516  * Start element handler
2517  * @param const XML_Char *pszName
2518  * @param const XML_Char **papszAttrs
2519  */
2520  virtual void start(const XML_Char *pszName,
2521  const XML_Char **papszAttrs);
2522 
2523  /**
2524  * End element handler
2525  * @param const XML_Char *pszName
2526  */
2527  virtual void end(const XML_Char *pszName);
2528  };
2529 
2530  class ComplexElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2531  {
2532  // Attributes
2533  private:
2534  /**
2535  * Complex
2536  */
2537  enum Element
2538  {
2539  Complex = 0,
2542  //Report
2543  };
2544 
2545  // Operations
2546  public:
2547  /**
2548  * Constructor
2549  */
2551  SCopasiXMLParserCommon & common);
2552 
2553  /**
2554  * Destructor
2555  */
2556  virtual ~ComplexElement();
2557 
2558  /**
2559  * Start element handler
2560  * @param const XML_Char *pszName
2561  * @param const XML_Char **papszAttrs
2562  */
2563  virtual void start(const XML_Char *pszName,
2564  const XML_Char **papszAttrs);
2565 
2566  /**
2567  * End element handler
2568  * @param const XML_Char *pszName
2569  */
2570  virtual void end(const XML_Char *pszName);
2571  };
2572 
2573  class HeaderElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2574  {
2575  // Attributes
2576  private:
2577  /**
2578  * Header
2579  */
2580  enum Element
2581  {
2582  Header = 0,
2586  };
2587 
2588  // Operations
2589  public:
2590  /**
2591  * Constructor
2592  */
2594  SCopasiXMLParserCommon & common);
2595 
2596  /**
2597  * Destructor
2598  */
2599  virtual ~HeaderElement();
2600 
2601  /**
2602  * Start element handler
2603  * @param const XML_Char *pszName
2604  * @param const XML_Char **papszAttrs
2605  */
2606  virtual void start(const XML_Char *pszName,
2607  const XML_Char **papszAttrs);
2608 
2609  /**
2610  * End element handler
2611  * @param const XML_Char *pszName
2612  */
2613  virtual void end(const XML_Char *pszName);
2614 
2615  // Attributes
2616  private:
2618  };
2619 
2620  class BodyElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2621  {
2622  // Attributes
2623  private:
2624  /**
2625  * Body
2626  */
2627  enum Element
2628  {
2629  Body = 0,
2633  };
2634 
2635  // Operations
2636  public:
2637  /**
2638  * Constructor
2639  */
2640  BodyElement(CCopasiXMLParser & parser,
2641  SCopasiXMLParserCommon & common);
2642 
2643  /**
2644  * Destructor
2645  */
2646  virtual ~BodyElement();
2647 
2648  /**
2649  * Start element handler
2650  * @param const XML_Char *pszName
2651  * @param const XML_Char **papszAttrs
2652  */
2653  virtual void start(const XML_Char *pszName,
2654  const XML_Char **papszAttrs);
2655 
2656  /**
2657  * End element handler
2658  * @param const XML_Char *pszName
2659  */
2660  virtual void end(const XML_Char *pszName);
2661 
2662  // Attributes
2663  private:
2665  };
2666 
2667  class FooterElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2668  {
2669  // Attributes
2670  private:
2671  /**
2672  * Footer
2673  */
2674  enum Element
2675  {
2676  Footer = 0,
2680  };
2681 
2682  // Operations
2683  public:
2684  /**
2685  * Constructor
2686  */
2688  SCopasiXMLParserCommon & common);
2689 
2690  /**
2691  * Destructor
2692  */
2693  virtual ~FooterElement();
2694 
2695  /**
2696  * Start element handler
2697  * @param const XML_Char *pszName
2698  * @param const XML_Char **papszAttrs
2699  */
2700  virtual void start(const XML_Char *pszName,
2701  const XML_Char **papszAttrs);
2702 
2703  /**
2704  * End element handler
2705  * @param const XML_Char *pszName
2706  */
2707  virtual void end(const XML_Char *pszName);
2708 
2709  // Attributes
2710  private:
2712  };
2713 
2715  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2716  {
2717  // Attributes
2718  private:
2719  /**
2720  * Enum of invoked parsers
2721  */
2722  enum Element
2723  {
2724  Table = 0,
2726  };
2727 
2728  // Operations
2729  public:
2730  /**
2731  * Constructor
2732  */
2733  TableElement(CCopasiXMLParser & parser,
2734  SCopasiXMLParserCommon & common);
2735 
2736  /**
2737  * Destructor
2738  */
2739  virtual ~TableElement();
2740 
2741  /**
2742  * Start element handler
2743  * @param const XML_Char *pszName
2744  * @param const XML_Char **papszAttrs
2745  */
2746  virtual void start(const XML_Char *pszName,
2747  const XML_Char **papszAttrs);
2748 
2749  /**
2750  * End element handler
2751  * @param const XML_Char *pszName
2752  */
2753  virtual void end(const XML_Char *pszName);
2754  };
2755 
2756  class ReportElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2757  {
2758  // Attributes
2759  private:
2760  /**
2761  * Report
2762  */
2763  enum Element
2764  {
2765  Report = 0,
2771  };
2772 
2777 
2780 
2781  // Operations
2782  public:
2783  /**
2784  * Constructor
2785  */
2787  SCopasiXMLParserCommon & common);
2788 
2789  /**
2790  * Destructor
2791  */
2792  virtual ~ReportElement();
2793 
2794  /**
2795  * Start element handler
2796  * @param const XML_Char *pszName
2797  * @param const XML_Char **papszAttrs
2798  */
2799  virtual void start(const XML_Char *pszName,
2800  const XML_Char **papszAttrs);
2801 
2802  /**
2803  * End element handler
2804  * @param const XML_Char *pszName
2805  */
2806  virtual void end(const XML_Char *pszName);
2807  };
2808 
2809  /**
2810  *
2811  */
2812  class COPASIElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2813  {
2814  // Attributes
2815  private:
2816  /**
2817  *
2818  */
2819  enum Element
2820  {
2821  COPASI = 0,
2830  };
2831 
2832  // Operations
2833  public:
2834  /**
2835  * Constructor
2836  */
2838  SCopasiXMLParserCommon & common);
2839 
2840  /**
2841  * Destructor
2842  */
2843  virtual ~COPASIElement();
2844 
2845  /**
2846  * Start element handler
2847  * @param const XML_Char *pszName
2848  * @param const XML_Char **papszAttrs
2849  */
2850  virtual void start(const XML_Char *pszName,
2851  const XML_Char **papszAttrs);
2852 
2853  /**
2854  * End element handler
2855  * @param const XML_Char *pszName
2856  */
2857  virtual void end(const XML_Char *pszName);
2858  };
2859 
2860  class ListOfFunctionsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2861  {
2862  // Attributes
2863  private:
2864  /**
2865  *
2866  */
2867  enum Element
2868  {
2871  };
2872 
2873  // Operations
2874  public:
2875  /**
2876  * Constructor
2877  */
2879  SCopasiXMLParserCommon & common);
2880 
2881  /**
2882  * Destructor
2883  */
2884  virtual ~ListOfFunctionsElement();
2885 
2886  /**
2887  * Start element handler
2888  * @param const XML_Char *pszName
2889  * @param const XML_Char **papszAttrs
2890  */
2891  virtual void start(const XML_Char *pszName,
2892  const XML_Char **papszAttrs);
2893 
2894  /**
2895  * End element handler
2896  * @param const XML_Char *pszName
2897  */
2898  virtual void end(const XML_Char *pszName);
2899  };
2900 
2901  class MathMLElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2902  {
2903  // Attributes
2904  private:
2905  /**
2906  * Text
2907  */
2908  enum Element
2909  {
2910  MathML = 0,
2912  };
2913 
2914  // Operations
2915  public:
2916  /**
2917  * Constructor
2918  */
2920  SCopasiXMLParserCommon & common);
2921 
2922  /**
2923  * Destructor
2924  */
2925  virtual ~MathMLElement();
2926 
2927  /**
2928  * Start element handler
2929  * @param const XML_Char *pszName
2930  * @param const XML_Char **papszAttrs
2931  */
2932  virtual void start(const XML_Char *pszName,
2933  const XML_Char **papszAttrs);
2934 
2935  /**
2936  * End element handler
2937  * @param const XML_Char *pszName
2938  */
2939  virtual void end(const XML_Char *pszName);
2940  };
2941 
2942  class ParameterDescriptionElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2943  {
2944  // Attributes
2945  private:
2946  /**
2947  *
2948  */
2949  enum Element
2950  {
2952  };
2953 
2954  /**
2955  * Order
2956  */
2957  unsigned C_INT32 mOrder;
2958 
2959  // Operations
2960  public:
2961  /**
2962  * Constructor
2963  */
2965  SCopasiXMLParserCommon & common);
2966 
2967  /**
2968  * Destructor
2969  */
2970  virtual ~ParameterDescriptionElement();
2971 
2972  /**
2973  * Start element handler
2974  * @param const XML_Char *pszName
2975  * @param const XML_Char **papszAttrs
2976  */
2977  virtual void start(const XML_Char *pszName,
2978  const XML_Char **papszAttrs);
2979 
2980  /**
2981  * End element handler
2982  * @param const XML_Char *pszName
2983  */
2984  virtual void end(const XML_Char *pszName);
2985 
2986  /**
2987  * Reset the element handler to start values.
2988  */
2989  virtual void reset();
2990  };
2991 
2992  class ListOfParameterDescriptionsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
2993  {
2994  // Attributes
2995  private:
2996  /**
2997  *
2998  */
2999  enum Element
3000  {
3003  };
3004 
3005  // Operations
3006  public:
3007  /**
3008  * Constructor
3009  */
3011  SCopasiXMLParserCommon & common);
3012 
3013  /**
3014  * Destructor
3015  */
3017 
3018  /**
3019  * Start element handler
3020  * @param const XML_Char *pszName
3021  * @param const XML_Char **papszAttrs
3022  */
3023  virtual void start(const XML_Char *pszName,
3024  const XML_Char **papszAttrs);
3025 
3026  /**
3027  * End element handler
3028  * @param const XML_Char *pszName
3029  */
3030  virtual void end(const XML_Char *pszName);
3031  };
3032 
3033  class FunctionElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3034  {
3035  // Attributes
3036  private:
3037  /**
3038  *
3039  */
3040  enum Element
3041  {
3049  };
3050 
3051  /**
3052  *
3053  */
3055 
3056  /**
3057  *
3058  */
3060 
3061  /**
3062  * The key in the CopasiML file
3063  */
3064  std::string mKey;
3065 
3066  /**
3067  * The index of a function with the same name
3068  */
3069  std::set< size_t > mExistingFunctionIndex;
3070 
3071  // Operations
3072  public:
3073  /**
3074  * Constructor
3075  */
3077  SCopasiXMLParserCommon & common);
3078 
3079  /**
3080  * Destructor
3081  */
3082  virtual ~FunctionElement();
3083 
3084  /**
3085  * Start element handler
3086  * @param const XML_Char *pszName
3087  * @param const XML_Char **papszAttrs
3088  */
3089  virtual void start(const XML_Char *pszName,
3090  const XML_Char **papszAttrs);
3091 
3092  /**
3093  * End element handler
3094  * @param const XML_Char *pszName
3095  */
3096  virtual void end(const XML_Char *pszName);
3097  };
3098 
3099  class MiriamAnnotationElement: public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3100  {
3101  // Attributes
3102  private:
3103  /**
3104  * Enum of invoked parsers
3105  */
3106  enum Element
3107  {
3110  };
3111 
3112  /**
3113  * String stream to handle RDF contents
3114  */
3115  std::ostringstream mRDF;
3116 
3117  /**
3118  * The level of nested xhtml elements.
3119  */
3120  size_t mLevel;
3121 
3122  /**
3123  * Information whether an element is empty
3124  */
3125  std::stack< bool > mElementEmpty;
3126 
3127  // Operations
3128  public:
3129  /**
3130  * Constructor
3131  */
3133  SCopasiXMLParserCommon & common);
3134 
3135  /**
3136  * Destructor
3137  */
3138  virtual ~MiriamAnnotationElement();
3139 
3140  /**
3141  * Start element handler
3142  * @param const XML_Char *pszName
3143  * @param const XML_Char **papszAttrs
3144  */
3145  virtual void start(const XML_Char *pszName,
3146  const XML_Char **papszAttrs);
3147 
3148  /**
3149  * End element handler
3150  * @param const XML_Char *pszName
3151  */
3152  virtual void end(const XML_Char *pszName);
3153  };
3154 
3155 public:
3156  /**
3157  * The Miriam Annotation Element handler
3158  */
3160 
3161 private:
3162 
3163  class GUIElement:
3164  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3165  {
3166  // Attributes
3167  private:
3168  /**
3169  * Enum of invoked parsers
3170  */
3171  enum Element
3172  {
3173  GUI = 0,
3175  };
3176 
3177  // Operations
3178  public:
3179  /**
3180  * Constructor
3181  */
3182  GUIElement(CCopasiXMLParser & parser,
3183  SCopasiXMLParserCommon & common);
3184 
3185  /**
3186  * Destructor
3187  */
3188  virtual ~GUIElement();
3189 
3190  /**
3191  * Start element handler
3192  * @param const XML_Char *pszName
3193  * @param const XML_Char **papszAttrs
3194  */
3195  virtual void start(const XML_Char *pszName,
3196  const XML_Char **papszAttrs);
3197 
3198  /**
3199  * End element handler
3200  * @param const XML_Char *pszName
3201  */
3202  virtual void end(const XML_Char *pszName);
3203  };
3204 
3206  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3207  {
3208  // Attributes
3209  private:
3210  /**
3211  * Enum of invoked parsers
3212  */
3213  enum Element
3214  {
3217  };
3218 
3219  // Operations
3220  public:
3221  /**
3222  * Constructor
3223  */
3225  SCopasiXMLParserCommon & common);
3226 
3227  /**
3228  * Destructor
3229  */
3230  virtual ~ListOfSlidersElement();
3231 
3232  /**
3233  * Start element handler
3234  * @param const XML_Char *pszName
3235  * @param const XML_Char **papszAttrs
3236  */
3237  virtual void start(const XML_Char *pszName,
3238  const XML_Char **papszAttrs);
3239 
3240  /**
3241  * End element handler
3242  * @param const XML_Char *pszName
3243  */
3244  virtual void end(const XML_Char *pszName);
3245  };
3246 
3248  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3249  {
3250  // Attributes
3251  private:
3252  /**
3253  * Enum of invoked parsers
3254  */
3255  enum Element
3256  {
3258  };
3259 
3260  // Operations
3261  public:
3262  /**
3263  * Constructor
3264  */
3266  SCopasiXMLParserCommon & common);
3267 
3268  /**
3269  * Destructor
3270  */
3271  virtual ~SliderElement();
3272 
3273  /**
3274  * Start element handler
3275  * @param const XML_Char *pszName
3276  * @param const XML_Char **papszAttrs
3277  */
3278  virtual void start(const XML_Char *pszName,
3279  const XML_Char **papszAttrs);
3280 
3281  /**
3282  * End element handler
3283  * @param const XML_Char *pszName
3284  */
3285  virtual void end(const XML_Char *pszName);
3286  };
3287 
3288  class CurveElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3289  {
3290  private:
3291  enum Element
3292  {
3293  Curve = 0,
3300  };
3301 
3302  size_t mLineNumber;
3303 
3304  public:
3305  CurveElement(CCopasiXMLParser & parser,
3306  SCopasiXMLParserCommon & common);
3307 
3308  virtual ~CurveElement();
3309 
3310  virtual void start(const XML_Char *pszName,
3311  const XML_Char **papszAttrs);
3312 
3313  virtual void end(const XML_Char *pszName);
3314  };
3315 
3316  class CompartmentGlyphElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3317  {
3318  private:
3319  enum Element
3320  {
3325  };
3326 
3327  size_t mLineNumber;
3328 
3329  public:
3331  SCopasiXMLParserCommon & common);
3332 
3333  virtual ~CompartmentGlyphElement();
3334 
3335  virtual void start(const XML_Char *pszName,
3336  const XML_Char **papszAttrs);
3337 
3338  virtual void end(const XML_Char *pszName);
3339  };
3340 
3341  class ListOfCompartmentGlyphsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3342  {
3343  private:
3344  enum Element
3345  {
3348  };
3349 
3350  public:
3352  SCopasiXMLParserCommon & common);
3353 
3355 
3356  virtual void start(const XML_Char *pszName,
3357  const XML_Char **papszAttrs);
3358 
3359  virtual void end(const XML_Char *pszName);
3360  };
3361 
3362  class MetaboliteGlyphElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3363  {
3364  private:
3365  enum Element
3366  {
3371  };
3372 
3373  size_t mLineNumber;
3374 
3375  public:
3377  SCopasiXMLParserCommon & common);
3378 
3379  virtual ~MetaboliteGlyphElement();
3380 
3381  virtual void start(const XML_Char *pszName,
3382  const XML_Char **papszAttrs);
3383 
3384  virtual void end(const XML_Char *pszName);
3385  };
3386 
3387  class ListOfMetabGlyphsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3388  {
3389  private:
3390  enum Element
3391  {
3394  };
3395 
3396  public:
3398  SCopasiXMLParserCommon & common);
3399 
3400  virtual ~ListOfMetabGlyphsElement();
3401 
3402  virtual void start(const XML_Char *pszName,
3403  const XML_Char **papszAttrs);
3404 
3405  virtual void end(const XML_Char *pszName);
3406  };
3407 
3408  class MetaboliteReferenceGlyphElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3409  {
3410  private:
3411  enum Element
3412  {
3418  };
3419 
3420  size_t mLineNumber;
3421 
3422  public:
3424  SCopasiXMLParserCommon & common);
3425 
3427 
3428  virtual void start(const XML_Char *pszName,
3429  const XML_Char **papszAttrs);
3430 
3431  virtual void end(const XML_Char *pszName);
3432  };
3433 
3434  class ListOfMetaboliteReferenceGlyphsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3435  {
3436  private:
3437  enum Element
3438  {
3441  };
3442 
3443  public:
3445  SCopasiXMLParserCommon & common);
3446 
3448 
3449  virtual void start(const XML_Char *pszName,
3450  const XML_Char **papszAttrs);
3451 
3452  virtual void end(const XML_Char *pszName);
3453  };
3454 
3455  class ReactionGlyphElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3456  {
3457  private:
3458  enum Element
3459  {
3466  };
3467 
3468  size_t mLineNumber;
3469 
3470  public:
3472  SCopasiXMLParserCommon & common);
3473 
3474  virtual ~ReactionGlyphElement();
3475 
3476  virtual void start(const XML_Char *pszName,
3477  const XML_Char **papszAttrs);
3478 
3479  virtual void end(const XML_Char *pszName);
3480  };
3481 
3482  class ListOfReactionGlyphsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3483  {
3484  private:
3485  enum Element
3486  {
3489  };
3490 
3491  public:
3493  SCopasiXMLParserCommon & common);
3494 
3495  virtual ~ListOfReactionGlyphsElement();
3496 
3497  virtual void start(const XML_Char *pszName,
3498  const XML_Char **papszAttrs);
3499 
3500  virtual void end(const XML_Char *pszName);
3501  };
3502 
3503  class TextGlyphElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3504  {
3505  private:
3506  enum Element
3507  {
3512  };
3513 
3514  size_t mLineNumber;
3515 
3516  public:
3518  SCopasiXMLParserCommon & common);
3519 
3520  virtual ~TextGlyphElement();
3521 
3522  virtual void start(const XML_Char *pszName,
3523  const XML_Char **papszAttrs);
3524 
3525  virtual void end(const XML_Char *pszName);
3526  };
3527 
3528  class ListOfTextGlyphsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3529  {
3530  private:
3531  enum Element
3532  {
3535  };
3536 
3537  public:
3539  SCopasiXMLParserCommon & common);
3540 
3541  virtual ~ListOfTextGlyphsElement();
3542 
3543  virtual void start(const XML_Char *pszName,
3544  const XML_Char **papszAttrs);
3545 
3546  virtual void end(const XML_Char *pszName);
3547  };
3548 
3549  class AdditionalGOElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3550  {
3551  private:
3552  enum Element
3553  {
3558  };
3559 
3560  size_t mLineNumber;
3561 
3562  public:
3564  SCopasiXMLParserCommon & common);
3565 
3566  virtual ~AdditionalGOElement();
3567 
3568  virtual void start(const XML_Char *pszName,
3569  const XML_Char **papszAttrs);
3570 
3571  virtual void end(const XML_Char *pszName);
3572  };
3573 
3574  class ListOfAdditionalGOsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3575  {
3576  private:
3577  enum Element
3578  {
3581  };
3582 
3583  public:
3585  SCopasiXMLParserCommon & common);
3586 
3587  virtual ~ListOfAdditionalGOsElement();
3588 
3589  virtual void start(const XML_Char *pszName,
3590  const XML_Char **papszAttrs);
3591 
3592  virtual void end(const XML_Char *pszName);
3593  };
3594 
3595  class LayoutElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3596  {
3597  private:
3598  enum Element
3599  {
3600  Layout = 0,
3608  };
3609 
3610  size_t mLineNumber;
3611 
3612  public:
3614  SCopasiXMLParserCommon & common);
3615 
3616  virtual ~LayoutElement();
3617 
3618  virtual void start(const XML_Char *pszName,
3619  const XML_Char **papszAttrs);
3620 
3621  virtual void end(const XML_Char *pszName);
3622  };
3623 
3624  class ListOfLayoutsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3625  {
3626  // Attributes
3627  private:
3628  /**
3629  *
3630  */
3631  enum Element
3632  {
3636  };
3637 
3638  // Operations
3639  public:
3640  /**
3641  * Constructor
3642  */
3644  SCopasiXMLParserCommon & common);
3645 
3646  /**
3647  * Destructor
3648  */
3649  virtual ~ListOfLayoutsElement();
3650 
3651  /**
3652  * Start element handler
3653  * @param const XML_Char *pszName
3654  * @param const XML_Char **papszAttrs
3655  */
3656  virtual void start(const XML_Char *pszName,
3657  const XML_Char **papszAttrs);
3658 
3659  /**
3660  * End element handler
3661  * @param const XML_Char *pszName
3662  */
3663  virtual void end(const XML_Char *pszName);
3664  };
3665 
3667  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3668  {
3669  // Attributes
3670  private:
3671  /**
3672  * Enum of invoked parsers
3673  */
3674  enum Element
3675  {
3678  };
3679 
3680  // Operations
3681  public:
3682  /**
3683  * Constructor
3684  */
3686  SCopasiXMLParserCommon & common);
3687 
3688  /**
3689  * Destructor
3690  */
3691  virtual ~SBMLReferenceElement();
3692 
3693  /**
3694  * Start element handler
3695  * @param const XML_Char *pszName
3696  * @param const XML_Char **papszAttrs
3697  */
3698  virtual void start(const XML_Char *pszName,
3699  const XML_Char **papszAttrs);
3700 
3701  /**
3702  * End element handler
3703  * @param const XML_Char *pszName
3704  */
3705  virtual void end(const XML_Char *pszName);
3706  };
3707 
3709  public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3710  {
3711  // Attributes
3712  private:
3713  /**
3714  * Enum of invoked parsers
3715  */
3716  enum Element
3717  {
3719  };
3720 
3721  // Operations
3722  public:
3723  /**
3724  * Constructor
3725  */
3727  SCopasiXMLParserCommon & common);
3728 
3729  /**
3730  * Destructor
3731  */
3732  virtual ~SBMLMapElement();
3733 
3734  /**
3735  * Start element handler
3736  * @param const XML_Char *pszName
3737  * @param const XML_Char **papszAttrs
3738  */
3739  virtual void start(const XML_Char *pszName,
3740  const XML_Char **papszAttrs);
3741 
3742  /**
3743  * End element handler
3744  * @param const XML_Char *pszName
3745  */
3746  virtual void end(const XML_Char *pszName);
3747  };
3748 
3749  class GradientStopElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3750  {
3751  // Attributes
3752  private:
3753  /**
3754  *
3755  */
3756  enum Element
3757  {
3759  };
3760 
3761  // Operations
3762  public:
3763  /**
3764  * Constructor
3765  */
3767  SCopasiXMLParserCommon & common);
3768 
3769  /**
3770  * Destructor
3771  */
3772  virtual ~GradientStopElement();
3773 
3774  /**
3775  * Start element handler
3776  * @param const XML_Char *pszName
3777  * @param const XML_Char **papszAttrs
3778  */
3779  virtual void start(const XML_Char *pszName,
3780  const XML_Char **papszAttrs);
3781 
3782  /**
3783  * End element handler
3784  * @param const XML_Char *pszName
3785  */
3786  virtual void end(const XML_Char *pszName);
3787  };
3788 
3789  class LinearGradientElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3790  {
3791  // Attributes
3792  private:
3793  /**
3794  *
3795  */
3796  enum Element
3797  {
3800  };
3801 
3802  // Operations
3803  public:
3804  /**
3805  * Constructor
3806  */
3808  SCopasiXMLParserCommon & common);
3809 
3810  /**
3811  * Destructor
3812  */
3813  virtual ~LinearGradientElement();
3814 
3815  /**
3816  * Start element handler
3817  * @param const XML_Char *pszName
3818  * @param const XML_Char **papszAttrs
3819  */
3820  virtual void start(const XML_Char *pszName,
3821  const XML_Char **papszAttrs);
3822 
3823  /**
3824  * End element handler
3825  * @param const XML_Char *pszName
3826  */
3827  virtual void end(const XML_Char *pszName);
3828  };
3829 
3830  class RadialGradientElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3831  {
3832  // Attributes
3833  private:
3834  /**
3835  *
3836  */
3837  enum Element
3838  {
3841  };
3842 
3843  // Operations
3844  public:
3845  /**
3846  * Constructor
3847  */
3849  SCopasiXMLParserCommon & common);
3850 
3851  /**
3852  * Destructor
3853  */
3854  virtual ~RadialGradientElement();
3855 
3856  /**
3857  * Start element handler
3858  * @param const XML_Char *pszName
3859  * @param const XML_Char **papszAttrs
3860  */
3861  virtual void start(const XML_Char *pszName,
3862  const XML_Char **papszAttrs);
3863 
3864  /**
3865  * End element handler
3866  * @param const XML_Char *pszName
3867  */
3868  virtual void end(const XML_Char *pszName);
3869  };
3870 
3871  class ColorDefinitionElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3872  {
3873  // Attributes
3874  private:
3875  /**
3876  *
3877  */
3878  enum Element
3879  {
3881  };
3882 
3883  // Operations
3884  public:
3885  /**
3886  * Constructor
3887  */
3889  SCopasiXMLParserCommon & common);
3890 
3891  /**
3892  * Destructor
3893  */
3894  virtual ~ColorDefinitionElement();
3895 
3896  /**
3897  * Start element handler
3898  * @param const XML_Char *pszName
3899  * @param const XML_Char **papszAttrs
3900  */
3901  virtual void start(const XML_Char *pszName,
3902  const XML_Char **papszAttrs);
3903 
3904  /**
3905  * End element handler
3906  * @param const XML_Char *pszName
3907  */
3908  virtual void end(const XML_Char *pszName);
3909  };
3910 
3911  class ListOfColorDefinitionsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3912  {
3913  // Attributes
3914  private:
3915  /**
3916  *
3917  */
3918  enum Element
3919  {
3922  };
3923 
3924  // Operations
3925  public:
3926  /**
3927  * Constructor
3928  */
3930  SCopasiXMLParserCommon & common);
3931 
3932  /**
3933  * Destructor
3934  */
3936 
3937  /**
3938  * Start element handler
3939  * @param const XML_Char *pszName
3940  * @param const XML_Char **papszAttrs
3941  */
3942  virtual void start(const XML_Char *pszName,
3943  const XML_Char **papszAttrs);
3944 
3945  /**
3946  * End element handler
3947  * @param const XML_Char *pszName
3948  */
3949  virtual void end(const XML_Char *pszName);
3950  };
3951 
3952  class ListOfGradientDefinitionsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3953  {
3954  // Attributes
3955  private:
3956  /**
3957  *
3958  */
3959  enum Element
3960  {
3963  };
3964 
3965  // Operations
3966  public:
3967  /**
3968  * Constructor
3969  */
3971  SCopasiXMLParserCommon & common);
3972 
3973  /**
3974  * Destructor
3975  */
3977 
3978  /**
3979  * Start element handler
3980  * @param const XML_Char *pszName
3981  * @param const XML_Char **papszAttrs
3982  */
3983  virtual void start(const XML_Char *pszName,
3984  const XML_Char **papszAttrs);
3985 
3986  /**
3987  * End element handler
3988  * @param const XML_Char *pszName
3989  */
3990  virtual void end(const XML_Char *pszName);
3991  };
3992 
3993  class ListOfLineEndingsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
3994  {
3995  // Attributes
3996  private:
3997  /**
3998  *
3999  */
4000  enum Element
4001  {
4004  };
4005 
4006  // Operations
4007  public:
4008  /**
4009  * Constructor
4010  */
4012  SCopasiXMLParserCommon & common);
4013 
4014  /**
4015  * Destructor
4016  */
4017  virtual ~ListOfLineEndingsElement();
4018 
4019  /**
4020  * Start element handler
4021  * @param const XML_Char *pszName
4022  * @param const XML_Char **papszAttrs
4023  */
4024  virtual void start(const XML_Char *pszName,
4025  const XML_Char **papszAttrs);
4026 
4027  /**
4028  * End element handler
4029  * @param const XML_Char *pszName
4030  */
4031  virtual void end(const XML_Char *pszName);
4032  };
4033 
4034  class LineEndingElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4035  {
4036  // Attributes
4037  private:
4038  /**
4039  *
4040  */
4041  enum Element
4042  {
4046  };
4047 
4048  // Operations
4049  public:
4050  /**
4051  * Constructor
4052  */
4054  SCopasiXMLParserCommon & common);
4055 
4056  /**
4057  * Destructor
4058  */
4059  virtual ~LineEndingElement();
4060 
4061  /**
4062  * Start element handler
4063  * @param const XML_Char *pszName
4064  * @param const XML_Char **papszAttrs
4065  */
4066  virtual void start(const XML_Char *pszName,
4067  const XML_Char **papszAttrs);
4068 
4069  /**
4070  * End element handler
4071  * @param const XML_Char *pszName
4072  */
4073  virtual void end(const XML_Char *pszName);
4074  };
4075 
4076  class ImageElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4077  {
4078  // Attributes
4079  private:
4080  /**
4081  *
4082  */
4083  enum Element
4084  {
4085  Image = 0
4086  };
4087 
4088  // Operations
4089  public:
4090  /**
4091  * Constructor
4092  */
4093  ImageElement(CCopasiXMLParser & parser,
4094  SCopasiXMLParserCommon & common);
4095 
4096  /**
4097  * Destructor
4098  */
4099  virtual ~ImageElement();
4100 
4101  /**
4102  * Start element handler
4103  * @param const XML_Char *pszName
4104  * @param const XML_Char **papszAttrs
4105  */
4106  virtual void start(const XML_Char *pszName,
4107  const XML_Char **papszAttrs);
4108 
4109  /**
4110  * End element handler
4111  * @param const XML_Char *pszName
4112  */
4113  virtual void end(const XML_Char *pszName);
4114  };
4115 
4116  class RectangleElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4117  {
4118  // Attributes
4119  private:
4120  /**
4121  *
4122  */
4123  enum Element
4124  {
4126  };
4127 
4128  // Operations
4129  public:
4130  /**
4131  * Constructor
4132  */
4134  SCopasiXMLParserCommon & common);
4135 
4136  /**
4137  * Destructor
4138  */
4139  virtual ~RectangleElement();
4140 
4141  /**
4142  * Start element handler
4143  * @param const XML_Char *pszName
4144  * @param const XML_Char **papszAttrs
4145  */
4146  virtual void start(const XML_Char *pszName,
4147  const XML_Char **papszAttrs);
4148 
4149  /**
4150  * End element handler
4151  * @param const XML_Char *pszName
4152  */
4153  virtual void end(const XML_Char *pszName);
4154  };
4155 
4156  class EllipseElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4157  {
4158  // Attributes
4159  private:
4160  /**
4161  *
4162  */
4163  enum Element
4164  {
4166  };
4167 
4168  // Operations
4169  public:
4170  /**
4171  * Constructor
4172  */
4174  SCopasiXMLParserCommon & common);
4175 
4176  /**
4177  * Destructor
4178  */
4179  virtual ~EllipseElement();
4180 
4181  /**
4182  * Start element handler
4183  * @param const XML_Char *pszName
4184  * @param const XML_Char **papszAttrs
4185  */
4186  virtual void start(const XML_Char *pszName,
4187  const XML_Char **papszAttrs);
4188 
4189  /**
4190  * End element handler
4191  * @param const XML_Char *pszName
4192  */
4193  virtual void end(const XML_Char *pszName);
4194  };
4195 
4196  class TextElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4197  {
4198  // Attributes
4199  private:
4200  /**
4201  *
4202  */
4203  enum Element
4204  {
4206  };
4207 
4208  // Operations
4209  public:
4210  /**
4211  * Constructor
4212  */
4213  TextElement(CCopasiXMLParser & parser,
4214  SCopasiXMLParserCommon & common);
4215 
4216  /**
4217  * Destructor
4218  */
4219  virtual ~TextElement();
4220 
4221  /**
4222  * Start element handler
4223  * @param const XML_Char *pszName
4224  * @param const XML_Char **papszAttrs
4225  */
4226  virtual void start(const XML_Char *pszName,
4227  const XML_Char **papszAttrs);
4228 
4229  /**
4230  * End element handler
4231  * @param const XML_Char *pszName
4232  */
4233  virtual void end(const XML_Char *pszName);
4234  };
4235 
4236  class RenderCurveElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4237  {
4238  // Attributes
4239  private:
4240  /**
4241  *
4242  */
4243  enum Element
4244  {
4247  };
4248 
4249  // Operations
4250  public:
4251  /**
4252  * Constructor
4253  */
4255  SCopasiXMLParserCommon & common);
4256 
4257  /**
4258  * Destructor
4259  */
4260  virtual ~RenderCurveElement();
4261 
4262  /**
4263  * Start element handler
4264  * @param const XML_Char *pszName
4265  * @param const XML_Char **papszAttrs
4266  */
4267  virtual void start(const XML_Char *pszName,
4268  const XML_Char **papszAttrs);
4269 
4270  /**
4271  * End element handler
4272  * @param const XML_Char *pszName
4273  */
4274  virtual void end(const XML_Char *pszName);
4275  };
4276 
4277  class PolygonElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4278  {
4279  // Attributes
4280  private:
4281  /**
4282  *
4283  */
4284  enum Element
4285  {
4286  Polygon = 0,
4288  };
4289 
4290  // Operations
4291  public:
4292  /**
4293  * Constructor
4294  */
4296  SCopasiXMLParserCommon & common);
4297 
4298  /**
4299  * Destructor
4300  */
4301  virtual ~PolygonElement();
4302 
4303  /**
4304  * Start element handler
4305  * @param const XML_Char *pszName
4306  * @param const XML_Char **papszAttrs
4307  */
4308  virtual void start(const XML_Char *pszName,
4309  const XML_Char **papszAttrs);
4310 
4311  /**
4312  * End element handler
4313  * @param const XML_Char *pszName
4314  */
4315  virtual void end(const XML_Char *pszName);
4316  };
4317 
4318  class ListOfCurveElementsElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4319  {
4320  // Attributes
4321  private:
4322  /**
4323  *
4324  */
4325  enum Element
4326  {
4329  };
4330 
4331  // Operations
4332  public:
4333  /**
4334  * Constructor
4335  */
4337  SCopasiXMLParserCommon & common);
4338 
4339  /**
4340  * Destructor
4341  */
4342  virtual ~ListOfCurveElementsElement();
4343 
4344  /**
4345  * Start element handler
4346  * @param const XML_Char *pszName
4347  * @param const XML_Char **papszAttrs
4348  */
4349  virtual void start(const XML_Char *pszName,
4350  const XML_Char **papszAttrs);
4351 
4352  /**
4353  * End element handler
4354  * @param const XML_Char *pszName
4355  */
4356  virtual void end(const XML_Char *pszName);
4357  };
4358 
4359  class CurveElementElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4360  {
4361  // Attributes
4362  private:
4363  /**
4364  *
4365  */
4366  enum Element
4367  {
4369  };
4370 
4371  // Operations
4372  public:
4373  /**
4374  * Constructor
4375  */
4377  SCopasiXMLParserCommon & common);
4378 
4379  /**
4380  * Destructor
4381  */
4382  virtual ~CurveElementElement();
4383 
4384  /**
4385  * Start element handler
4386  * @param const XML_Char *pszName
4387  * @param const XML_Char **papszAttrs
4388  */
4389  virtual void start(const XML_Char *pszName,
4390  const XML_Char **papszAttrs);
4391 
4392  /**
4393  * End element handler
4394  * @param const XML_Char *pszName
4395  */
4396  virtual void end(const XML_Char *pszName);
4397  };
4398 
4399  class LocalStyleElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4400  {
4401  // Attributes
4402  private:
4403  /**
4404  *
4405  */
4406  enum Element
4407  {
4410  };
4411 
4412  // Operations
4413  public:
4414  /**
4415  * Constructor
4416  */
4418  SCopasiXMLParserCommon & common);
4419 
4420  /**
4421  * Destructor
4422  */
4423  virtual ~LocalStyleElement();
4424 
4425  /**
4426  * Start element handler
4427  * @param const XML_Char *pszName
4428  * @param const XML_Char **papszAttrs
4429  */
4430  virtual void start(const XML_Char *pszName,
4431  const XML_Char **papszAttrs);
4432 
4433  /**
4434  * End element handler
4435  * @param const XML_Char *pszName
4436  */
4437  virtual void end(const XML_Char *pszName);
4438  };
4439 
4440  class GlobalStyleElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4441  {
4442  // Attributes
4443  private:
4444  /**
4445  *
4446  */
4447  enum Element
4448  {
4451  };
4452 
4453  // Operations
4454  public:
4455  /**
4456  * Constructor
4457  */
4459  SCopasiXMLParserCommon & common);
4460 
4461  /**
4462  * Destructor
4463  */
4464  virtual ~GlobalStyleElement();
4465 
4466  /**
4467  * Start element handler
4468  * @param const XML_Char *pszName
4469  * @param const XML_Char **papszAttrs
4470  */
4471  virtual void start(const XML_Char *pszName,
4472  const XML_Char **papszAttrs);
4473 
4474  /**
4475  * End element handler
4476  * @param const XML_Char *pszName
4477  */
4478  virtual void end(const XML_Char *pszName);
4479  };
4480 
4481  class ListOfLocalStylesElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4482  {
4483  // Attributes
4484  private:
4485  /**
4486  *
4487  */
4488  enum Element
4489  {
4492  };
4493 
4494  // Operations
4495  public:
4496  /**
4497  * Constructor
4498  */
4500  SCopasiXMLParserCommon & common);
4501 
4502  /**
4503  * Destructor
4504  */
4505  virtual ~ListOfLocalStylesElement();
4506 
4507  /**
4508  * Start element handler
4509  * @param const XML_Char *pszName
4510  * @param const XML_Char **papszAttrs
4511  */
4512  virtual void start(const XML_Char *pszName,
4513  const XML_Char **papszAttrs);
4514 
4515  /**
4516  * End element handler
4517  * @param const XML_Char *pszName
4518  */
4519  virtual void end(const XML_Char *pszName);
4520  };
4521 
4522  class ListOfGlobalStylesElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4523  {
4524  // Attributes
4525  private:
4526  /**
4527  *
4528  */
4529  enum Element
4530  {
4533  };
4534 
4535  // Operations
4536  public:
4537  /**
4538  * Constructor
4539  */
4541  SCopasiXMLParserCommon & common);
4542 
4543  /**
4544  * Destructor
4545  */
4546  virtual ~ListOfGlobalStylesElement();
4547 
4548  /**
4549  * Start element handler
4550  * @param const XML_Char *pszName
4551  * @param const XML_Char **papszAttrs
4552  */
4553  virtual void start(const XML_Char *pszName,
4554  const XML_Char **papszAttrs);
4555 
4556  /**
4557  * End element handler
4558  * @param const XML_Char *pszName
4559  */
4560  virtual void end(const XML_Char *pszName);
4561  };
4562 
4563  class ListOfLocalRenderInformationElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4564  {
4565  // Attributes
4566  private:
4567  /**
4568  *
4569  */
4570  enum Element
4571  {
4574  };
4575 
4576  // Operations
4577  public:
4578  /**
4579  * Constructor
4580  */
4582  SCopasiXMLParserCommon & common);
4583 
4584  /**
4585  * Destructor
4586  */
4588 
4589  /**
4590  * Start element handler
4591  * @param const XML_Char *pszName
4592  * @param const XML_Char **papszAttrs
4593  */
4594  virtual void start(const XML_Char *pszName,
4595  const XML_Char **papszAttrs);
4596 
4597  /**
4598  * End element handler
4599  * @param const XML_Char *pszName
4600  */
4601  virtual void end(const XML_Char *pszName);
4602  };
4603 
4604  class ListOfGlobalRenderInformationElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4605  {
4606  // Attributes
4607  private:
4608  /**
4609  *
4610  */
4611  enum Element
4612  {
4615  };
4616 
4617  // Operations
4618  public:
4619  /**
4620  * Constructor
4621  */
4623  SCopasiXMLParserCommon & common);
4624 
4625  /**
4626  * Destructor
4627  */
4629 
4630  /**
4631  * Start element handler
4632  * @param const XML_Char *pszName
4633  * @param const XML_Char **papszAttrs
4634  */
4635  virtual void start(const XML_Char *pszName,
4636  const XML_Char **papszAttrs);
4637 
4638  /**
4639  * End element handler
4640  * @param const XML_Char *pszName
4641  */
4642  virtual void end(const XML_Char *pszName);
4643  };
4644 
4645  class LocalRenderInformationElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4646  {
4647  // Attributes
4648  private:
4649  /**
4650  *
4651  */
4652  enum Element
4653  {
4659  };
4660 
4661  // Operations
4662  public:
4663  /**
4664  * Constructor
4665  */
4667  SCopasiXMLParserCommon & common);
4668 
4669  /**
4670  * Destructor
4671  */
4673 
4674  /**
4675  * Start element handler
4676  * @param const XML_Char *pszName
4677  * @param const XML_Char **papszAttrs
4678  */
4679  virtual void start(const XML_Char *pszName,
4680  const XML_Char **papszAttrs);
4681 
4682  /**
4683  * End element handler
4684  * @param const XML_Char *pszName
4685  */
4686  virtual void end(const XML_Char *pszName);
4687  };
4688 
4689  class GlobalRenderInformationElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4690  {
4691  // Attributes
4692  private:
4693  /**
4694  *
4695  */
4696  enum Element
4697  {
4703  };
4704 
4705  // Operations
4706  public:
4707  /**
4708  * Constructor
4709  */
4711  SCopasiXMLParserCommon & common);
4712 
4713  /**
4714  * Destructor
4715  */
4717 
4718  /**
4719  * Start element handler
4720  * @param const XML_Char *pszName
4721  * @param const XML_Char **papszAttrs
4722  */
4723  virtual void start(const XML_Char *pszName,
4724  const XML_Char **papszAttrs);
4725 
4726  /**
4727  * End element handler
4728  * @param const XML_Char *pszName
4729  */
4730  virtual void end(const XML_Char *pszName);
4731  };
4732 
4733  class GroupElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4734  {
4735  // Attributes
4736  private:
4737  /**
4738  *
4739  */
4740  enum Element
4741  {
4742  Group = 0,
4744  };
4745 
4746  // Operations
4747  public:
4748  /**
4749  * Constructor
4750  */
4751  GroupElement(CCopasiXMLParser & parser,
4752  SCopasiXMLParserCommon & common);
4753 
4754  /**
4755  * Destructor
4756  */
4757  virtual ~GroupElement();
4758 
4759  /**
4760  * Start element handler
4761  * @param const XML_Char *pszName
4762  * @param const XML_Char **papszAttrs
4763  */
4764  virtual void start(const XML_Char *pszName,
4765  const XML_Char **papszAttrs);
4766 
4767  /**
4768  * End element handler
4769  * @param const XML_Char *pszName
4770  */
4771  virtual void end(const XML_Char *pszName);
4772  };
4773 
4774  class BoundingBoxElement : public CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon >
4775  {
4776  // Attributes
4777  private:
4778  /**
4779  *
4780  */
4781  enum Element
4782  {
4786  };
4787 
4788  // Operations
4789  public:
4790  /**
4791  * Constructor
4792  */
4794  SCopasiXMLParserCommon & common);
4795 
4796  /**
4797  * Destructor
4798  */
4799  virtual ~BoundingBoxElement();
4800 
4801  /**
4802  * Start element handler
4803  * @param const XML_Char *pszName
4804  * @param const XML_Char **papszAttrs
4805  */
4806  virtual void start(const XML_Char *pszName,
4807  const XML_Char **papszAttrs);
4808 
4809  /**
4810  * End element handler
4811  * @param const XML_Char *pszName
4812  */
4813  virtual void end(const XML_Char *pszName);
4814  };
4815 
4816  // Operations
4817 private:
4818  /**
4819  * Constructor
4820  */
4821  CCopasiXMLParser();
4822 
4823 public:
4824  /**
4825  * Public constructor
4826  * @param CVersion & version
4827  */
4828  CCopasiXMLParser(CVersion & version);
4829 
4830  /**
4831  * Destructor
4832  */
4834 
4835  /**
4836  * Start element handler
4837  * @param const XML_Char *pszName
4838  * @param const XML_Char **papszAttrs
4839  */
4840  virtual void onStartElement(const XML_Char *pszName,
4841  const XML_Char **papszAttrs);
4842 
4843  /**
4844  * End element handler
4845  * @param const XML_Char *pszName
4846  */
4847  virtual void onEndElement(const XML_Char *pszName);
4848 
4849  /**
4850  * Set the datamodel.
4851  * @param CCopasiDataModel* pDataModel
4852  */
4853  void setDatamodel(CCopasiDataModel* pDataModel);
4854 
4855  /**
4856  * Set the list of loaded functions
4857  * @param CCopasiVectorN< CFunction > * pFunctionList
4858  */
4859  void setFunctionList(CCopasiVectorN< CFunction > * pFunctionList);
4860 
4861 #ifdef XXXX
4862  /**
4863  * Start CDATA section handler
4864  */
4865  virtual void onStartCdataSection();
4866 
4867  /**
4868  * End CDATA section handler
4869  */
4870  virtual void onEndCdataSection();
4871 #endif // XXXX
4872 
4873  /**
4874  * Skipped entity handler
4875  * This is called in two situations:
4876  * 1) An entity reference is encountered for which no declaration
4877  * has been read *and* this is not an error.
4878  * 2) An internal entity reference is read, but not expanded, because
4879  * XML_SetDefaultHandler has been called.
4880  * Note: skipped parameter entities in declarations and skipped general
4881  * entities in attribute values cannot be reported, because
4882  * the event would be out of sync with the reporting of the
4883  * declarations or attribute values
4884  * @param const XML_Char *entityName
4885  * @param int is_parameter_entity
4886  */
4887  virtual void onSkippedEntityHandler(const XML_Char * entityName,
4888  int is_parameter_entity);
4889 
4890  /**
4891  * Enable/Disable the character data handler
4892  * @param bool fEnable (Default: true)
4893  */
4894  void enableCharacterDataHandler(bool fEnable = true);
4895 
4896  /**
4897  * Character data handler
4898  * @param const XML_Char *pszData
4899  * @param int nLength
4900  */
4901  virtual void onCharacterData(const XML_Char *pszData,
4902  int nLength);
4903  /**
4904  * Retrieve the data.
4905  * Any sequence of toBeStripped characters is replaced by a single
4906  * join character. The default is no stripping.
4907  * @param const std::string & toBeStripped (default: "")
4908  * @param const std::string & join (default: " ")
4909  * @return std::string data
4910  */
4911  std::string getCharacterData(const std::string & toBeStripped = "",
4912  const std::string & join = " ");
4913 
4914  /**
4915  * Push the element handler on the stack.
4916  * @param CXMLHandler< CCopasiXMLParser > elementHandler
4917  */
4919 
4920  /**
4921  * Pop the element handler form the stack.
4922  */
4923  void popElementHandler();
4924 
4925  /**
4926  * Retrieve the loaded model functions
4927  * @return CModel * pModel
4928  */
4929  CModel * getModel() const;
4930 
4931  /**
4932  * Retrieve the list of loaded reports
4933  * @return CReportDefinitionVector * pReportList
4934  */
4936 
4937  /**
4938  * Retrieve the list of loaded functions
4939  * @return CCopasiVectorN< CTask > * pTaskList
4940  */
4942 
4943  /**
4944  * Retrieve the list of loaded functions
4945  * @return COutputDefinitionVector * pPlotList
4946  */
4948 
4949  /**
4950  * Set the GUI information to be saved
4951  * @param SCopasiXMLGUI * pGUI
4952  */
4953  void setGUI(SCopasiXMLGUI * pGUI);
4954 
4955  /**
4956  * Set the list of loaded layouts
4957  * @param CListOfLayouts * pLayoutList
4958  */
4959  void setLayoutList(CListOfLayouts * pLayoutList);
4960 
4961  /**
4962  * Retrieve the list of loaded layouts
4963  * @return CListOfLayouts * pLayoutList
4964  */
4965  CListOfLayouts * getLayoutList() const;
4966 
4967  /**
4968  * Retrieve a pointer to the current group if available
4969  * @return const CCopasiParameterGroup * currentGroup
4970  */
4971  const CCopasiParameterGroup * getCurrentGroup() const;
4972 
4973  /**
4974  * Retrieve an object by its CN within the context of the parser
4975  * @param const std::string & cn
4976  * @return const CCopasiObject * pObject
4977  */
4978  const CCopasiObject * getObjectFromName(const std::string & cn) const;
4979 };
4980 
4981 #endif // COPASI_CCopasiXMLParser
CLLineEnding * pLineEnding
virtual void end(const XML_Char *pszName)
Definition: CEvent.h:152
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
CCopasiVectorN< CFunction > * pFunctionList
ComplexElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
ListOfEventsElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
ListOfReportsElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
GroupElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
CCopasiVectorN< CCopasiTask > * pTaskList
SCopasiXMLParserCommon mCommon
CPlotSpecification * pCurrentPlot
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
CLMetabGlyph * pMetaboliteGlyph
virtual void end(const XML_Char *pszName)
virtual void onSkippedEntityHandler(const XML_Char *entityName, int is_parameter_entity)
MetaboliteGlyphElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
ListOfSubstratesElement * mpListOfSubstratesElement
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
ReportInstanceElement * mpReportElement
std::map< std::string, std::vector< std::pair< std::vector< CRegisteredObjectName > *, size_t > > > reportReferenceMap
CCopasiXMLInterface::EncodingType mCharacterDataEncoding
virtual void end(const XML_Char *pszName)
CCopasiDataModel * pDataModel
ParameterGroupElement * mpProblemElement
SBMLReferenceElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
Definition: CLText.h:27
virtual void end(const XML_Char *pszName)
virtual void end(const XML_Char *pszName)
CListOfLayouts * pLayoutList
virtual void end(const XML_Char *pszName)
ListOfTasksElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
ModelElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
UnknownElement mUnknownElement
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
TextGlyphElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
CurveElementElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
std::map< std::string, std::vector< std::string > > SourceParameterKeys
std::vector< CModelEntity * > StateVariableList
virtual void end(const XML_Char *pszName)
CurveElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void end(const XML_Char *pszName)
void enableCharacterDataHandler(bool fEnable=true)
LocalRenderInformationElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void end(const XML_Char *pszName)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
std::stack< CXMLElementHandler< CCopasiXMLParser, SCopasiXMLParserCommon > * > mElementHandlerStack
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void end(const XML_Char *pszName)
CCopasiVectorN< CCopasiTask > * getTaskList() const
virtual void end(const XML_Char *pszName)
ListOfCallParametersElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
COutputDefinitionVector * pPlotList
EllipseElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
ListOfColorDefinitionsElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
std::pair< std::string, std::string > mAssignmentPair
virtual void onStartCdataSection()
Definition: CExpat.cpp:55
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
BoundingBoxElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
PlotItemElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void end(const XML_Char *pszName)
virtual void end(const XML_Char *pszName)
ListOfConstantsElement * mpListOfConstantsElement
ListOfSlidersElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
ListOfParameterDescriptionsElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
RectangleElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void end(const XML_Char *pszName)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
ReportElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
ListOfGlobalRenderInformationElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void end(const XML_Char *pszName)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void end(const XML_Char *pszName)
PolygonElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
virtual void start(const XML_Char *pszName, const XML_Char **papszAttrs)
ImageElement(CCopasiXMLParser &parser, SCopasiXMLParserCommon &common)