1 /** 2 * @file SedSlice.h 3 * @brief Definition of the SedSlice class. 4 * @author DEVISER 5 * 6 * <!-------------------------------------------------------------------------- 7 * This file is part of libSEDML. Please visit http://sed-ml.org for more 8 * information about SED-ML. The latest version of libSEDML can be found on 9 * github: https://github.com/fbergmann/libSEDML/ 10 * 11 12 * Copyright (c) 2013-2019, Frank T. Bergmann 13 * All rights reserved. 14 * 15 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions are met: 18 * 19 20 * 1. Redistributions of source code must retain the above copyright notice, 21 * this 22 * list of conditions and the following disclaimer. 23 * 2. Redistributions in binary form must reproduce the above copyright notice, 24 * this list of conditions and the following disclaimer in the documentation 25 * and/or other materials provided with the distribution. 26 * 27 * This library is free software; you can redistribute it and/or modify it 28 * under the terms of the GNU Lesser General Public License as published by the 29 * Free Software Foundation. A copy of the license agreement is provided in the 30 * file named "LICENSE.txt" included with this software distribution and also 31 * available online as http://sbml.org/software/libsbml/license.html 32 * ------------------------------------------------------------------------ --> 33 * 34 * @class SedSlice 35 * @sbmlbrief{sedml} TODO:Definition of the SedSlice class. 36 */ 37 38 39 #ifndef SedSlice_H__ 40 #define SedSlice_H__ 41 42 43 #include <sedml/common/extern.h> 44 #include <sedml/common/sedmlfwd.h> 45 46 47 #ifdef __cplusplus 48 49 50 #include <string> 51 52 53 #include <sedml/SedBase.h> 54 #include <sbml/common/libsbml-namespace.h> 55 56 57 LIBSEDML_CPP_NAMESPACE_BEGIN 58 59 60 class LIBSEDML_EXTERN SedSlice : public SedBase 61 { 62 protected: 63 64 /** @cond doxygenLibSEDMLInternal */ 65 66 std::string mReference; 67 std::string mValue; 68 std::string mIndex; 69 int mStartIndex; 70 bool mIsSetStartIndex; 71 int mEndIndex; 72 bool mIsSetEndIndex; 73 74 /** @endcond */ 75 76 public: 77 78 /** 79 * Creates a new SedSlice using the given SED-ML Level and @ p version values. 80 * 81 * @param level an unsigned int, the SED-ML Level to assign to this SedSlice. 82 * 83 * @param version an unsigned int, the SED-ML Version to assign to this 84 * SedSlice. 85 * 86 * @copydetails doc_note_setting_lv_pkg 87 */ 88 SedSlice(unsigned int level = SEDML_DEFAULT_LEVEL, 89 unsigned int version = SEDML_DEFAULT_VERSION); 90 91 92 /** 93 * Creates a new SedSlice using the given SedNamespaces object @p sedmlns. 94 * 95 * @param sedmlns the SedNamespaces object. 96 * 97 * @copydetails doc_note_setting_lv_pkg 98 */ 99 SedSlice(SedNamespaces *sedmlns); 100 101 102 /** 103 * Copy constructor for SedSlice. 104 * 105 * @param orig the SedSlice instance to copy. 106 */ 107 SedSlice(const SedSlice& orig); 108 109 110 /** 111 * Assignment operator for SedSlice. 112 * 113 * @param rhs the SedSlice object whose values are to be used as the basis of 114 * the assignment. 115 */ 116 SedSlice& operator=(const SedSlice& rhs); 117 118 119 /** 120 * Creates and returns a deep copy of this SedSlice object. 121 * 122 * @return a (deep) copy of this SedSlice object. 123 */ 124 virtual SedSlice* clone() const; 125 126 127 /** 128 * Destructor for SedSlice. 129 */ 130 virtual ~SedSlice(); 131 132 133 /** 134 * Returns the value of the "reference" attribute of this SedSlice. 135 * 136 * @return the value of the "reference" attribute of this SedSlice as a 137 * string. 138 */ 139 const std::string& getReference() const; 140 141 142 /** 143 * Returns the value of the "value" attribute of this SedSlice. 144 * 145 * @return the value of the "value" attribute of this SedSlice as a string. 146 */ 147 const std::string& getValue() const; 148 149 150 /** 151 * Returns the value of the "index" attribute of this SedSlice. 152 * 153 * @return the value of the "index" attribute of this SedSlice as a string. 154 */ 155 const std::string& getIndex() const; 156 157 158 /** 159 * Returns the value of the "startIndex" attribute of this SedSlice. 160 * 161 * @return the value of the "startIndex" attribute of this SedSlice as a 162 * integer. 163 */ 164 int getStartIndex() const; 165 166 167 /** 168 * Returns the value of the "endIndex" attribute of this SedSlice. 169 * 170 * @return the value of the "endIndex" attribute of this SedSlice as a 171 * integer. 172 */ 173 int getEndIndex() const; 174 175 176 /** 177 * Predicate returning @c true if this SedSlice's "reference" attribute is 178 * set. 179 * 180 * @return @c true if this SedSlice's "reference" attribute has been set, 181 * otherwise @c false is returned. 182 */ 183 bool isSetReference() const; 184 185 186 /** 187 * Predicate returning @c true if this SedSlice's "value" attribute is set. 188 * 189 * @return @c true if this SedSlice's "value" attribute has been set, 190 * otherwise @c false is returned. 191 */ 192 bool isSetValue() const; 193 194 195 /** 196 * Predicate returning @c true if this SedSlice's "index" attribute is set. 197 * 198 * @return @c true if this SedSlice's "index" attribute has been set, 199 * otherwise @c false is returned. 200 */ 201 bool isSetIndex() const; 202 203 204 /** 205 * Predicate returning @c true if this SedSlice's "startIndex" attribute is 206 * set. 207 * 208 * @return @c true if this SedSlice's "startIndex" attribute has been set, 209 * otherwise @c false is returned. 210 */ 211 bool isSetStartIndex() const; 212 213 214 /** 215 * Predicate returning @c true if this SedSlice's "endIndex" attribute is 216 * set. 217 * 218 * @return @c true if this SedSlice's "endIndex" attribute has been set, 219 * otherwise @c false is returned. 220 */ 221 bool isSetEndIndex() const; 222 223 224 /** 225 * Sets the value of the "reference" attribute of this SedSlice. 226 * 227 * @param reference std::string& value of the "reference" attribute to be 228 * set. 229 * 230 * @copydetails doc_returns_success_code 231 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 232 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 233 * OperationReturnValues_t} 234 */ 235 int setReference(const std::string& reference); 236 237 238 /** 239 * Sets the value of the "value" attribute of this SedSlice. 240 * 241 * @param value std::string& value of the "value" attribute to be set. 242 * 243 * @copydetails doc_returns_one_success_code 244 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 245 * 246 * Calling this function with @p value = @c NULL or an empty string is 247 * equivalent to calling unsetValue(). 248 */ 249 int setValue(const std::string& value); 250 251 252 /** 253 * Sets the value of the "index" attribute of this SedSlice. 254 * 255 * @param index std::string& value of the "index" attribute to be set. 256 * 257 * @copydetails doc_returns_success_code 258 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 259 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 260 * OperationReturnValues_t} 261 */ 262 int setIndex(const std::string& index); 263 264 265 /** 266 * Sets the value of the "startIndex" attribute of this SedSlice. 267 * 268 * @param startIndex int value of the "startIndex" attribute to be set. 269 * 270 * @copydetails doc_returns_success_code 271 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 272 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 273 * OperationReturnValues_t} 274 */ 275 int setStartIndex(int startIndex); 276 277 278 /** 279 * Sets the value of the "endIndex" attribute of this SedSlice. 280 * 281 * @param endIndex int value of the "endIndex" attribute to be set. 282 * 283 * @copydetails doc_returns_success_code 284 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 285 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 286 * OperationReturnValues_t} 287 */ 288 int setEndIndex(int endIndex); 289 290 291 /** 292 * Unsets the value of the "reference" attribute of this SedSlice. 293 * 294 * @copydetails doc_returns_success_code 295 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 296 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 297 */ 298 int unsetReference(); 299 300 301 /** 302 * Unsets the value of the "value" attribute of this SedSlice. 303 * 304 * @copydetails doc_returns_success_code 305 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 306 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 307 */ 308 int unsetValue(); 309 310 311 /** 312 * Unsets the value of the "index" attribute of this SedSlice. 313 * 314 * @copydetails doc_returns_success_code 315 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 316 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 317 */ 318 int unsetIndex(); 319 320 321 /** 322 * Unsets the value of the "startIndex" attribute of this SedSlice. 323 * 324 * @copydetails doc_returns_success_code 325 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 326 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 327 */ 328 int unsetStartIndex(); 329 330 331 /** 332 * Unsets the value of the "endIndex" attribute of this SedSlice. 333 * 334 * @copydetails doc_returns_success_code 335 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 336 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 337 */ 338 int unsetEndIndex(); 339 340 341 /** 342 * @copydoc doc_renamesidref_common 343 */ 344 virtual void renameSIdRefs(const std::string& oldid, 345 const std::string& newid); 346 347 348 /** 349 * Returns the XML element name of this SedSlice object. 350 * 351 * For SedSlice, the XML element name is always @c "slice". 352 * 353 * @return the name of this element, i.e. @c "slice". 354 */ 355 virtual const std::string& getElementName() const; 356 357 358 /** 359 * Returns the libSEDML type code for this SedSlice object. 360 * 361 * @copydetails doc_what_are_typecodes 362 * 363 * @return the SED-ML type code for this object: 364 * @sedmlconstant{SEDML_DATA_SLICE, SedTypeCode_t}. 365 * 366 * @copydetails doc_warning_typecodes_not_unique 367 * 368 * @see getElementName() 369 */ 370 virtual int getTypeCode() const; 371 372 373 /** 374 * Predicate returning @c true if all the required attributes for this 375 * SedSlice object have been set. 376 * 377 * @return @c true to indicate that all the required attributes of this 378 * SedSlice have been set, otherwise @c false is returned. 379 * 380 * 381 * @note The required attributes for the SedSlice object are: 382 * @li "reference" 383 * @li "value" 384 */ 385 virtual bool hasRequiredAttributes() const; 386 387 388 389 /** @cond doxygenLibSEDMLInternal */ 390 391 /** 392 * Write any contained elements 393 */ 394 virtual void writeElements(LIBSBML_CPP_NAMESPACE_QUALIFIER XMLOutputStream& 395 stream) const; 396 397 /** @endcond */ 398 399 400 401 /** @cond doxygenLibSEDMLInternal */ 402 403 /** 404 * Accepts the given SedVisitor 405 */ 406 virtual bool accept(SedVisitor& v) const; 407 408 /** @endcond */ 409 410 411 412 /** @cond doxygenLibSEDMLInternal */ 413 414 /** 415 * Sets the parent SedDocument 416 */ 417 virtual void setSedDocument(SedDocument* d); 418 419 /** @endcond */ 420 421 422 423 424 #ifndef SWIG 425 426 427 428 /** @cond doxygenLibSEDMLInternal */ 429 430 /** 431 * Gets the value of the "attributeName" attribute of this SedSlice. 432 * 433 * @param attributeName, the name of the attribute to retrieve. 434 * 435 * @param value, the address of the value to record. 436 * 437 * @copydetails doc_returns_success_code 438 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 439 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 440 */ 441 virtual int getAttribute(const std::string& attributeName, bool& value) 442 const; 443 444 /** @endcond */ 445 446 447 448 /** @cond doxygenLibSEDMLInternal */ 449 450 /** 451 * Gets the value of the "attributeName" attribute of this SedSlice. 452 * 453 * @param attributeName, the name of the attribute to retrieve. 454 * 455 * @param value, the address of the value to record. 456 * 457 * @copydetails doc_returns_success_code 458 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 459 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 460 */ 461 virtual int getAttribute(const std::string& attributeName, int& value) const; 462 463 /** @endcond */ 464 465 466 467 /** @cond doxygenLibSEDMLInternal */ 468 469 /** 470 * Gets the value of the "attributeName" attribute of this SedSlice. 471 * 472 * @param attributeName, the name of the attribute to retrieve. 473 * 474 * @param value, the address of the value to record. 475 * 476 * @copydetails doc_returns_success_code 477 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 478 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 479 */ 480 virtual int getAttribute(const std::string& attributeName, 481 double& value) const; 482 483 /** @endcond */ 484 485 486 487 /** @cond doxygenLibSEDMLInternal */ 488 489 /** 490 * Gets the value of the "attributeName" attribute of this SedSlice. 491 * 492 * @param attributeName, the name of the attribute to retrieve. 493 * 494 * @param value, the address of the value to record. 495 * 496 * @copydetails doc_returns_success_code 497 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 498 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 499 */ 500 virtual int getAttribute(const std::string& attributeName, 501 unsigned int& value) const; 502 503 /** @endcond */ 504 505 506 507 /** @cond doxygenLibSEDMLInternal */ 508 509 /** 510 * Gets the value of the "attributeName" attribute of this SedSlice. 511 * 512 * @param attributeName, the name of the attribute to retrieve. 513 * 514 * @param value, the address of the value to record. 515 * 516 * @copydetails doc_returns_success_code 517 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 518 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 519 */ 520 virtual int getAttribute(const std::string& attributeName, 521 std::string& value) const; 522 523 /** @endcond */ 524 525 526 527 /** @cond doxygenLibSEDMLInternal */ 528 529 /** 530 * Predicate returning @c true if this SedSlice's attribute "attributeName" 531 * is set. 532 * 533 * @param attributeName, the name of the attribute to query. 534 * 535 * @return @c true if this SedSlice's attribute "attributeName" has been set, 536 * otherwise @c false is returned. 537 */ 538 virtual bool isSetAttribute(const std::string& attributeName) const; 539 540 /** @endcond */ 541 542 543 544 /** @cond doxygenLibSEDMLInternal */ 545 546 /** 547 * Sets the value of the "attributeName" attribute of this SedSlice. 548 * 549 * @param attributeName, the name of the attribute to set. 550 * 551 * @param value, the value of the attribute to set. 552 * 553 * @copydetails doc_returns_success_code 554 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 555 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 556 */ 557 virtual int setAttribute(const std::string& attributeName, bool value); 558 559 /** @endcond */ 560 561 562 563 /** @cond doxygenLibSEDMLInternal */ 564 565 /** 566 * Sets the value of the "attributeName" attribute of this SedSlice. 567 * 568 * @param attributeName, the name of the attribute to set. 569 * 570 * @param value, the value of the attribute to set. 571 * 572 * @copydetails doc_returns_success_code 573 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 574 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 575 */ 576 virtual int setAttribute(const std::string& attributeName, int value); 577 578 /** @endcond */ 579 580 581 582 /** @cond doxygenLibSEDMLInternal */ 583 584 /** 585 * Sets the value of the "attributeName" attribute of this SedSlice. 586 * 587 * @param attributeName, the name of the attribute to set. 588 * 589 * @param value, the value of the attribute to set. 590 * 591 * @copydetails doc_returns_success_code 592 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 593 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 594 */ 595 virtual int setAttribute(const std::string& attributeName, double value); 596 597 /** @endcond */ 598 599 600 601 /** @cond doxygenLibSEDMLInternal */ 602 603 /** 604 * Sets the value of the "attributeName" attribute of this SedSlice. 605 * 606 * @param attributeName, the name of the attribute to set. 607 * 608 * @param value, the value of the attribute to set. 609 * 610 * @copydetails doc_returns_success_code 611 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 612 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 613 */ 614 virtual int setAttribute(const std::string& attributeName, 615 unsigned int value); 616 617 /** @endcond */ 618 619 620 621 /** @cond doxygenLibSEDMLInternal */ 622 623 /** 624 * Sets the value of the "attributeName" attribute of this SedSlice. 625 * 626 * @param attributeName, the name of the attribute to set. 627 * 628 * @param value, the value of the attribute to set. 629 * 630 * @copydetails doc_returns_success_code 631 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 632 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 633 */ 634 virtual int setAttribute(const std::string& attributeName, 635 const std::string& value); 636 637 /** @endcond */ 638 639 640 641 /** @cond doxygenLibSEDMLInternal */ 642 643 /** 644 * Unsets the value of the "attributeName" attribute of this SedSlice. 645 * 646 * @param attributeName, the name of the attribute to query. 647 * 648 * @copydetails doc_returns_success_code 649 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 650 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 651 */ 652 virtual int unsetAttribute(const std::string& attributeName); 653 654 /** @endcond */ 655 656 657 658 659 #endif /* !SWIG */ 660 661 662 protected: 663 664 665 /** @cond doxygenLibSEDMLInternal */ 666 667 /** 668 * Adds the expected attributes for this element 669 */ 670 virtual void addExpectedAttributes(LIBSBML_CPP_NAMESPACE_QUALIFIER 671 ExpectedAttributes& attributes); 672 673 /** @endcond */ 674 675 676 677 /** @cond doxygenLibSEDMLInternal */ 678 679 /** 680 * Reads the expected attributes into the member data variables 681 */ 682 virtual void readAttributes( 683 const LIBSBML_CPP_NAMESPACE_QUALIFIER 684 XMLAttributes& attributes, 685 const LIBSBML_CPP_NAMESPACE_QUALIFIER 686 ExpectedAttributes& expectedAttributes); 687 688 /** @endcond */ 689 690 691 692 /** @cond doxygenLibSEDMLInternal */ 693 694 /** 695 * Writes the attributes to the stream 696 */ 697 virtual void writeAttributes(LIBSBML_CPP_NAMESPACE_QUALIFIER XMLOutputStream& 698 stream) const; 699 700 /** @endcond */ 701 702 703 }; 704 705 706 707 LIBSEDML_CPP_NAMESPACE_END 708 709 710 711 712 #endif /* __cplusplus */ 713 714 715 716 717 #ifndef SWIG 718 719 720 721 722 LIBSEDML_CPP_NAMESPACE_BEGIN 723 724 725 726 727 BEGIN_C_DECLS 728 729 730 /** 731 * Creates a new SedSlice_t using the given SED-ML Level and @ p version values. 732 * 733 * @param level an unsigned int, the SED-ML Level to assign to this SedSlice_t. 734 * 735 * @param version an unsigned int, the SED-ML Version to assign to this 736 * SedSlice_t. 737 * 738 * @copydetails doc_note_setting_lv_pkg 739 * 740 * @copydetails doc_returned_owned_pointer 741 * 742 * @memberof SedSlice_t 743 */ 744 LIBSEDML_EXTERN 745 SedSlice_t * 746 SedSlice_create(unsigned int level, unsigned int version); 747 748 749 /** 750 * Creates and returns a deep copy of this SedSlice_t object. 751 * 752 * @param ss the SedSlice_t structure. 753 * 754 * @return a (deep) copy of this SedSlice_t object. 755 * 756 * @copydetails doc_returned_owned_pointer 757 * 758 * @memberof SedSlice_t 759 */ 760 LIBSEDML_EXTERN 761 SedSlice_t* 762 SedSlice_clone(const SedSlice_t* ss); 763 764 765 /** 766 * Frees this SedSlice_t object. 767 * 768 * @param ss the SedSlice_t structure. 769 * 770 * @memberof SedSlice_t 771 */ 772 LIBSEDML_EXTERN 773 void 774 SedSlice_free(SedSlice_t* ss); 775 776 777 /** 778 * Returns the value of the "reference" attribute of this SedSlice_t. 779 * 780 * @param ss the SedSlice_t structure whose reference is sought. 781 * 782 * @return the value of the "reference" attribute of this SedSlice_t as a 783 * pointer to a string. 784 * 785 * @copydetails doc_returned_owned_char 786 * 787 * @memberof SedSlice_t 788 */ 789 LIBSEDML_EXTERN 790 char * 791 SedSlice_getReference(const SedSlice_t * ss); 792 793 794 /** 795 * Returns the value of the "value" attribute of this SedSlice_t. 796 * 797 * @param ss the SedSlice_t structure whose value is sought. 798 * 799 * @return the value of the "value" attribute of this SedSlice_t as a pointer 800 * to a string. 801 * 802 * @copydetails doc_returned_owned_char 803 * 804 * @memberof SedSlice_t 805 */ 806 LIBSEDML_EXTERN 807 char * 808 SedSlice_getValue(const SedSlice_t * ss); 809 810 811 /** 812 * Returns the value of the "index" attribute of this SedSlice_t. 813 * 814 * @param ss the SedSlice_t structure whose index is sought. 815 * 816 * @return the value of the "index" attribute of this SedSlice_t as a pointer 817 * to a string. 818 * 819 * @copydetails doc_returned_owned_char 820 * 821 * @memberof SedSlice_t 822 */ 823 LIBSEDML_EXTERN 824 char * 825 SedSlice_getIndex(const SedSlice_t * ss); 826 827 828 /** 829 * Returns the value of the "startIndex" attribute of this SedSlice_t. 830 * 831 * @param ss the SedSlice_t structure whose startIndex is sought. 832 * 833 * @return the value of the "startIndex" attribute of this SedSlice_t as a 834 * integer. 835 * 836 * @memberof SedSlice_t 837 */ 838 LIBSEDML_EXTERN 839 int 840 SedSlice_getStartIndex(const SedSlice_t * ss); 841 842 843 /** 844 * Returns the value of the "endIndex" attribute of this SedSlice_t. 845 * 846 * @param ss the SedSlice_t structure whose endIndex is sought. 847 * 848 * @return the value of the "endIndex" attribute of this SedSlice_t as a 849 * integer. 850 * 851 * @memberof SedSlice_t 852 */ 853 LIBSEDML_EXTERN 854 int 855 SedSlice_getEndIndex(const SedSlice_t * ss); 856 857 858 /** 859 * Predicate returning @c 1 (true) if this SedSlice_t's "reference" attribute 860 * is set. 861 * 862 * @param ss the SedSlice_t structure. 863 * 864 * @return @c 1 (true) if this SedSlice_t's "reference" attribute has been set, 865 * otherwise @c 0 (false) is returned. 866 * 867 * @memberof SedSlice_t 868 */ 869 LIBSEDML_EXTERN 870 int 871 SedSlice_isSetReference(const SedSlice_t * ss); 872 873 874 /** 875 * Predicate returning @c 1 (true) if this SedSlice_t's "value" attribute is 876 * set. 877 * 878 * @param ss the SedSlice_t structure. 879 * 880 * @return @c 1 (true) if this SedSlice_t's "value" attribute has been set, 881 * otherwise @c 0 (false) is returned. 882 * 883 * @memberof SedSlice_t 884 */ 885 LIBSEDML_EXTERN 886 int 887 SedSlice_isSetValue(const SedSlice_t * ss); 888 889 890 /** 891 * Predicate returning @c 1 (true) if this SedSlice_t's "index" attribute is 892 * set. 893 * 894 * @param ss the SedSlice_t structure. 895 * 896 * @return @c 1 (true) if this SedSlice_t's "index" attribute has been set, 897 * otherwise @c 0 (false) is returned. 898 * 899 * @memberof SedSlice_t 900 */ 901 LIBSEDML_EXTERN 902 int 903 SedSlice_isSetIndex(const SedSlice_t * ss); 904 905 906 /** 907 * Predicate returning @c 1 (true) if this SedSlice_t's "startIndex" attribute 908 * is set. 909 * 910 * @param ss the SedSlice_t structure. 911 * 912 * @return @c 1 (true) if this SedSlice_t's "startIndex" attribute has been 913 * set, otherwise @c 0 (false) is returned. 914 * 915 * @memberof SedSlice_t 916 */ 917 LIBSEDML_EXTERN 918 int 919 SedSlice_isSetStartIndex(const SedSlice_t * ss); 920 921 922 /** 923 * Predicate returning @c 1 (true) if this SedSlice_t's "endIndex" attribute is 924 * set. 925 * 926 * @param ss the SedSlice_t structure. 927 * 928 * @return @c 1 (true) if this SedSlice_t's "endIndex" attribute has been set, 929 * otherwise @c 0 (false) is returned. 930 * 931 * @memberof SedSlice_t 932 */ 933 LIBSEDML_EXTERN 934 int 935 SedSlice_isSetEndIndex(const SedSlice_t * ss); 936 937 938 /** 939 * Sets the value of the "reference" attribute of this SedSlice_t. 940 * 941 * @param ss the SedSlice_t structure. 942 * 943 * @param reference const char * value of the "reference" attribute to be set. 944 * 945 * @copydetails doc_returns_success_code 946 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 947 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 948 * OperationReturnValues_t} 949 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 950 * 951 * @memberof SedSlice_t 952 */ 953 LIBSEDML_EXTERN 954 int 955 SedSlice_setReference(SedSlice_t * ss, const char * reference); 956 957 958 /** 959 * Sets the value of the "value" attribute of this SedSlice_t. 960 * 961 * @param ss the SedSlice_t structure. 962 * 963 * @param value const char * value of the "value" attribute to be set. 964 * 965 * @copydetails doc_returns_success_code 966 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 967 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 968 * 969 * Calling this function with @p value = @c NULL or an empty string is 970 * equivalent to calling SedSlice_unsetValue(). 971 * 972 * @memberof SedSlice_t 973 */ 974 LIBSEDML_EXTERN 975 int 976 SedSlice_setValue(SedSlice_t * ss, const char * value); 977 978 979 /** 980 * Sets the value of the "index" attribute of this SedSlice_t. 981 * 982 * @param ss the SedSlice_t structure. 983 * 984 * @param index const char * value of the "index" attribute to be set. 985 * 986 * @copydetails doc_returns_success_code 987 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 988 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 989 * OperationReturnValues_t} 990 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 991 * 992 * @memberof SedSlice_t 993 */ 994 LIBSEDML_EXTERN 995 int 996 SedSlice_setIndex(SedSlice_t * ss, const char * index); 997 998 999 /** 1000 * Sets the value of the "startIndex" attribute of this SedSlice_t. 1001 * 1002 * @param ss the SedSlice_t structure. 1003 * 1004 * @param startIndex int value of the "startIndex" attribute to be set. 1005 * 1006 * @copydetails doc_returns_success_code 1007 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1008 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 1009 * OperationReturnValues_t} 1010 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1011 * 1012 * @memberof SedSlice_t 1013 */ 1014 LIBSEDML_EXTERN 1015 int 1016 SedSlice_setStartIndex(SedSlice_t * ss, int startIndex); 1017 1018 1019 /** 1020 * Sets the value of the "endIndex" attribute of this SedSlice_t. 1021 * 1022 * @param ss the SedSlice_t structure. 1023 * 1024 * @param endIndex int value of the "endIndex" attribute to be set. 1025 * 1026 * @copydetails doc_returns_success_code 1027 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1028 * @li @sedmlconstant{LIBSEDML_INVALID_ATTRIBUTE_VALUE, 1029 * OperationReturnValues_t} 1030 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1031 * 1032 * @memberof SedSlice_t 1033 */ 1034 LIBSEDML_EXTERN 1035 int 1036 SedSlice_setEndIndex(SedSlice_t * ss, int endIndex); 1037 1038 1039 /** 1040 * Unsets the value of the "reference" attribute of this SedSlice_t. 1041 * 1042 * @param ss the SedSlice_t structure. 1043 * 1044 * @copydetails doc_returns_success_code 1045 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1046 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 1047 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1048 * 1049 * @memberof SedSlice_t 1050 */ 1051 LIBSEDML_EXTERN 1052 int 1053 SedSlice_unsetReference(SedSlice_t * ss); 1054 1055 1056 /** 1057 * Unsets the value of the "value" attribute of this SedSlice_t. 1058 * 1059 * @param ss the SedSlice_t structure. 1060 * 1061 * @copydetails doc_returns_success_code 1062 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1063 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 1064 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1065 * 1066 * @memberof SedSlice_t 1067 */ 1068 LIBSEDML_EXTERN 1069 int 1070 SedSlice_unsetValue(SedSlice_t * ss); 1071 1072 1073 /** 1074 * Unsets the value of the "index" attribute of this SedSlice_t. 1075 * 1076 * @param ss the SedSlice_t structure. 1077 * 1078 * @copydetails doc_returns_success_code 1079 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1080 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 1081 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1082 * 1083 * @memberof SedSlice_t 1084 */ 1085 LIBSEDML_EXTERN 1086 int 1087 SedSlice_unsetIndex(SedSlice_t * ss); 1088 1089 1090 /** 1091 * Unsets the value of the "startIndex" attribute of this SedSlice_t. 1092 * 1093 * @param ss the SedSlice_t structure. 1094 * 1095 * @copydetails doc_returns_success_code 1096 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1097 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 1098 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1099 * 1100 * @memberof SedSlice_t 1101 */ 1102 LIBSEDML_EXTERN 1103 int 1104 SedSlice_unsetStartIndex(SedSlice_t * ss); 1105 1106 1107 /** 1108 * Unsets the value of the "endIndex" attribute of this SedSlice_t. 1109 * 1110 * @param ss the SedSlice_t structure. 1111 * 1112 * @copydetails doc_returns_success_code 1113 * @li @sedmlconstant{LIBSEDML_OPERATION_SUCCESS, OperationReturnValues_t} 1114 * @li @sedmlconstant{LIBSEDML_OPERATION_FAILED, OperationReturnValues_t} 1115 * @li @sedmlconstant{LIBSEDML_INVALID_OBJECT, OperationReturnValues_t} 1116 * 1117 * @memberof SedSlice_t 1118 */ 1119 LIBSEDML_EXTERN 1120 int 1121 SedSlice_unsetEndIndex(SedSlice_t * ss); 1122 1123 1124 /** 1125 * Predicate returning @c 1 (true) if all the required attributes for this 1126 * SedSlice_t object have been set. 1127 * 1128 * @param ss the SedSlice_t structure. 1129 * 1130 * @return @c 1 (true) to indicate that all the required attributes of this 1131 * SedSlice_t have been set, otherwise @c 0 (false) is returned. 1132 * 1133 * 1134 * @note The required attributes for the SedSlice_t object are: 1135 * @li "reference" 1136 * @li "value" 1137 * 1138 * @memberof SedSlice_t 1139 */ 1140 LIBSEDML_EXTERN 1141 int 1142 SedSlice_hasRequiredAttributes(const SedSlice_t * ss); 1143 1144 1145 1146 1147 END_C_DECLS 1148 1149 1150 1151 1152 LIBSEDML_CPP_NAMESPACE_END 1153 1154 1155 1156 1157 #endif /* !SWIG */ 1158 1159 1160 1161 1162 #endif /* !SedSlice_H__ */ 1163 1164 1165