1 /**
2 * @file: MultiSpeciesType.cpp
3 * @brief: Implementation of the MultiSpeciesType class
4 * @author: SBMLTeam
5 *
6 * <!--------------------------------------------------------------------------
7 * This file is part of libSBML. Please visit http://sbml.org for more
8 * information about SBML, and the latest version of libSBML.
9 *
10 * Copyright (C) 2020 jointly by the following organizations:
11 * 1. California Institute of Technology, Pasadena, CA, USA
12 * 2. University of Heidelberg, Heidelberg, Germany
13 * 3. University College London, London, UK
14 *
15 * Copyright (C) 2009-2013 jointly by the following organizations:
16 * 1. California Institute of Technology, Pasadena, CA, USA
17 * 2. EMBL European Bioinformatics Institute (EMBL-EBI), Hinxton, UK
18 *
19 * Copyright (C) 2006-2008 by the California Institute of Technology,
20 * Pasadena, CA, USA
21 *
22 * Copyright (C) 2002-2005 jointly by the following organizations:
23 * 1. California Institute of Technology, Pasadena, CA, USA
24 * 2. Japan Science and Technology Agency, Japan
25 *
26 * This library is free software; you can redistribute it and/or modify it
27 * under the terms of the GNU Lesser General Public License as published by
28 * the Free Software Foundation. A copy of the license agreement is provided
29 * in the file named "LICENSE.txt" included with this software distribution
30 * and also available online as http://sbml.org/software/libsbml/license.html
31 * ------------------------------------------------------------------------ -->
32 */
33
34
35 #include <sbml/packages/multi/sbml/MultiSpeciesType.h>
36 #include <sbml/packages/multi/sbml/BindingSiteSpeciesType.h>
37 #include <sbml/packages/multi/validator/MultiSBMLError.h>
38
39 #include <sbml/util/ElementFilter.h>
40
41
42 using namespace std;
43
44
45 #ifdef __cplusplus
46
47 LIBSBML_CPP_NAMESPACE_BEGIN
48
49
50 /*
51 * Creates a new MultiSpeciesType with the given level, version, and package version.
52 */
MultiSpeciesType(unsigned int level,unsigned int version,unsigned int pkgVersion)53 MultiSpeciesType::MultiSpeciesType (unsigned int level, unsigned int version, unsigned int pkgVersion)
54 : SBase(level, version)
55 //// ,mId ("")
56 //// ,mName ("")
57 ,mCompartment ("")
58 ,mListOfSpeciesFeatureTypes (level, version, pkgVersion)
59 ,mListOfSpeciesTypeInstances (level, version, pkgVersion)
60 ,mListOfSpeciesTypeComponentIndexes (level, version, pkgVersion)
61 ,mListOfInSpeciesTypeBonds (level, version, pkgVersion)
62 {
63 // set an SBMLNamespaces derived object of this package
64 setSBMLNamespacesAndOwn(new MultiPkgNamespaces(level, version, pkgVersion));
65
66 // connect to child objects
67 connectToChild();
68 }
69
70
71 /*
72 * Creates a new MultiSpeciesType with the given MultiPkgNamespaces object.
73 */
MultiSpeciesType(MultiPkgNamespaces * multins)74 MultiSpeciesType::MultiSpeciesType (MultiPkgNamespaces* multins)
75 : SBase(multins)
76 //// ,mId ("")
77 //// ,mName ("")
78 ,mCompartment ("")
79 ,mListOfSpeciesFeatureTypes (multins)
80 ,mListOfSpeciesTypeInstances (multins)
81 ,mListOfSpeciesTypeComponentIndexes (multins)
82 ,mListOfInSpeciesTypeBonds (multins)
83 {
84 // set the element namespace of this object
85 setElementNamespace(multins->getURI());
86
87 // connect to child objects
88 connectToChild();
89
90 // load package extensions bound with this object (if any)
91 loadPlugins(multins);
92 }
93
94
95 /*
96 * Copy constructor for MultiSpeciesType.
97 */
MultiSpeciesType(const MultiSpeciesType & orig)98 MultiSpeciesType::MultiSpeciesType (const MultiSpeciesType& orig)
99 : SBase(orig)
100 // , mId ( orig.mId)
101 // , mName ( orig.mName)
102 , mCompartment ( orig.mCompartment)
103 ,mListOfSpeciesFeatureTypes (orig.mListOfSpeciesFeatureTypes)
104 ,mListOfSpeciesTypeInstances (orig.mListOfSpeciesTypeInstances)
105 ,mListOfSpeciesTypeComponentIndexes (orig.mListOfSpeciesTypeComponentIndexes)
106 ,mListOfInSpeciesTypeBonds (orig.mListOfInSpeciesTypeBonds)
107 {
108 // connect to child objects
109 connectToChild();
110 }
111
112
113 /*
114 * Assignment for MultiSpeciesType.
115 */
116 MultiSpeciesType&
operator =(const MultiSpeciesType & rhs)117 MultiSpeciesType::operator=(const MultiSpeciesType& rhs)
118 {
119 if (&rhs != this)
120 {
121 SBase::operator=(rhs);
122 mId = rhs.mId;
123 mName = rhs.mName;
124 mCompartment = rhs.mCompartment;
125 mListOfSpeciesFeatureTypes = rhs.mListOfSpeciesFeatureTypes;
126 mListOfSpeciesTypeInstances = rhs.mListOfSpeciesTypeInstances;
127 mListOfSpeciesTypeComponentIndexes = rhs.mListOfSpeciesTypeComponentIndexes;
128 mListOfInSpeciesTypeBonds = rhs.mListOfInSpeciesTypeBonds;
129
130 // connect to child objects
131 connectToChild();
132 }
133 return *this;
134 }
135
136
137 /*
138 * Clone for MultiSpeciesType.
139 */
140 MultiSpeciesType*
clone() const141 MultiSpeciesType::clone () const
142 {
143 return new MultiSpeciesType(*this);
144 }
145
146
147 /*
148 * Destructor for MultiSpeciesType.
149 */
~MultiSpeciesType()150 MultiSpeciesType::~MultiSpeciesType ()
151 {
152 }
153
154
155 /*
156 * Returns the value of the "id" attribute of this MultiSpeciesType.
157 */
158 const std::string&
getId() const159 MultiSpeciesType::getId() const
160 {
161 return mId;
162 }
163
164
165 /*
166 * Returns the value of the "name" attribute of this MultiSpeciesType.
167 */
168 const std::string&
getName() const169 MultiSpeciesType::getName() const
170 {
171 return mName;
172 }
173
174
175
176
177 /*
178 * Returns the value of the "compartment" attribute of this MultiSpeciesType.
179 */
180 const std::string&
getCompartment() const181 MultiSpeciesType::getCompartment() const
182 {
183 return mCompartment;
184 }
185
186
187 /*
188 * Returns true/false if id is set.
189 */
190 bool
isSetId() const191 MultiSpeciesType::isSetId() const
192 {
193 return (mId.empty() == false);
194 }
195
196
197 /*
198 * Returns true/false if name is set.
199 */
200 bool
isSetName() const201 MultiSpeciesType::isSetName() const
202 {
203 return (mName.empty() == false);
204 }
205
206
207
208
209 /*
210 * Returns true/false if compartment is set.
211 */
212 bool
isSetCompartment() const213 MultiSpeciesType::isSetCompartment() const
214 {
215 return (mCompartment.empty() == false);
216 }
217
218
219 /*
220 * Sets id and returns value indicating success.
221 */
222 int
setId(const std::string & id)223 MultiSpeciesType::setId(const std::string& id)
224 {
225 return SyntaxChecker::checkAndSetSId(id, mId);
226 }
227
228
229 /*
230 * Sets name and returns value indicating success.
231 */
232 int
setName(const std::string & name)233 MultiSpeciesType::setName(const std::string& name)
234 {
235 mName = name;
236 return LIBSBML_OPERATION_SUCCESS;
237 }
238
239
240
241
242 /*
243 * Sets compartment and returns value indicating success.
244 */
245 int
setCompartment(const std::string & compartment)246 MultiSpeciesType::setCompartment(const std::string& compartment)
247 {
248 if (!(SyntaxChecker::isValidInternalSId(compartment)))
249 {
250 return LIBSBML_INVALID_ATTRIBUTE_VALUE;
251 }
252 else
253 {
254 mCompartment = compartment;
255 return LIBSBML_OPERATION_SUCCESS;
256 }
257 }
258
259
260 /*
261 * Unsets id and returns value indicating success.
262 */
263 int
unsetId()264 MultiSpeciesType::unsetId()
265 {
266 mId.erase();
267
268 if (mId.empty() == true)
269 {
270 return LIBSBML_OPERATION_SUCCESS;
271 }
272 else
273 {
274 return LIBSBML_OPERATION_FAILED;
275 }
276 }
277
278
279 /*
280 * Unsets name and returns value indicating success.
281 */
282 int
unsetName()283 MultiSpeciesType::unsetName()
284 {
285 mName.erase();
286
287 if (mName.empty() == true)
288 {
289 return LIBSBML_OPERATION_SUCCESS;
290 }
291 else
292 {
293 return LIBSBML_OPERATION_FAILED;
294 }
295 }
296
297
298
299
300 /*
301 * Unsets compartment and returns value indicating success.
302 */
303 int
unsetCompartment()304 MultiSpeciesType::unsetCompartment()
305 {
306 mCompartment.erase();
307
308 if (mCompartment.empty() == true)
309 {
310 return LIBSBML_OPERATION_SUCCESS;
311 }
312 else
313 {
314 return LIBSBML_OPERATION_FAILED;
315 }
316 }
317
318
319 /*
320 * Returns the "ListOfSpeciesFeatureTypes" in this MultiSpeciesType object.
321 */
322 const ListOfSpeciesFeatureTypes*
getListOfSpeciesFeatureTypes() const323 MultiSpeciesType::getListOfSpeciesFeatureTypes() const
324 {
325 return &mListOfSpeciesFeatureTypes;
326 }
327
328
329 /*
330 * Returns the "ListOfSpeciesFeatureTypes" in this MultiSpeciesType object.
331 */
332 ListOfSpeciesFeatureTypes*
getListOfSpeciesFeatureTypes()333 MultiSpeciesType::getListOfSpeciesFeatureTypes()
334 {
335 return &mListOfSpeciesFeatureTypes;
336 }
337
338
339 /*
340 * Removes the nth SpeciesFeatureType from the ListOfSpeciesFeatureTypes.
341 */
342 SpeciesFeatureType*
removeSpeciesFeatureType(unsigned int n)343 MultiSpeciesType::removeSpeciesFeatureType(unsigned int n)
344 {
345 return mListOfSpeciesFeatureTypes.remove(n);
346 }
347
348
349 /*
350 * Removes the a SpeciesFeatureType with given id from the ListOfSpeciesFeatureTypes.
351 */
352 SpeciesFeatureType*
removeSpeciesFeatureType(const std::string & sid)353 MultiSpeciesType::removeSpeciesFeatureType(const std::string& sid)
354 {
355 return mListOfSpeciesFeatureTypes.remove(sid);
356 }
357
358
359 /*
360 * Return the nth SpeciesFeatureType in the ListOfSpeciesFeatureTypes within this MultiSpeciesType.
361 */
362 SpeciesFeatureType*
getSpeciesFeatureType(unsigned int n)363 MultiSpeciesType::getSpeciesFeatureType(unsigned int n)
364 {
365 return mListOfSpeciesFeatureTypes.get(n);
366 }
367
368
369 /*
370 * Return the nth SpeciesFeatureType in the ListOfSpeciesFeatureTypes within this MultiSpeciesType.
371 */
372 const SpeciesFeatureType*
getSpeciesFeatureType(unsigned int n) const373 MultiSpeciesType::getSpeciesFeatureType(unsigned int n) const
374 {
375 return mListOfSpeciesFeatureTypes.get(n);
376 }
377
378
379 /*
380 * Return a SpeciesFeatureType from the ListOfSpeciesFeatureTypes by id.
381 */
382 SpeciesFeatureType*
getSpeciesFeatureType(const std::string & sid)383 MultiSpeciesType::getSpeciesFeatureType(const std::string& sid)
384 {
385 return mListOfSpeciesFeatureTypes.get(sid);
386 }
387
388
389 /*
390 * Return a SpeciesFeatureType from the ListOfSpeciesFeatureTypes by id.
391 */
392 const SpeciesFeatureType*
getSpeciesFeatureType(const std::string & sid) const393 MultiSpeciesType::getSpeciesFeatureType(const std::string& sid) const
394 {
395 return mListOfSpeciesFeatureTypes.get(sid);
396 }
397
398
399 /*
400 * Adds a copy the given "SpeciesFeatureType" to this MultiSpeciesType.
401 */
402 int
addSpeciesFeatureType(const SpeciesFeatureType * sft)403 MultiSpeciesType::addSpeciesFeatureType(const SpeciesFeatureType* sft)
404 {
405 if (sft == NULL)
406 {
407 return LIBSBML_OPERATION_FAILED;
408 }
409 else if (sft->hasRequiredAttributes() == false)
410 {
411 return LIBSBML_INVALID_OBJECT;
412 }
413 else if (getLevel() != sft->getLevel())
414 {
415 return LIBSBML_LEVEL_MISMATCH;
416 }
417 else if (getVersion() != sft->getVersion())
418 {
419 return LIBSBML_VERSION_MISMATCH;
420 }
421 else if (matchesRequiredSBMLNamespacesForAddition(static_cast<const SBase *>(sft)) == false)
422 {
423 return LIBSBML_NAMESPACES_MISMATCH;
424 }
425 else
426 {
427 mListOfSpeciesFeatureTypes.append(sft);
428
429 return LIBSBML_OPERATION_SUCCESS;
430 }
431 }
432
433
434 /*
435 * Get the number of SpeciesFeatureType objects in this MultiSpeciesType.
436 */
437 unsigned int
getNumSpeciesFeatureTypes() const438 MultiSpeciesType::getNumSpeciesFeatureTypes() const
439 {
440 return mListOfSpeciesFeatureTypes.size();
441 }
442
443
444 /*
445 * Creates a new SpeciesFeatureType object, adds it to this MultiSpeciesTypes
446 */
447 SpeciesFeatureType*
createSpeciesFeatureType()448 MultiSpeciesType::createSpeciesFeatureType()
449 {
450 SpeciesFeatureType* sft = NULL;
451
452 try
453 {
454 MULTI_CREATE_NS(multins, getSBMLNamespaces());
455 sft = new SpeciesFeatureType(multins);
456 delete multins;
457 }
458 catch (...)
459 {
460 /* here we do not create a default object as the level/version must
461 * match the parent object
462 *
463 * do nothing
464 */
465 }
466
467 if(sft != NULL)
468 {
469 mListOfSpeciesFeatureTypes.appendAndOwn(sft);
470 }
471
472 return sft;
473 }
474
475
476 /*
477 * Returns the "ListOfSpeciesTypeInstances" in this MultiSpeciesType object.
478 */
479 const ListOfSpeciesTypeInstances*
getListOfSpeciesTypeInstances() const480 MultiSpeciesType::getListOfSpeciesTypeInstances() const
481 {
482 return &mListOfSpeciesTypeInstances;
483 }
484
485
486 /*
487 * Returns the "ListOfSpeciesTypeInstances" in this MultiSpeciesType object.
488 */
489 ListOfSpeciesTypeInstances*
getListOfSpeciesTypeInstances()490 MultiSpeciesType::getListOfSpeciesTypeInstances()
491 {
492 return &mListOfSpeciesTypeInstances;
493 }
494
495
496 /*
497 * Removes the nth SpeciesTypeInstance from the ListOfSpeciesTypeInstances.
498 */
499 SpeciesTypeInstance*
removeSpeciesTypeInstance(unsigned int n)500 MultiSpeciesType::removeSpeciesTypeInstance(unsigned int n)
501 {
502 return mListOfSpeciesTypeInstances.remove(n);
503 }
504
505
506 /*
507 * Removes the a SpeciesTypeInstance with given id from the ListOfSpeciesTypeInstances.
508 */
509 SpeciesTypeInstance*
removeSpeciesTypeInstance(const std::string & sid)510 MultiSpeciesType::removeSpeciesTypeInstance(const std::string& sid)
511 {
512 return mListOfSpeciesTypeInstances.remove(sid);
513 }
514
515
516 /*
517 * Return the nth SpeciesTypeInstance in the ListOfSpeciesTypeInstances within this MultiSpeciesType.
518 */
519 SpeciesTypeInstance*
getSpeciesTypeInstance(unsigned int n)520 MultiSpeciesType::getSpeciesTypeInstance(unsigned int n)
521 {
522 return mListOfSpeciesTypeInstances.get(n);
523 }
524
525
526 /*
527 * Return the nth SpeciesTypeInstance in the ListOfSpeciesTypeInstances within this MultiSpeciesType.
528 */
529 const SpeciesTypeInstance*
getSpeciesTypeInstance(unsigned int n) const530 MultiSpeciesType::getSpeciesTypeInstance(unsigned int n) const
531 {
532 return mListOfSpeciesTypeInstances.get(n);
533 }
534
535
536 /*
537 * Return a SpeciesTypeInstance from the ListOfSpeciesTypeInstances by id.
538 */
539 SpeciesTypeInstance*
getSpeciesTypeInstance(const std::string & sid)540 MultiSpeciesType::getSpeciesTypeInstance(const std::string& sid)
541 {
542 return mListOfSpeciesTypeInstances.get(sid);
543 }
544
545
546 /*
547 * Return a SpeciesTypeInstance from the ListOfSpeciesTypeInstances by id.
548 */
549 const SpeciesTypeInstance*
getSpeciesTypeInstance(const std::string & sid) const550 MultiSpeciesType::getSpeciesTypeInstance(const std::string& sid) const
551 {
552 return mListOfSpeciesTypeInstances.get(sid);
553 }
554
555
556 /*
557 * Adds a copy the given "SpeciesTypeInstance" to this MultiSpeciesType.
558 */
559 int
addSpeciesTypeInstance(const SpeciesTypeInstance * sti)560 MultiSpeciesType::addSpeciesTypeInstance(const SpeciesTypeInstance* sti)
561 {
562 if (sti == NULL)
563 {
564 return LIBSBML_OPERATION_FAILED;
565 }
566 else if (sti->hasRequiredAttributes() == false)
567 {
568 return LIBSBML_INVALID_OBJECT;
569 }
570 else if (getLevel() != sti->getLevel())
571 {
572 return LIBSBML_LEVEL_MISMATCH;
573 }
574 else if (getVersion() != sti->getVersion())
575 {
576 return LIBSBML_VERSION_MISMATCH;
577 }
578 else if (matchesRequiredSBMLNamespacesForAddition(static_cast<const SBase *>(sti)) == false)
579 {
580 return LIBSBML_NAMESPACES_MISMATCH;
581 }
582 else
583 {
584 mListOfSpeciesTypeInstances.append(sti);
585
586 return LIBSBML_OPERATION_SUCCESS;
587 }
588 }
589
590
591 /*
592 * Get the number of SpeciesTypeInstance objects in this MultiSpeciesType.
593 */
594 unsigned int
getNumSpeciesTypeInstances() const595 MultiSpeciesType::getNumSpeciesTypeInstances() const
596 {
597 return mListOfSpeciesTypeInstances.size();
598 }
599
600
601 /*
602 * Creates a new SpeciesTypeInstance object, adds it to this MultiSpeciesTypes
603 */
604 SpeciesTypeInstance*
createSpeciesTypeInstance()605 MultiSpeciesType::createSpeciesTypeInstance()
606 {
607 SpeciesTypeInstance* sti = NULL;
608
609 try
610 {
611 MULTI_CREATE_NS(multins, getSBMLNamespaces());
612 sti = new SpeciesTypeInstance(multins);
613 delete multins;
614 }
615 catch (...)
616 {
617 /* here we do not create a default object as the level/version must
618 * match the parent object
619 *
620 * do nothing
621 */
622 }
623
624 if(sti != NULL)
625 {
626 mListOfSpeciesTypeInstances.appendAndOwn(sti);
627 }
628
629 return sti;
630 }
631
632
633 /*
634 * Returns the "ListOfSpeciesTypeComponentIndexes" in this MultiSpeciesType object.
635 */
636 const ListOfSpeciesTypeComponentIndexes*
getListOfSpeciesTypeComponentIndexes() const637 MultiSpeciesType::getListOfSpeciesTypeComponentIndexes() const
638 {
639 return &mListOfSpeciesTypeComponentIndexes;
640 }
641
642
643 /*
644 * Returns the "ListOfSpeciesTypeComponentIndexes" in this MultiSpeciesType object.
645 */
646 ListOfSpeciesTypeComponentIndexes*
getListOfSpeciesTypeComponentIndexes()647 MultiSpeciesType::getListOfSpeciesTypeComponentIndexes()
648 {
649 return &mListOfSpeciesTypeComponentIndexes;
650 }
651
652
653 /*
654 * Removes the nth SpeciesTypeComponentIndex from the ListOfSpeciesTypeComponentIndexes.
655 */
656 SpeciesTypeComponentIndex*
removeSpeciesTypeComponentIndex(unsigned int n)657 MultiSpeciesType::removeSpeciesTypeComponentIndex(unsigned int n)
658 {
659 return mListOfSpeciesTypeComponentIndexes.remove(n);
660 }
661
662
663 /*
664 * Removes the a SpeciesTypeComponentIndex with given id from the ListOfSpeciesTypeComponentIndexes.
665 */
666 SpeciesTypeComponentIndex*
removeSpeciesTypeComponentIndex(const std::string & sid)667 MultiSpeciesType::removeSpeciesTypeComponentIndex(const std::string& sid)
668 {
669 return mListOfSpeciesTypeComponentIndexes.remove(sid);
670 }
671
672
673 /*
674 * Return the nth SpeciesTypeComponentIndex in the ListOfSpeciesTypeComponentIndexes within this MultiSpeciesType.
675 */
676 SpeciesTypeComponentIndex*
getSpeciesTypeComponentIndex(unsigned int n)677 MultiSpeciesType::getSpeciesTypeComponentIndex(unsigned int n)
678 {
679 return mListOfSpeciesTypeComponentIndexes.get(n);
680 }
681
682
683 /*
684 * Return the nth SpeciesTypeComponentIndex in the ListOfSpeciesTypeComponentIndexes within this MultiSpeciesType.
685 */
686 const SpeciesTypeComponentIndex*
getSpeciesTypeComponentIndex(unsigned int n) const687 MultiSpeciesType::getSpeciesTypeComponentIndex(unsigned int n) const
688 {
689 return mListOfSpeciesTypeComponentIndexes.get(n);
690 }
691
692
693 /*
694 * Return a SpeciesTypeComponentIndex from the ListOfSpeciesTypeComponentIndexes by id.
695 */
696 SpeciesTypeComponentIndex*
getSpeciesTypeComponentIndex(const std::string & sid)697 MultiSpeciesType::getSpeciesTypeComponentIndex(const std::string& sid)
698 {
699 return mListOfSpeciesTypeComponentIndexes.get(sid);
700 }
701
702
703 /*
704 * Return a SpeciesTypeComponentIndex from the ListOfSpeciesTypeComponentIndexes by id.
705 */
706 const SpeciesTypeComponentIndex*
getSpeciesTypeComponentIndex(const std::string & sid) const707 MultiSpeciesType::getSpeciesTypeComponentIndex(const std::string& sid) const
708 {
709 return mListOfSpeciesTypeComponentIndexes.get(sid);
710 }
711
712
713 /*
714 * Adds a copy the given "SpeciesTypeComponentIndex" to this MultiSpeciesType.
715 */
716 int
addSpeciesTypeComponentIndex(const SpeciesTypeComponentIndex * stci)717 MultiSpeciesType::addSpeciesTypeComponentIndex(const SpeciesTypeComponentIndex* stci)
718 {
719 if (stci == NULL)
720 {
721 return LIBSBML_OPERATION_FAILED;
722 }
723 else if (stci->hasRequiredAttributes() == false)
724 {
725 return LIBSBML_INVALID_OBJECT;
726 }
727 else if (getLevel() != stci->getLevel())
728 {
729 return LIBSBML_LEVEL_MISMATCH;
730 }
731 else if (getVersion() != stci->getVersion())
732 {
733 return LIBSBML_VERSION_MISMATCH;
734 }
735 else if (matchesRequiredSBMLNamespacesForAddition(static_cast<const SBase *>(stci)) == false)
736 {
737 return LIBSBML_NAMESPACES_MISMATCH;
738 }
739 else
740 {
741 mListOfSpeciesTypeComponentIndexes.append(stci);
742
743 return LIBSBML_OPERATION_SUCCESS;
744 }
745 }
746
747
748 /*
749 * Get the number of SpeciesTypeComponentIndex objects in this MultiSpeciesType.
750 */
751 unsigned int
getNumSpeciesTypeComponentIndexes() const752 MultiSpeciesType::getNumSpeciesTypeComponentIndexes() const
753 {
754 return mListOfSpeciesTypeComponentIndexes.size();
755 }
756
757
758 /*
759 * Creates a new SpeciesTypeComponentIndex object, adds it to this MultiSpeciesTypes
760 */
761 SpeciesTypeComponentIndex*
createSpeciesTypeComponentIndex()762 MultiSpeciesType::createSpeciesTypeComponentIndex()
763 {
764 SpeciesTypeComponentIndex* stci = NULL;
765
766 try
767 {
768 MULTI_CREATE_NS(multins, getSBMLNamespaces());
769 stci = new SpeciesTypeComponentIndex(multins);
770 delete multins;
771 }
772 catch (...)
773 {
774 /* here we do not create a default object as the level/version must
775 * match the parent object
776 *
777 * do nothing
778 */
779 }
780
781 if(stci != NULL)
782 {
783 mListOfSpeciesTypeComponentIndexes.appendAndOwn(stci);
784 }
785
786 return stci;
787 }
788
789
790 /*
791 * Returns the "ListOfInSpeciesTypeBonds" in this MultiSpeciesType object.
792 */
793 const ListOfInSpeciesTypeBonds*
getListOfInSpeciesTypeBonds() const794 MultiSpeciesType::getListOfInSpeciesTypeBonds() const
795 {
796 return &mListOfInSpeciesTypeBonds;
797 }
798
799
800 /*
801 * Returns the "ListOfInSpeciesTypeBonds" in this MultiSpeciesType object.
802 */
803 ListOfInSpeciesTypeBonds*
getListOfInSpeciesTypeBonds()804 MultiSpeciesType::getListOfInSpeciesTypeBonds()
805 {
806 return &mListOfInSpeciesTypeBonds;
807 }
808
809
810 /*
811 * Removes the nth InSpeciesTypeBond from the ListOfInSpeciesTypeBonds.
812 */
813 InSpeciesTypeBond*
removeInSpeciesTypeBond(unsigned int n)814 MultiSpeciesType::removeInSpeciesTypeBond(unsigned int n)
815 {
816 return mListOfInSpeciesTypeBonds.remove(n);
817 }
818
819
820 /*
821 * Removes the a InSpeciesTypeBond with given id from the ListOfInSpeciesTypeBonds.
822 */
823 InSpeciesTypeBond*
removeInSpeciesTypeBond(const std::string & sid)824 MultiSpeciesType::removeInSpeciesTypeBond(const std::string& sid)
825 {
826 return mListOfInSpeciesTypeBonds.remove(sid);
827 }
828
829
830 /*
831 * Return the nth InSpeciesTypeBond in the ListOfInSpeciesTypeBonds within this MultiSpeciesType.
832 */
833 InSpeciesTypeBond*
getInSpeciesTypeBond(unsigned int n)834 MultiSpeciesType::getInSpeciesTypeBond(unsigned int n)
835 {
836 return mListOfInSpeciesTypeBonds.get(n);
837 }
838
839
840 /*
841 * Return the nth InSpeciesTypeBond in the ListOfInSpeciesTypeBonds within this MultiSpeciesType.
842 */
843 const InSpeciesTypeBond*
getInSpeciesTypeBond(unsigned int n) const844 MultiSpeciesType::getInSpeciesTypeBond(unsigned int n) const
845 {
846 return mListOfInSpeciesTypeBonds.get(n);
847 }
848
849
850 /*
851 * Return a InSpeciesTypeBond from the ListOfInSpeciesTypeBonds by id.
852 */
853 InSpeciesTypeBond*
getInSpeciesTypeBond(const std::string & sid)854 MultiSpeciesType::getInSpeciesTypeBond(const std::string& sid)
855 {
856 return mListOfInSpeciesTypeBonds.get(sid);
857 }
858
859
860 /*
861 * Return a InSpeciesTypeBond from the ListOfInSpeciesTypeBonds by id.
862 */
863 const InSpeciesTypeBond*
getInSpeciesTypeBond(const std::string & sid) const864 MultiSpeciesType::getInSpeciesTypeBond(const std::string& sid) const
865 {
866 return mListOfInSpeciesTypeBonds.get(sid);
867 }
868
869
870 /*
871 * Adds a copy the given "InSpeciesTypeBond" to this MultiSpeciesType.
872 */
873 int
addInSpeciesTypeBond(const InSpeciesTypeBond * istb)874 MultiSpeciesType::addInSpeciesTypeBond(const InSpeciesTypeBond* istb)
875 {
876 if (istb == NULL)
877 {
878 return LIBSBML_OPERATION_FAILED;
879 }
880 else if (istb->hasRequiredAttributes() == false)
881 {
882 return LIBSBML_INVALID_OBJECT;
883 }
884 else if (getLevel() != istb->getLevel())
885 {
886 return LIBSBML_LEVEL_MISMATCH;
887 }
888 else if (getVersion() != istb->getVersion())
889 {
890 return LIBSBML_VERSION_MISMATCH;
891 }
892 else if (matchesRequiredSBMLNamespacesForAddition(static_cast<const SBase *>(istb)) == false)
893 {
894 return LIBSBML_NAMESPACES_MISMATCH;
895 }
896 else
897 {
898 mListOfInSpeciesTypeBonds.append(istb);
899
900 return LIBSBML_OPERATION_SUCCESS;
901 }
902 }
903
904
905 /*
906 * Get the number of InSpeciesTypeBond objects in this MultiSpeciesType.
907 */
908 unsigned int
getNumInSpeciesTypeBonds() const909 MultiSpeciesType::getNumInSpeciesTypeBonds() const
910 {
911 return mListOfInSpeciesTypeBonds.size();
912 }
913
914
915 /*
916 * Creates a new InSpeciesTypeBond object, adds it to this MultiSpeciesTypes
917 */
918 InSpeciesTypeBond*
createInSpeciesTypeBond()919 MultiSpeciesType::createInSpeciesTypeBond()
920 {
921 InSpeciesTypeBond* istb = NULL;
922
923 try
924 {
925 MULTI_CREATE_NS(multins, getSBMLNamespaces());
926 istb = new InSpeciesTypeBond(multins);
927 delete multins;
928 }
929 catch (...)
930 {
931 /* here we do not create a default object as the level/version must
932 * match the parent object
933 *
934 * do nothing
935 */
936 }
937
938 if(istb != NULL)
939 {
940 mListOfInSpeciesTypeBonds.appendAndOwn(istb);
941 }
942
943 return istb;
944 }
945
946
947 /*
948 * rename attributes that are SIdRefs or instances in math
949 */
950 void
renameSIdRefs(const std::string & oldid,const std::string & newid)951 MultiSpeciesType::renameSIdRefs(const std::string& oldid, const std::string& newid)
952 {
953 SBase::renameSIdRefs(oldid, newid);
954 if (isSetCompartment() == true && mCompartment == oldid)
955 {
956 setCompartment(newid);
957 }
958
959 }
960
961
962 List*
getAllElements(ElementFilter * filter)963 MultiSpeciesType::getAllElements(ElementFilter* filter)
964 {
965 List* ret = new List();
966 List* sublist = NULL;
967
968 ADD_FILTERED_LIST(ret, sublist, mListOfSpeciesFeatureTypes, filter);
969 ADD_FILTERED_LIST(ret, sublist, mListOfSpeciesTypeInstances, filter);
970 ADD_FILTERED_LIST(ret, sublist, mListOfSpeciesTypeComponentIndexes, filter);
971 ADD_FILTERED_LIST(ret, sublist, mListOfInSpeciesTypeBonds, filter);
972
973 ADD_FILTERED_FROM_PLUGIN(ret, sublist, filter);
974
975 return ret;
976 }
977
978
979 /*
980 * Returns the XML element name of this object
981 */
982 const std::string&
getElementName() const983 MultiSpeciesType::getElementName () const
984 {
985 static const string name = "speciesType";
986 return name;
987 }
988
989
990 /*
991 * Returns the libSBML type code for this SBML object.
992 */
993 int
getTypeCode() const994 MultiSpeciesType::getTypeCode () const
995 {
996 return SBML_MULTI_SPECIES_TYPE;
997 }
998
999
1000 /*
1001 * check if all the required attributes are set
1002 */
1003 bool
hasRequiredAttributes() const1004 MultiSpeciesType::hasRequiredAttributes () const
1005 {
1006 bool allPresent = true;
1007
1008 if (isSetId() == false)
1009 allPresent = false;
1010
1011
1012 return allPresent;
1013 }
1014
1015
1016 /*
1017 * check if all the required elements are set
1018 */
1019 bool
hasRequiredElements() const1020 MultiSpeciesType::hasRequiredElements () const
1021 {
1022 bool allPresent = true;
1023
1024 return allPresent;
1025 }
1026
1027
1028 /** @cond doxygenLibsbmlInternal */
1029
1030 /*
1031 * write contained elements
1032 */
1033 void
writeElements(XMLOutputStream & stream) const1034 MultiSpeciesType::writeElements (XMLOutputStream& stream) const
1035 {
1036 SBase::writeElements(stream);
1037
1038 if (getNumSpeciesFeatureTypes() > 0)
1039 {
1040 mListOfSpeciesFeatureTypes.write(stream);
1041 }
1042
1043 if (getNumSpeciesTypeInstances() > 0)
1044 {
1045 mListOfSpeciesTypeInstances.write(stream);
1046 }
1047
1048 if (getNumSpeciesTypeComponentIndexes() > 0)
1049 {
1050 mListOfSpeciesTypeComponentIndexes.write(stream);
1051 }
1052
1053 if (getNumInSpeciesTypeBonds() > 0)
1054 {
1055 mListOfInSpeciesTypeBonds.write(stream);
1056 }
1057
1058 SBase::writeExtensionElements(stream);
1059 }
1060
1061
1062 /** @endcond */
1063
1064
1065 /** @cond doxygenLibsbmlInternal */
1066
1067 /*
1068 * Accepts the given SBMLVisitor.
1069 */
1070 bool
accept(SBMLVisitor & v) const1071 MultiSpeciesType::accept (SBMLVisitor& v) const
1072 {
1073 v.visit(*this);
1074
1075 // SpeciesFeatureType
1076 for(unsigned int i = 0; i < getNumSpeciesFeatureTypes(); i++)
1077 {
1078 getSpeciesFeatureType(i)->accept(v);
1079 }
1080
1081 // SpeciesTypeInstance
1082 for(unsigned int i = 0; i < getNumSpeciesTypeInstances(); i++)
1083 {
1084 getSpeciesTypeInstance(i)->accept(v);
1085 }
1086
1087 // SpeciesTypeComponentIndex
1088 for(unsigned int i = 0; i < getNumSpeciesTypeComponentIndexes(); i++)
1089 {
1090 getSpeciesTypeComponentIndex(i)->accept(v);
1091 }
1092
1093 // InSpeciesTypeBond
1094 for(unsigned int i = 0; i < getNumInSpeciesTypeBonds(); i++)
1095 {
1096 getInSpeciesTypeBond(i)->accept(v);
1097 }
1098
1099 return true;
1100 }
1101
1102
1103 /** @endcond */
1104
1105
1106 /** @cond doxygenLibsbmlInternal */
1107
1108 /*
1109 * Sets the parent SBMLDocument.
1110 */
1111 void
setSBMLDocument(SBMLDocument * d)1112 MultiSpeciesType::setSBMLDocument (SBMLDocument* d)
1113 {
1114 SBase::setSBMLDocument(d);
1115 mListOfSpeciesFeatureTypes.setSBMLDocument(d);
1116 mListOfSpeciesTypeInstances.setSBMLDocument(d);
1117 mListOfSpeciesTypeComponentIndexes.setSBMLDocument(d);
1118 mListOfInSpeciesTypeBonds.setSBMLDocument(d);
1119 }
1120
1121
1122 /** @endcond */
1123
1124
1125 /** @cond doxygenLibsbmlInternal */
1126
1127 /*
1128 * Connects to child elements.
1129 */
1130 void
connectToChild()1131 MultiSpeciesType::connectToChild()
1132 {
1133 mListOfSpeciesFeatureTypes.connectToParent(this);
1134 mListOfSpeciesTypeInstances.connectToParent(this);
1135 mListOfSpeciesTypeComponentIndexes.connectToParent(this);
1136 mListOfInSpeciesTypeBonds.connectToParent(this);
1137 }
1138
1139
1140 /** @endcond */
1141
1142
1143 /** @cond doxygenLibsbmlInternal */
1144
1145 /*
1146 * Enables/Disables the given package with this element.
1147 */
1148 void
enablePackageInternal(const std::string & pkgURI,const std::string & pkgPrefix,bool flag)1149 MultiSpeciesType::enablePackageInternal(const std::string& pkgURI,
1150 const std::string& pkgPrefix, bool flag)
1151 {
1152 SBase::enablePackageInternal(pkgURI, pkgPrefix, flag);
1153 mListOfSpeciesFeatureTypes.enablePackageInternal(pkgURI, pkgPrefix, flag);
1154 mListOfSpeciesTypeInstances.enablePackageInternal(pkgURI, pkgPrefix, flag);
1155 mListOfSpeciesTypeComponentIndexes.enablePackageInternal(pkgURI, pkgPrefix, flag);
1156 mListOfInSpeciesTypeBonds.enablePackageInternal(pkgURI, pkgPrefix, flag);
1157 }
1158
1159
1160 /** @endcond */
1161
1162
1163 /** @cond doxygenLibsbmlInternal */
1164
1165 /*
1166 * creates object.
1167 */
1168 SBase*
createObject(XMLInputStream & stream)1169 MultiSpeciesType::createObject(XMLInputStream& stream)
1170 {
1171 SBase* object = NULL;
1172
1173 const std::string& name = stream.peek().getName();
1174 const XMLNamespaces& xmlns = stream.peek().getNamespaces();
1175 std::string prefix(stream.peek().getPrefix());
1176
1177 const std::string& targetPrefix =
1178 (xmlns.hasURI(mURI)) ? xmlns.getPrefix(mURI) : getPrefix();
1179
1180 if (prefix == targetPrefix)
1181 {
1182 MULTI_CREATE_NS(multins, getSBMLNamespaces());
1183 if (!targetPrefix.empty()) {
1184 prefix += ":";
1185 }
1186
1187 if (name == "listOfSpeciesFeatureTypes")
1188 {
1189 if (mListOfSpeciesFeatureTypes.size() > 0)
1190 {
1191 getErrorLog()->logPackageError("multi", MultiLofSpeFtrTyps_onlyOne,
1192 getPackageVersion(), getLevel(), getVersion(),
1193 "<" + prefix + "speciesType> may only have one <" + prefix
1194 + "listOfSpeciesFeatureTypes>",
1195 stream.peek().getLine(),
1196 stream.peek().getColumn());
1197 }
1198 else {
1199 object = &mListOfSpeciesFeatureTypes;
1200
1201 if (targetPrefix.empty() == true)
1202 {
1203 mListOfSpeciesFeatureTypes.getSBMLDocument()->enableDefaultNS(mURI,
1204 true);
1205 }
1206 }
1207 }
1208 else if (name == "listOfSpeciesTypeInstances")
1209 {
1210 if (mListOfSpeciesTypeInstances.size() > 0)
1211 {
1212 getErrorLog()->logPackageError("multi", MultiLofSptInss_onlyOne,
1213 getPackageVersion(), getLevel(), getVersion(),
1214 "<" + prefix + "speciesType> may only have one <" + prefix
1215 + "listOfSpeciesTypeInstances>",
1216 stream.peek().getLine(),
1217 stream.peek().getColumn());
1218 }
1219 else {
1220 object = &mListOfSpeciesTypeInstances;
1221
1222 if (targetPrefix.empty() == true)
1223 {
1224 mListOfSpeciesTypeInstances.getSBMLDocument()->enableDefaultNS(mURI,
1225 true);
1226 }
1227 }
1228 }
1229 else if (name == "listOfSpeciesTypeComponentIndexes")
1230 {
1231 if (mListOfSpeciesTypeComponentIndexes.size() > 0)
1232 {
1233 getErrorLog()->logPackageError("multi", MultiLofSptCpoInds_onlyOne,
1234 getPackageVersion(), getLevel(), getVersion(),
1235 "<" + prefix + "speciesType> may only have one <" + prefix
1236 + "listOfSpeciesTypeComponentIndexes>",
1237 stream.peek().getLine(),
1238 stream.peek().getColumn());
1239 }
1240 else {
1241 object = &mListOfSpeciesTypeComponentIndexes;
1242
1243 if (targetPrefix.empty() == true)
1244 {
1245 mListOfSpeciesTypeComponentIndexes.getSBMLDocument()->enableDefaultNS(mURI,
1246 true);
1247 }
1248 }
1249 }
1250 else if (name == "listOfInSpeciesTypeBonds")
1251 {
1252 if (mListOfInSpeciesTypeBonds.size() > 0)
1253 {
1254 getErrorLog()->logPackageError("multi", MultiLofInSptBnds_onlyOne,
1255 getPackageVersion(), getLevel(), getVersion(),
1256 "<" + prefix + "speciesType> may only have one <" + prefix
1257 + "listOfInSpeciesTypeBonds>",
1258 stream.peek().getLine(),
1259 stream.peek().getColumn());
1260 }
1261 else {
1262 object = &mListOfInSpeciesTypeBonds;
1263
1264 if (targetPrefix.empty() == true)
1265 {
1266 mListOfInSpeciesTypeBonds.getSBMLDocument()->enableDefaultNS(mURI,
1267 true);
1268 }
1269 }
1270 object = &mListOfInSpeciesTypeBonds;
1271 }
1272
1273 delete multins;
1274 }
1275
1276 return object;
1277 }
1278
1279
1280 /** @endcond */
1281
1282
1283 /** @cond doxygenLibsbmlInternal */
1284
1285 /*
1286 * Get the list of expected attributes for this element.
1287 */
1288 void
addExpectedAttributes(ExpectedAttributes & attributes)1289 MultiSpeciesType::addExpectedAttributes(ExpectedAttributes& attributes)
1290 {
1291 SBase::addExpectedAttributes(attributes);
1292
1293 attributes.add("id");
1294 attributes.add("name");
1295 attributes.add("compartment");
1296 }
1297
1298
1299 /** @endcond */
1300
1301
1302 /** @cond doxygenLibsbmlInternal */
1303
1304 /*
1305 * Read values from the given XMLAttributes set into their specific fields.
1306 */
1307 void
readAttributes(const XMLAttributes & attributes,const ExpectedAttributes & expectedAttributes)1308 MultiSpeciesType::readAttributes (const XMLAttributes& attributes,
1309 const ExpectedAttributes& expectedAttributes)
1310 {
1311 const unsigned int sbmlLevel = getLevel ();
1312 const unsigned int sbmlVersion = getVersion();
1313
1314 unsigned int numErrs;
1315
1316 /* look to see whether an unknown attribute error was logged
1317 * during the read of the listOfMultiSpeciesTypes - which will have
1318 * happened immediately prior to this read
1319 */
1320
1321 if (getErrorLog() != NULL &&
1322 static_cast<ListOfMultiSpeciesTypes*>(getParentSBMLObject())->size() < 2)
1323 {
1324 numErrs = getErrorLog()->getNumErrors();
1325 for (int n = numErrs-1; n >= 0; n--)
1326 {
1327 if (getErrorLog()->getError(n)->getErrorId() == UnknownPackageAttribute)
1328 {
1329 const std::string details =
1330 getErrorLog()->getError(n)->getMessage();
1331 getErrorLog()->remove(UnknownPackageAttribute);
1332 getErrorLog()->logPackageError("multi", MultiLofStps_AllowedAtts,
1333 getPackageVersion(), sbmlLevel, sbmlVersion, details,
1334 getLine(), getColumn());
1335 }
1336 else if (getErrorLog()->getError(n)->getErrorId() == UnknownCoreAttribute)
1337 {
1338 const std::string details =
1339 getErrorLog()->getError(n)->getMessage();
1340 getErrorLog()->remove(UnknownCoreAttribute);
1341 getErrorLog()->logPackageError("multi", MultiLofStps_AllowedAtts,
1342 getPackageVersion(), sbmlLevel, sbmlVersion, details,
1343 getLine(), getColumn());
1344 }
1345 }
1346 }
1347
1348 SBase::readAttributes(attributes, expectedAttributes);
1349
1350 // look to see whether an unknown attribute error was logged
1351 if (getErrorLog() != NULL)
1352 {
1353 numErrs = getErrorLog()->getNumErrors();
1354 for (int n = numErrs-1; n >= 0; n--)
1355 {
1356 if (getErrorLog()->getError(n)->getErrorId() == UnknownPackageAttribute)
1357 {
1358 const std::string details =
1359 getErrorLog()->getError(n)->getMessage();
1360 getErrorLog()->remove(UnknownPackageAttribute);
1361 getErrorLog()->logPackageError("multi", MultiSpt_AllowedMultiAtts,
1362 getPackageVersion(), sbmlLevel, sbmlVersion, details,
1363 getLine(), getColumn());
1364 }
1365 else if (getErrorLog()->getError(n)->getErrorId() == UnknownCoreAttribute)
1366 {
1367 const std::string details =
1368 getErrorLog()->getError(n)->getMessage();
1369 getErrorLog()->remove(UnknownCoreAttribute);
1370 getErrorLog()->logPackageError("multi", MultiSpt_AllowedCoreAtts,
1371 getPackageVersion(), sbmlLevel, sbmlVersion, details,
1372 getLine(), getColumn());
1373 }
1374 }
1375 }
1376
1377 bool assigned = false;
1378
1379 //
1380 // id SId ( use = "required" )
1381 //
1382 assigned = attributes.readInto("id", mId);
1383
1384 if (assigned == true)
1385 {
1386 // check string is not empty and correct syntax
1387
1388 if (mId.empty() == true)
1389 {
1390 logEmptyString(mId, getLevel(), getVersion(), "<MultiSpeciesType>");
1391 }
1392 else if (SyntaxChecker::isValidSBMLSId(mId) == false && getErrorLog() != NULL)
1393 {
1394 std::string details = "The syntax of the attribute id='" + mId + "' does not conform.";
1395 getErrorLog()->logPackageError("multi", MultiInvSIdSyn,
1396 getPackageVersion(), sbmlLevel, sbmlVersion, details,
1397 getLine(), getColumn());
1398 }
1399 }
1400 else
1401 {
1402 std::string message = "Multi attribute 'id' is missing.";
1403 getErrorLog()->logPackageError("multi", MultiSpt_AllowedMultiAtts,
1404 getPackageVersion(), sbmlLevel, sbmlVersion, message, getLine(), getColumn());
1405 }
1406
1407 //
1408 // name string ( use = "optional" )
1409 //
1410 assigned = attributes.readInto("name", mName);
1411
1412 if (assigned == true)
1413 {
1414 // check string is not empty
1415
1416 if (mName.empty() == true)
1417 {
1418 logEmptyString(mName, getLevel(), getVersion(), "<MultiSpeciesType>");
1419 }
1420 }
1421
1422 //
1423 // compartment SIdRef ( use = "optional" )
1424 //
1425 assigned = attributes.readInto("compartment", mCompartment);
1426
1427 if (assigned == true)
1428 {
1429 // check string is not empty and correct syntax
1430
1431 if (mCompartment.empty() == true)
1432 {
1433 logEmptyString(mCompartment, getLevel(), getVersion(), "<MultiSpeciesType>");
1434 }
1435 else if (SyntaxChecker::isValidSBMLSId(mCompartment) == false && getErrorLog() != NULL)
1436 {
1437 std::string details = "The syntax of the attribute compartment='" + mCompartment + "' does not conform.";
1438 getErrorLog()->logPackageError("multi", MultiInvSIdSyn,
1439 getPackageVersion(), sbmlLevel, sbmlVersion, details,
1440 getLine(), getColumn());
1441
1442 }
1443 }
1444
1445 }
1446
1447
1448 /** @endcond */
1449
1450
1451 /** @cond doxygenLibsbmlInternal */
1452
1453 /*
1454 * Write values of XMLAttributes to the output stream.
1455 */
1456 void
writeAttributes(XMLOutputStream & stream) const1457 MultiSpeciesType::writeAttributes (XMLOutputStream& stream) const
1458 {
1459 SBase::writeAttributes(stream);
1460
1461 if (isSetId() == true)
1462 stream.writeAttribute("id", getPrefix(), mId);
1463
1464 if (isSetName() == true)
1465 stream.writeAttribute("name", getPrefix(), mName);
1466
1467
1468 if (isSetCompartment() == true)
1469 stream.writeAttribute("compartment", getPrefix(), mCompartment);
1470
1471 SBase::writeExtensionAttributes(stream);
1472
1473 }
1474
1475
1476 /** @endcond */
1477
1478
1479 /*
1480 * Constructor
1481 */
ListOfMultiSpeciesTypes(unsigned int level,unsigned int version,unsigned int pkgVersion)1482 ListOfMultiSpeciesTypes::ListOfMultiSpeciesTypes(unsigned int level,
1483 unsigned int version,
1484 unsigned int pkgVersion)
1485 : ListOf(level, version)
1486 {
1487 setSBMLNamespacesAndOwn(new MultiPkgNamespaces(level, version, pkgVersion));
1488 }
1489
1490
1491 /*
1492 * Constructor
1493 */
ListOfMultiSpeciesTypes(MultiPkgNamespaces * multins)1494 ListOfMultiSpeciesTypes::ListOfMultiSpeciesTypes(MultiPkgNamespaces* multins)
1495 : ListOf(multins)
1496 {
1497 setElementNamespace(multins->getURI());
1498 }
1499
1500
1501 /*
1502 * Returns a deep copy of this ListOfMultiSpeciesTypes
1503 */
1504 ListOfMultiSpeciesTypes*
clone() const1505 ListOfMultiSpeciesTypes::clone () const
1506 {
1507 return new ListOfMultiSpeciesTypes(*this);
1508 }
1509
1510
1511 /*
1512 * Get a MultiSpeciesType from the ListOfMultiSpeciesTypes by index.
1513 */
1514 MultiSpeciesType*
get(unsigned int n)1515 ListOfMultiSpeciesTypes::get(unsigned int n)
1516 {
1517 return static_cast<MultiSpeciesType*>(ListOf::get(n));
1518 }
1519
1520
1521 /*
1522 * Get a MultiSpeciesType from the ListOfMultiSpeciesTypes by index.
1523 */
1524 const MultiSpeciesType*
get(unsigned int n) const1525 ListOfMultiSpeciesTypes::get(unsigned int n) const
1526 {
1527 return static_cast<const MultiSpeciesType*>(ListOf::get(n));
1528 }
1529
1530
1531 /*
1532 * Get a MultiSpeciesType from the ListOfMultiSpeciesTypes by id.
1533 */
1534 MultiSpeciesType*
get(const std::string & sid)1535 ListOfMultiSpeciesTypes::get(const std::string& sid)
1536 {
1537 return const_cast<MultiSpeciesType*>(
1538 static_cast<const ListOfMultiSpeciesTypes&>(*this).get(sid));
1539 }
1540
1541
1542 /*
1543 * Get a MultiSpeciesType from the ListOfMultiSpeciesTypes by id.
1544 */
1545 const MultiSpeciesType*
get(const std::string & sid) const1546 ListOfMultiSpeciesTypes::get(const std::string& sid) const
1547 {
1548 vector<SBase*>::const_iterator result;
1549
1550 result = find_if( mItems.begin(), mItems.end(), IdEq<MultiSpeciesType>(sid) );
1551 return (result == mItems.end()) ? 0 : static_cast <MultiSpeciesType*> (*result);
1552 }
1553
1554
1555 /*
1556 * Removes the nth MultiSpeciesType from this ListOfMultiSpeciesTypes
1557 */
1558 MultiSpeciesType*
remove(unsigned int n)1559 ListOfMultiSpeciesTypes::remove(unsigned int n)
1560 {
1561 return static_cast<MultiSpeciesType*>(ListOf::remove(n));
1562 }
1563
1564
1565 /*
1566 * Removes the MultiSpeciesType from this ListOfMultiSpeciesTypes with the given identifier
1567 */
1568 MultiSpeciesType*
remove(const std::string & sid)1569 ListOfMultiSpeciesTypes::remove(const std::string& sid)
1570 {
1571 SBase* item = NULL;
1572 vector<SBase*>::iterator result;
1573
1574 result = find_if( mItems.begin(), mItems.end(), IdEq<MultiSpeciesType>(sid) );
1575
1576 if (result != mItems.end())
1577 {
1578 item = *result;
1579 mItems.erase(result);
1580 }
1581
1582 return static_cast <MultiSpeciesType*> (item);
1583 }
1584
1585
1586 /*
1587 * Returns the XML element name of this object
1588 */
1589 const std::string&
getElementName() const1590 ListOfMultiSpeciesTypes::getElementName () const
1591 {
1592 static const string name = "listOfSpeciesTypes";
1593 return name;
1594 }
1595
1596
1597 /*
1598 * Returns the libSBML type code for this SBML object.
1599 */
1600 int
getTypeCode() const1601 ListOfMultiSpeciesTypes::getTypeCode () const
1602 {
1603 return SBML_LIST_OF;
1604 }
1605
1606
1607 /*
1608 * Returns the libSBML type code for the objects in this LIST_OF.
1609 */
1610 int
getItemTypeCode() const1611 ListOfMultiSpeciesTypes::getItemTypeCode () const
1612 {
1613 return SBML_MULTI_SPECIES_TYPE;
1614 }
1615
1616
1617 /** @cond doxygenLibsbmlInternal */
1618
1619 /*
1620 * Creates a new MultiSpeciesType in this ListOfMultiSpeciesTypes
1621 */
1622 SBase*
createObject(XMLInputStream & stream)1623 ListOfMultiSpeciesTypes::createObject(XMLInputStream& stream)
1624 {
1625 const std::string& name = stream.peek().getName();
1626 SBase* object = NULL;
1627
1628 if (name == "speciesType")
1629 {
1630 MULTI_CREATE_NS(multins, getSBMLNamespaces());
1631 object = new MultiSpeciesType(multins);
1632 appendAndOwn(object);
1633 delete multins;
1634 }
1635 else if (name == "bindingSiteSpeciesType")
1636 {
1637 MULTI_CREATE_NS(multins, getSBMLNamespaces());
1638 object = new BindingSiteSpeciesType(multins);
1639 appendAndOwn(object);
1640 delete multins;
1641 }
1642
1643 return object;
1644 }
1645
1646
1647 /** @endcond */
1648
1649
1650 /** @cond doxygenLibsbmlInternal */
1651
1652 /*
1653 * Write the namespace for the Multi package.
1654 */
1655 void
writeXMLNS(XMLOutputStream & stream) const1656 ListOfMultiSpeciesTypes::writeXMLNS(XMLOutputStream& stream) const
1657 {
1658 XMLNamespaces xmlns;
1659
1660 std::string prefix = getPrefix();
1661
1662 if (prefix.empty())
1663 {
1664 XMLNamespaces* thisxmlns = getNamespaces();
1665 if (thisxmlns && thisxmlns->hasURI(MultiExtension::getXmlnsL3V1V1()))
1666 {
1667 xmlns.add(MultiExtension::getXmlnsL3V1V1(),prefix);
1668 }
1669 }
1670
1671 stream << xmlns;
1672 }
1673
1674 /*
1675 * Return true only when the item is an object of MultiSpeciesType or
1676 * BindingSiteSpeciesType
1677 */
1678 bool
isValidTypeForList(SBase * item)1679 ListOfMultiSpeciesTypes::isValidTypeForList(SBase * item)
1680 {
1681 return item->getTypeCode() == SBML_MULTI_SPECIES_TYPE ||
1682 item->getTypeCode() == SBML_MULTI_BINDING_SITE_SPECIES_TYPE;
1683 }
1684
1685
1686
1687 /** @endcond */
1688
1689
1690 LIBSBML_EXTERN
1691 MultiSpeciesType_t *
MultiSpeciesType_create(unsigned int level,unsigned int version,unsigned int pkgVersion)1692 MultiSpeciesType_create(unsigned int level, unsigned int version,
1693 unsigned int pkgVersion)
1694 {
1695 return new MultiSpeciesType(level, version, pkgVersion);
1696 }
1697
1698
1699 LIBSBML_EXTERN
1700 void
MultiSpeciesType_free(MultiSpeciesType_t * mst)1701 MultiSpeciesType_free(MultiSpeciesType_t * mst)
1702 {
1703 if (mst != NULL)
1704 delete mst;
1705 }
1706
1707
1708 LIBSBML_EXTERN
1709 MultiSpeciesType_t *
MultiSpeciesType_clone(MultiSpeciesType_t * mst)1710 MultiSpeciesType_clone(MultiSpeciesType_t * mst)
1711 {
1712 if (mst != NULL)
1713 {
1714 return static_cast<MultiSpeciesType_t*>(mst->clone());
1715 }
1716 else
1717 {
1718 return NULL;
1719 }
1720 }
1721
1722
1723 LIBSBML_EXTERN
1724 char *
MultiSpeciesType_getId(MultiSpeciesType_t * mst)1725 MultiSpeciesType_getId(MultiSpeciesType_t * mst)
1726 {
1727 if (mst == NULL)
1728 return NULL;
1729
1730 return mst->getId().empty() ? NULL : safe_strdup(mst->getId().c_str());
1731 }
1732
1733
1734 LIBSBML_EXTERN
1735 char *
MultiSpeciesType_getName(MultiSpeciesType_t * mst)1736 MultiSpeciesType_getName(MultiSpeciesType_t * mst)
1737 {
1738 if (mst == NULL)
1739 return NULL;
1740
1741 return mst->getName().empty() ? NULL : safe_strdup(mst->getName().c_str());
1742 }
1743
1744
1745
1746
1747 LIBSBML_EXTERN
1748 char *
MultiSpeciesType_getCompartment(MultiSpeciesType_t * mst)1749 MultiSpeciesType_getCompartment(MultiSpeciesType_t * mst)
1750 {
1751 if (mst == NULL)
1752 return NULL;
1753
1754 return mst->getCompartment().empty() ? NULL : safe_strdup(mst->getCompartment().c_str());
1755 }
1756
1757
1758 LIBSBML_EXTERN
1759 int
MultiSpeciesType_isSetId(MultiSpeciesType_t * mst)1760 MultiSpeciesType_isSetId(MultiSpeciesType_t * mst)
1761 {
1762 return (mst != NULL) ? static_cast<int>(mst->isSetId()) : 0;
1763 }
1764
1765
1766 LIBSBML_EXTERN
1767 int
MultiSpeciesType_isSetName(MultiSpeciesType_t * mst)1768 MultiSpeciesType_isSetName(MultiSpeciesType_t * mst)
1769 {
1770 return (mst != NULL) ? static_cast<int>(mst->isSetName()) : 0;
1771 }
1772
1773
1774
1775
1776 LIBSBML_EXTERN
1777 int
MultiSpeciesType_isSetCompartment(MultiSpeciesType_t * mst)1778 MultiSpeciesType_isSetCompartment(MultiSpeciesType_t * mst)
1779 {
1780 return (mst != NULL) ? static_cast<int>(mst->isSetCompartment()) : 0;
1781 }
1782
1783
1784 LIBSBML_EXTERN
1785 int
MultiSpeciesType_setId(MultiSpeciesType_t * mst,const char * id)1786 MultiSpeciesType_setId(MultiSpeciesType_t * mst, const char * id)
1787 {
1788 return (mst != NULL) ? mst->setId(id) : LIBSBML_INVALID_OBJECT;
1789 }
1790
1791
1792 LIBSBML_EXTERN
1793 int
MultiSpeciesType_setName(MultiSpeciesType_t * mst,const char * name)1794 MultiSpeciesType_setName(MultiSpeciesType_t * mst, const char * name)
1795 {
1796 return (mst != NULL) ? mst->setName(name) : LIBSBML_INVALID_OBJECT;
1797 }
1798
1799
1800
1801
1802 LIBSBML_EXTERN
1803 int
MultiSpeciesType_setCompartment(MultiSpeciesType_t * mst,const char * compartment)1804 MultiSpeciesType_setCompartment(MultiSpeciesType_t * mst, const char * compartment)
1805 {
1806 return (mst != NULL) ? mst->setCompartment(compartment) : LIBSBML_INVALID_OBJECT;
1807 }
1808
1809
1810 LIBSBML_EXTERN
1811 int
MultiSpeciesType_unsetId(MultiSpeciesType_t * mst)1812 MultiSpeciesType_unsetId(MultiSpeciesType_t * mst)
1813 {
1814 return (mst != NULL) ? mst->unsetId() : LIBSBML_INVALID_OBJECT;
1815 }
1816
1817
1818 LIBSBML_EXTERN
1819 int
MultiSpeciesType_unsetName(MultiSpeciesType_t * mst)1820 MultiSpeciesType_unsetName(MultiSpeciesType_t * mst)
1821 {
1822 return (mst != NULL) ? mst->unsetName() : LIBSBML_INVALID_OBJECT;
1823 }
1824
1825
1826
1827
1828 LIBSBML_EXTERN
1829 int
MultiSpeciesType_unsetCompartment(MultiSpeciesType_t * mst)1830 MultiSpeciesType_unsetCompartment(MultiSpeciesType_t * mst)
1831 {
1832 return (mst != NULL) ? mst->unsetCompartment() : LIBSBML_INVALID_OBJECT;
1833 }
1834
1835
1836 /*
1837 * Returns a ListOf_t * containing SpeciesFeatureType_t objects from this
1838 * MultiSpeciesType_t.
1839 */
1840 LIBSBML_EXTERN
1841 ListOf_t*
MultiSpeciesType_getListOfSpeciesFeatureTypes(MultiSpeciesType_t * mst)1842 MultiSpeciesType_getListOfSpeciesFeatureTypes(MultiSpeciesType_t* mst)
1843 {
1844 return (mst != NULL) ? mst->getListOfSpeciesFeatureTypes() : NULL;
1845 }
1846
1847
1848 /*
1849 * Get a SpeciesFeatureType_t from the MultiSpeciesType_t.
1850 */
1851 LIBSBML_EXTERN
1852 SpeciesFeatureType_t*
MultiSpeciesType_getSpeciesFeatureType(MultiSpeciesType_t * mst,unsigned int n)1853 MultiSpeciesType_getSpeciesFeatureType(MultiSpeciesType_t* mst,
1854 unsigned int n)
1855 {
1856 return (mst != NULL) ? mst->getSpeciesFeatureType(n) : NULL;
1857 }
1858
1859
1860 /*
1861 * Get a SpeciesFeatureType_t from the MultiSpeciesType_t based on its
1862 * identifier.
1863 */
1864 LIBSBML_EXTERN
1865 SpeciesFeatureType_t*
MultiSpeciesType_getSpeciesFeatureTypeById(MultiSpeciesType_t * mst,const char * sid)1866 MultiSpeciesType_getSpeciesFeatureTypeById(MultiSpeciesType_t* mst,
1867 const char *sid)
1868 {
1869 return (mst != NULL && sid != NULL) ? mst->getSpeciesFeatureType(sid) : NULL;
1870 }
1871
1872
1873 /*
1874 * Adds a copy of the given SpeciesFeatureType_t to this MultiSpeciesType_t.
1875 */
1876 LIBSBML_EXTERN
1877 int
MultiSpeciesType_addSpeciesFeatureType(MultiSpeciesType_t * mst,const SpeciesFeatureType_t * sft)1878 MultiSpeciesType_addSpeciesFeatureType(MultiSpeciesType_t* mst,
1879 const SpeciesFeatureType_t* sft)
1880 {
1881 return (mst != NULL) ? mst->addSpeciesFeatureType(sft) :
1882 LIBSBML_INVALID_OBJECT;
1883 }
1884
1885
1886 /*
1887 * Get the number of SpeciesFeatureType_t objects in this MultiSpeciesType_t.
1888 */
1889 LIBSBML_EXTERN
1890 unsigned int
MultiSpeciesType_getNumSpeciesFeatureTypes(MultiSpeciesType_t * mst)1891 MultiSpeciesType_getNumSpeciesFeatureTypes(MultiSpeciesType_t* mst)
1892 {
1893 return (mst != NULL) ? mst->getNumSpeciesFeatureTypes() : SBML_INT_MAX;
1894 }
1895
1896
1897 /*
1898 * Creates a new SpeciesFeatureType_t object, adds it to this
1899 * MultiSpeciesType_t object and returns the SpeciesFeatureType_t object
1900 * created.
1901 */
1902 LIBSBML_EXTERN
1903 SpeciesFeatureType_t*
MultiSpeciesType_createSpeciesFeatureType(MultiSpeciesType_t * mst)1904 MultiSpeciesType_createSpeciesFeatureType(MultiSpeciesType_t* mst)
1905 {
1906 return (mst != NULL) ? mst->createSpeciesFeatureType() : NULL;
1907 }
1908
1909
1910 /*
1911 * Removes the nth SpeciesFeatureType_t from this MultiSpeciesType_t and
1912 * returns a pointer to it.
1913 */
1914 LIBSBML_EXTERN
1915 SpeciesFeatureType_t*
MultiSpeciesType_removeSpeciesFeatureType(MultiSpeciesType_t * mst,unsigned int n)1916 MultiSpeciesType_removeSpeciesFeatureType(MultiSpeciesType_t* mst,
1917 unsigned int n)
1918 {
1919 return (mst != NULL) ? mst->removeSpeciesFeatureType(n) : NULL;
1920 }
1921
1922
1923 /*
1924 * Removes the SpeciesFeatureType_t from this MultiSpeciesType_t based on its
1925 * identifier and returns a pointer to it.
1926 */
1927 LIBSBML_EXTERN
1928 SpeciesFeatureType_t*
MultiSpeciesType_removeSpeciesFeatureTypeById(MultiSpeciesType_t * mst,const char * sid)1929 MultiSpeciesType_removeSpeciesFeatureTypeById(MultiSpeciesType_t* mst,
1930 const char* sid)
1931 {
1932 return (mst != NULL && sid != NULL) ? mst->removeSpeciesFeatureType(sid) :
1933 NULL;
1934 }
1935
1936
1937 /*
1938 * Returns a ListOf_t * containing SpeciesTypeInstance_t objects from this
1939 * MultiSpeciesType_t.
1940 */
1941 LIBSBML_EXTERN
1942 ListOf_t*
MultiSpeciesType_getListOfSpeciesTypeInstances(MultiSpeciesType_t * mst)1943 MultiSpeciesType_getListOfSpeciesTypeInstances(MultiSpeciesType_t* mst)
1944 {
1945 return (mst != NULL) ? mst->getListOfSpeciesTypeInstances() : NULL;
1946 }
1947
1948
1949 /*
1950 * Get a SpeciesTypeInstance_t from the MultiSpeciesType_t.
1951 */
1952 LIBSBML_EXTERN
1953 SpeciesTypeInstance_t*
MultiSpeciesType_getSpeciesTypeInstance(MultiSpeciesType_t * mst,unsigned int n)1954 MultiSpeciesType_getSpeciesTypeInstance(MultiSpeciesType_t* mst,
1955 unsigned int n)
1956 {
1957 return (mst != NULL) ? mst->getSpeciesTypeInstance(n) : NULL;
1958 }
1959
1960
1961 /*
1962 * Get a SpeciesTypeInstance_t from the MultiSpeciesType_t based on its
1963 * identifier.
1964 */
1965 LIBSBML_EXTERN
1966 SpeciesTypeInstance_t*
MultiSpeciesType_getSpeciesTypeInstanceById(MultiSpeciesType_t * mst,const char * sid)1967 MultiSpeciesType_getSpeciesTypeInstanceById(MultiSpeciesType_t* mst,
1968 const char *sid)
1969 {
1970 return (mst != NULL && sid != NULL) ? mst->getSpeciesTypeInstance(sid) :
1971 NULL;
1972 }
1973
1974
1975 /*
1976 * Adds a copy of the given SpeciesTypeInstance_t to this MultiSpeciesType_t.
1977 */
1978 LIBSBML_EXTERN
1979 int
MultiSpeciesType_addSpeciesTypeInstance(MultiSpeciesType_t * mst,const SpeciesTypeInstance_t * sti)1980 MultiSpeciesType_addSpeciesTypeInstance(MultiSpeciesType_t* mst,
1981 const SpeciesTypeInstance_t* sti)
1982 {
1983 return (mst != NULL) ? mst->addSpeciesTypeInstance(sti) :
1984 LIBSBML_INVALID_OBJECT;
1985 }
1986
1987
1988 /*
1989 * Get the number of SpeciesTypeInstance_t objects in this MultiSpeciesType_t.
1990 */
1991 LIBSBML_EXTERN
1992 unsigned int
MultiSpeciesType_getNumSpeciesTypeInstances(MultiSpeciesType_t * mst)1993 MultiSpeciesType_getNumSpeciesTypeInstances(MultiSpeciesType_t* mst)
1994 {
1995 return (mst != NULL) ? mst->getNumSpeciesTypeInstances() : SBML_INT_MAX;
1996 }
1997
1998
1999 /*
2000 * Creates a new SpeciesTypeInstance_t object, adds it to this
2001 * MultiSpeciesType_t object and returns the SpeciesTypeInstance_t object
2002 * created.
2003 */
2004 LIBSBML_EXTERN
2005 SpeciesTypeInstance_t*
MultiSpeciesType_createSpeciesTypeInstance(MultiSpeciesType_t * mst)2006 MultiSpeciesType_createSpeciesTypeInstance(MultiSpeciesType_t* mst)
2007 {
2008 return (mst != NULL) ? mst->createSpeciesTypeInstance() : NULL;
2009 }
2010
2011
2012 /*
2013 * Removes the nth SpeciesTypeInstance_t from this MultiSpeciesType_t and
2014 * returns a pointer to it.
2015 */
2016 LIBSBML_EXTERN
2017 SpeciesTypeInstance_t*
MultiSpeciesType_removeSpeciesTypeInstance(MultiSpeciesType_t * mst,unsigned int n)2018 MultiSpeciesType_removeSpeciesTypeInstance(MultiSpeciesType_t* mst,
2019 unsigned int n)
2020 {
2021 return (mst != NULL) ? mst->removeSpeciesTypeInstance(n) : NULL;
2022 }
2023
2024
2025 /*
2026 * Removes the SpeciesTypeInstance_t from this MultiSpeciesType_t based on its
2027 * identifier and returns a pointer to it.
2028 */
2029 LIBSBML_EXTERN
2030 SpeciesTypeInstance_t*
MultiSpeciesType_removeSpeciesTypeInstanceById(MultiSpeciesType_t * mst,const char * sid)2031 MultiSpeciesType_removeSpeciesTypeInstanceById(MultiSpeciesType_t* mst,
2032 const char* sid)
2033 {
2034 return (mst != NULL && sid != NULL) ? mst->removeSpeciesTypeInstance(sid) :
2035 NULL;
2036 }
2037
2038
2039 /*
2040 * Returns a ListOf_t * containing SpeciesTypeComponentIndex_t objects from
2041 * this MultiSpeciesType_t.
2042 */
2043 LIBSBML_EXTERN
2044 ListOf_t*
MultiSpeciesType_getListOfSpeciesTypeComponentIndexes(MultiSpeciesType_t * mst)2045 MultiSpeciesType_getListOfSpeciesTypeComponentIndexes(MultiSpeciesType_t* mst)
2046 {
2047 return (mst != NULL) ? mst->getListOfSpeciesTypeComponentIndexes() : NULL;
2048 }
2049
2050
2051 /*
2052 * Get a SpeciesTypeComponentIndex_t from the MultiSpeciesType_t.
2053 */
2054 LIBSBML_EXTERN
2055 SpeciesTypeComponentIndex_t*
MultiSpeciesType_getSpeciesTypeComponentIndex(MultiSpeciesType_t * mst,unsigned int n)2056 MultiSpeciesType_getSpeciesTypeComponentIndex(MultiSpeciesType_t* mst,
2057 unsigned int n)
2058 {
2059 return (mst != NULL) ? mst->getSpeciesTypeComponentIndex(n) : NULL;
2060 }
2061
2062
2063 /*
2064 * Get a SpeciesTypeComponentIndex_t from the MultiSpeciesType_t based on its
2065 * identifier.
2066 */
2067 LIBSBML_EXTERN
2068 SpeciesTypeComponentIndex_t*
MultiSpeciesType_getSpeciesTypeComponentIndexById(MultiSpeciesType_t * mst,const char * sid)2069 MultiSpeciesType_getSpeciesTypeComponentIndexById(MultiSpeciesType_t* mst,
2070 const char *sid)
2071 {
2072 return (mst != NULL && sid != NULL) ? mst->getSpeciesTypeComponentIndex(sid)
2073 : NULL;
2074 }
2075
2076
2077 /*
2078 * Adds a copy of the given SpeciesTypeComponentIndex_t to this
2079 * MultiSpeciesType_t.
2080 */
2081 LIBSBML_EXTERN
2082 int
MultiSpeciesType_addSpeciesTypeComponentIndex(MultiSpeciesType_t * mst,const SpeciesTypeComponentIndex_t * stci)2083 MultiSpeciesType_addSpeciesTypeComponentIndex(MultiSpeciesType_t* mst,
2084 const
2085 SpeciesTypeComponentIndex_t*
2086 stci)
2087 {
2088 return (mst != NULL) ? mst->addSpeciesTypeComponentIndex(stci) :
2089 LIBSBML_INVALID_OBJECT;
2090 }
2091
2092
2093 /*
2094 * Get the number of SpeciesTypeComponentIndex_t objects in this
2095 * MultiSpeciesType_t.
2096 */
2097 LIBSBML_EXTERN
2098 unsigned int
MultiSpeciesType_getNumSpeciesTypeComponentIndexes(MultiSpeciesType_t * mst)2099 MultiSpeciesType_getNumSpeciesTypeComponentIndexes(MultiSpeciesType_t* mst)
2100 {
2101 return (mst != NULL) ? mst->getNumSpeciesTypeComponentIndexes() :
2102 SBML_INT_MAX;
2103 }
2104
2105
2106 /*
2107 * Creates a new SpeciesTypeComponentIndex_t object, adds it to this
2108 * MultiSpeciesType_t object and returns the SpeciesTypeComponentIndex_t object
2109 * created.
2110 */
2111 LIBSBML_EXTERN
2112 SpeciesTypeComponentIndex_t*
MultiSpeciesType_createSpeciesTypeComponentIndex(MultiSpeciesType_t * mst)2113 MultiSpeciesType_createSpeciesTypeComponentIndex(MultiSpeciesType_t* mst)
2114 {
2115 return (mst != NULL) ? mst->createSpeciesTypeComponentIndex() : NULL;
2116 }
2117
2118
2119 /*
2120 * Removes the nth SpeciesTypeComponentIndex_t from this MultiSpeciesType_t and
2121 * returns a pointer to it.
2122 */
2123 LIBSBML_EXTERN
2124 SpeciesTypeComponentIndex_t*
MultiSpeciesType_removeSpeciesTypeComponentIndex(MultiSpeciesType_t * mst,unsigned int n)2125 MultiSpeciesType_removeSpeciesTypeComponentIndex(MultiSpeciesType_t* mst,
2126 unsigned int n)
2127 {
2128 return (mst != NULL) ? mst->removeSpeciesTypeComponentIndex(n) : NULL;
2129 }
2130
2131
2132 /*
2133 * Removes the SpeciesTypeComponentIndex_t from this MultiSpeciesType_t based
2134 * on its identifier and returns a pointer to it.
2135 */
2136 LIBSBML_EXTERN
2137 SpeciesTypeComponentIndex_t*
MultiSpeciesType_removeSpeciesTypeComponentIndexById(MultiSpeciesType_t * mst,const char * sid)2138 MultiSpeciesType_removeSpeciesTypeComponentIndexById(MultiSpeciesType_t* mst,
2139 const char* sid)
2140 {
2141 return (mst != NULL && sid != NULL) ?
2142 mst->removeSpeciesTypeComponentIndex(sid) : NULL;
2143 }
2144
2145
2146 /*
2147 * Returns a ListOf_t * containing InSpeciesTypeBond_t objects from this
2148 * MultiSpeciesType_t.
2149 */
2150 LIBSBML_EXTERN
2151 ListOf_t*
MultiSpeciesType_getListOfInSpeciesTypeBonds(MultiSpeciesType_t * mst)2152 MultiSpeciesType_getListOfInSpeciesTypeBonds(MultiSpeciesType_t* mst)
2153 {
2154 return (mst != NULL) ? mst->getListOfInSpeciesTypeBonds() : NULL;
2155 }
2156
2157
2158 /*
2159 * Get an InSpeciesTypeBond_t from the MultiSpeciesType_t.
2160 */
2161 LIBSBML_EXTERN
2162 InSpeciesTypeBond_t*
MultiSpeciesType_getInSpeciesTypeBond(MultiSpeciesType_t * mst,unsigned int n)2163 MultiSpeciesType_getInSpeciesTypeBond(MultiSpeciesType_t* mst, unsigned int n)
2164 {
2165 return (mst != NULL) ? mst->getInSpeciesTypeBond(n) : NULL;
2166 }
2167
2168
2169 /*
2170 * Get an InSpeciesTypeBond_t from the MultiSpeciesType_t based on its
2171 * identifier.
2172 */
2173 LIBSBML_EXTERN
2174 InSpeciesTypeBond_t*
MultiSpeciesType_getInSpeciesTypeBondById(MultiSpeciesType_t * mst,const char * sid)2175 MultiSpeciesType_getInSpeciesTypeBondById(MultiSpeciesType_t* mst,
2176 const char *sid)
2177 {
2178 return (mst != NULL && sid != NULL) ? mst->getInSpeciesTypeBond(sid) : NULL;
2179 }
2180
2181
2182 /*
2183 * Adds a copy of the given InSpeciesTypeBond_t to this MultiSpeciesType_t.
2184 */
2185 LIBSBML_EXTERN
2186 int
MultiSpeciesType_addInSpeciesTypeBond(MultiSpeciesType_t * mst,const InSpeciesTypeBond_t * istb)2187 MultiSpeciesType_addInSpeciesTypeBond(MultiSpeciesType_t* mst,
2188 const InSpeciesTypeBond_t* istb)
2189 {
2190 return (mst != NULL) ? mst->addInSpeciesTypeBond(istb) :
2191 LIBSBML_INVALID_OBJECT;
2192 }
2193
2194
2195 /*
2196 * Get the number of InSpeciesTypeBond_t objects in this MultiSpeciesType_t.
2197 */
2198 LIBSBML_EXTERN
2199 unsigned int
MultiSpeciesType_getNumInSpeciesTypeBonds(MultiSpeciesType_t * mst)2200 MultiSpeciesType_getNumInSpeciesTypeBonds(MultiSpeciesType_t* mst)
2201 {
2202 return (mst != NULL) ? mst->getNumInSpeciesTypeBonds() : SBML_INT_MAX;
2203 }
2204
2205
2206 /*
2207 * Creates a new InSpeciesTypeBond_t object, adds it to this MultiSpeciesType_t
2208 * object and returns the InSpeciesTypeBond_t object created.
2209 */
2210 LIBSBML_EXTERN
2211 InSpeciesTypeBond_t*
MultiSpeciesType_createInSpeciesTypeBond(MultiSpeciesType_t * mst)2212 MultiSpeciesType_createInSpeciesTypeBond(MultiSpeciesType_t* mst)
2213 {
2214 return (mst != NULL) ? mst->createInSpeciesTypeBond() : NULL;
2215 }
2216
2217
2218 /*
2219 * Removes the nth InSpeciesTypeBond_t from this MultiSpeciesType_t and returns
2220 * a pointer to it.
2221 */
2222 LIBSBML_EXTERN
2223 InSpeciesTypeBond_t*
MultiSpeciesType_removeInSpeciesTypeBond(MultiSpeciesType_t * mst,unsigned int n)2224 MultiSpeciesType_removeInSpeciesTypeBond(MultiSpeciesType_t* mst,
2225 unsigned int n)
2226 {
2227 return (mst != NULL) ? mst->removeInSpeciesTypeBond(n) : NULL;
2228 }
2229
2230
2231 /*
2232 * Removes the InSpeciesTypeBond_t from this MultiSpeciesType_t based on its
2233 * identifier and returns a pointer to it.
2234 */
2235 LIBSBML_EXTERN
2236 InSpeciesTypeBond_t*
MultiSpeciesType_removeInSpeciesTypeBondById(MultiSpeciesType_t * mst,const char * sid)2237 MultiSpeciesType_removeInSpeciesTypeBondById(MultiSpeciesType_t* mst,
2238 const char* sid)
2239 {
2240 return (mst != NULL && sid != NULL) ? mst->removeInSpeciesTypeBond(sid) :
2241 NULL;
2242 }
2243
2244
2245 LIBSBML_EXTERN
2246 int
MultiSpeciesType_hasRequiredAttributes(MultiSpeciesType_t * mst)2247 MultiSpeciesType_hasRequiredAttributes(MultiSpeciesType_t * mst)
2248 {
2249 return (mst != NULL) ? static_cast<int>(mst->hasRequiredAttributes()) : 0;
2250 }
2251
2252
2253 LIBSBML_EXTERN
2254 MultiSpeciesType_t *
ListOfMultiSpeciesTypes_getById(ListOf_t * lo,const char * sid)2255 ListOfMultiSpeciesTypes_getById(ListOf_t * lo, const char * sid)
2256 {
2257 if (lo == NULL)
2258 return NULL;
2259
2260 return (sid != NULL) ? static_cast <ListOfMultiSpeciesTypes *>(lo)->get(sid) : NULL;
2261 }
2262
2263
2264 LIBSBML_EXTERN
2265 MultiSpeciesType_t *
ListOfMultiSpeciesTypes_removeById(ListOf_t * lo,const char * sid)2266 ListOfMultiSpeciesTypes_removeById(ListOf_t * lo, const char * sid)
2267 {
2268 if (lo == NULL)
2269 return NULL;
2270
2271 return (sid != NULL) ? static_cast <ListOfMultiSpeciesTypes *>(lo)->remove(sid) : NULL;
2272 }
2273
2274
2275
2276
2277 LIBSBML_CPP_NAMESPACE_END
2278
2279 #endif /*__cplusplus */
2280
2281
2282