001/* ---------------------------------------------------------------------------- 002 * This file was automatically generated by SWIG (http://www.swig.org). 003 * Version 3.0.10 004 * 005 * Do not make changes to this file unless you know what you are doing--modify 006 * the SWIG interface file instead. 007 * ----------------------------------------------------------------------------- */ 008 009package org.sbml.libsbml; 010 011/** 012 * <span class="pkg-marker pkg-color-layout"><a href="group__layout.html">layout</a></span> 013 014 A glyph for miscellaneous items. 015 <p> 016 * The {@link GeneralGlyph} is used to facilitate the representation of elements 017 * other than {@link Compartment}, {@link Species} and {@link Reaction} and thus can be used for the 018 * display of relationships of {@link Rule} or elements defined by other SBML 019 * packages. It closely follows the structure of the {@link ReactionGlyph}. 020 * {@link GeneralGlyph} is defined to have an optional attribute reference as well as 021 * the elements curve, listOfReferenceGlyphs and listOfSubGlyphs. 022 */ 023 024public class GeneralGlyph extends GraphicalObject { 025 private long swigCPtr; 026 027 protected GeneralGlyph(long cPtr, boolean cMemoryOwn) 028 { 029 super(libsbmlJNI.GeneralGlyph_SWIGUpcast(cPtr), cMemoryOwn); 030 swigCPtr = cPtr; 031 } 032 033 protected static long getCPtr(GeneralGlyph obj) 034 { 035 return (obj == null) ? 0 : obj.swigCPtr; 036 } 037 038 protected static long getCPtrAndDisown (GeneralGlyph obj) 039 { 040 long ptr = 0; 041 042 if (obj != null) 043 { 044 ptr = obj.swigCPtr; 045 obj.swigCMemOwn = false; 046 } 047 048 return ptr; 049 } 050 051 protected void finalize() { 052 delete(); 053 } 054 055 public synchronized void delete() { 056 if (swigCPtr != 0) { 057 if (swigCMemOwn) { 058 swigCMemOwn = false; 059 libsbmlJNI.delete_GeneralGlyph(swigCPtr); 060 } 061 swigCPtr = 0; 062 } 063 super.delete(); 064 } 065 066 067/** 068 * Creates a new {@link GeneralGlyph}. The list of reference glyph and subglyphs is 069 * empty and the id of the associated element is set to the empty 070 * string. 071 <p> 072 * @param level the SBML Level. 073 * @param version the Version within the SBML Level. 074 * @param pkgVersion the version of the package. 075 <p> 076 * <p> 077 * @note Attempting to add an object to an {@link SBMLDocument} having a different 078 * combination of SBML Level, Version and XML namespaces than the object 079 * itself will result in an error at the time a caller attempts to make the 080 * addition. A parent object must have compatible Level, Version and XML 081 * namespaces. (Strictly speaking, a parent may also have more XML 082 * namespaces than a child, but the reverse is not permitted.) The 083 * restriction is necessary to ensure that an SBML model has a consistent 084 * overall structure. This requires callers to manage their objects 085 * carefully, but the benefit is increased flexibility in how models can be 086 * created by permitting callers to create objects bottom-up if desired. In 087 * situations where objects are not yet attached to parents (e.g., 088 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 089 * libSBML determine such things as whether it is valid to assign a 090 * particular value to an attribute. For packages, this means that the 091 * parent object to which this package element is being added must have 092 * been created with the package namespace, or that the package namespace 093 * was added to it, even if that parent is not a package object itself. 094 */ public 095 GeneralGlyph(long level, long version, long pkgVersion) throws org.sbml.libsbml.SBMLConstructorException { 096 this(libsbmlJNI.new_GeneralGlyph__SWIG_0(level, version, pkgVersion), true); 097 } 098 099 100/** 101 * Creates a new {@link GeneralGlyph}. The list of reference glyph and subglyphs is 102 * empty and the id of the associated element is set to the empty 103 * string. 104 <p> 105 * @param level the SBML Level. 106 * @param version the Version within the SBML Level. 107 * @param pkgVersion the version of the package. 108 <p> 109 * <p> 110 * @note Attempting to add an object to an {@link SBMLDocument} having a different 111 * combination of SBML Level, Version and XML namespaces than the object 112 * itself will result in an error at the time a caller attempts to make the 113 * addition. A parent object must have compatible Level, Version and XML 114 * namespaces. (Strictly speaking, a parent may also have more XML 115 * namespaces than a child, but the reverse is not permitted.) The 116 * restriction is necessary to ensure that an SBML model has a consistent 117 * overall structure. This requires callers to manage their objects 118 * carefully, but the benefit is increased flexibility in how models can be 119 * created by permitting callers to create objects bottom-up if desired. In 120 * situations where objects are not yet attached to parents (e.g., 121 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 122 * libSBML determine such things as whether it is valid to assign a 123 * particular value to an attribute. For packages, this means that the 124 * parent object to which this package element is being added must have 125 * been created with the package namespace, or that the package namespace 126 * was added to it, even if that parent is not a package object itself. 127 */ public 128 GeneralGlyph(long level, long version) throws org.sbml.libsbml.SBMLConstructorException { 129 this(libsbmlJNI.new_GeneralGlyph__SWIG_1(level, version), true); 130 } 131 132 133/** 134 * Creates a new {@link GeneralGlyph}. The list of reference glyph and subglyphs is 135 * empty and the id of the associated element is set to the empty 136 * string. 137 <p> 138 * @param level the SBML Level. 139 * @param version the Version within the SBML Level. 140 * @param pkgVersion the version of the package. 141 <p> 142 * <p> 143 * @note Attempting to add an object to an {@link SBMLDocument} having a different 144 * combination of SBML Level, Version and XML namespaces than the object 145 * itself will result in an error at the time a caller attempts to make the 146 * addition. A parent object must have compatible Level, Version and XML 147 * namespaces. (Strictly speaking, a parent may also have more XML 148 * namespaces than a child, but the reverse is not permitted.) The 149 * restriction is necessary to ensure that an SBML model has a consistent 150 * overall structure. This requires callers to manage their objects 151 * carefully, but the benefit is increased flexibility in how models can be 152 * created by permitting callers to create objects bottom-up if desired. In 153 * situations where objects are not yet attached to parents (e.g., 154 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 155 * libSBML determine such things as whether it is valid to assign a 156 * particular value to an attribute. For packages, this means that the 157 * parent object to which this package element is being added must have 158 * been created with the package namespace, or that the package namespace 159 * was added to it, even if that parent is not a package object itself. 160 */ public 161 GeneralGlyph(long level) throws org.sbml.libsbml.SBMLConstructorException { 162 this(libsbmlJNI.new_GeneralGlyph__SWIG_2(level), true); 163 } 164 165 166/** 167 * Creates a new {@link GeneralGlyph}. The list of reference glyph and subglyphs is 168 * empty and the id of the associated element is set to the empty 169 * string. 170 <p> 171 * @param level the SBML Level. 172 * @param version the Version within the SBML Level. 173 * @param pkgVersion the version of the package. 174 <p> 175 * <p> 176 * @note Attempting to add an object to an {@link SBMLDocument} having a different 177 * combination of SBML Level, Version and XML namespaces than the object 178 * itself will result in an error at the time a caller attempts to make the 179 * addition. A parent object must have compatible Level, Version and XML 180 * namespaces. (Strictly speaking, a parent may also have more XML 181 * namespaces than a child, but the reverse is not permitted.) The 182 * restriction is necessary to ensure that an SBML model has a consistent 183 * overall structure. This requires callers to manage their objects 184 * carefully, but the benefit is increased flexibility in how models can be 185 * created by permitting callers to create objects bottom-up if desired. In 186 * situations where objects are not yet attached to parents (e.g., 187 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 188 * libSBML determine such things as whether it is valid to assign a 189 * particular value to an attribute. For packages, this means that the 190 * parent object to which this package element is being added must have 191 * been created with the package namespace, or that the package namespace 192 * was added to it, even if that parent is not a package object itself. 193 */ public 194 GeneralGlyph() throws org.sbml.libsbml.SBMLConstructorException { 195 this(libsbmlJNI.new_GeneralGlyph__SWIG_3(), true); 196 } 197 198 199/** 200 * Creates a new {@link GeneralGlyph} with the given {@link LayoutPkgNamespaces} object. 201 <p> 202 * <p> 203 * The package namespaces object used in this constructor is derived from a 204 * {@link SBMLNamespaces} object, which encapsulates SBML Level/Version/namespaces 205 * information. It is used to communicate the SBML Level, Version, and 206 * package version and name information used in addition to SBML Level 3 Core. A 207 * common approach to using libSBML's {@link SBMLNamespaces} facilities is to create an 208 * package namespace object somewhere in a program once, then hand that object 209 * as needed to object constructors of that package that accept it as and 210 * argument, such as this one. 211 <p> 212 * @param layoutns the {@link LayoutPkgNamespaces} object. 213 <p> 214 * <p> 215 * @note Attempting to add an object to an {@link SBMLDocument} having a different 216 * combination of SBML Level, Version and XML namespaces than the object 217 * itself will result in an error at the time a caller attempts to make the 218 * addition. A parent object must have compatible Level, Version and XML 219 * namespaces. (Strictly speaking, a parent may also have more XML 220 * namespaces than a child, but the reverse is not permitted.) The 221 * restriction is necessary to ensure that an SBML model has a consistent 222 * overall structure. This requires callers to manage their objects 223 * carefully, but the benefit is increased flexibility in how models can be 224 * created by permitting callers to create objects bottom-up if desired. In 225 * situations where objects are not yet attached to parents (e.g., 226 * {@link SBMLDocument}), knowledge of the intented SBML Level and Version help 227 * libSBML determine such things as whether it is valid to assign a 228 * particular value to an attribute. For packages, this means that the 229 * parent object to which this package element is being added must have 230 * been created with the package namespace, or that the package namespace 231 * was added to it, even if that parent is not a package object itself. 232 */ public 233 GeneralGlyph(LayoutPkgNamespaces layoutns) throws org.sbml.libsbml.SBMLConstructorException { 234 this(libsbmlJNI.new_GeneralGlyph__SWIG_4(LayoutPkgNamespaces.getCPtr(layoutns), layoutns), true); 235 } 236 237 238/** 239 * Creates a glyph with the given {@link LayoutPkgNamespaces} and id. 240 <p> 241 * (FOR BACKWARD COMPATIBILITY) 242 */ public 243 GeneralGlyph(LayoutPkgNamespaces layoutns, String id) throws org.sbml.libsbml.SBMLConstructorException { 244 this(libsbmlJNI.new_GeneralGlyph__SWIG_5(LayoutPkgNamespaces.getCPtr(layoutns), layoutns, id), true); 245 } 246 247 248/** 249 * Creates a glyph with the given {@link LayoutPkgNamespaces}, id and set the id of the 250 * associated element to the second argument. 251 <p> 252 * (FOR BACKWARD COMPATIBILITY) 253 */ public 254 GeneralGlyph(LayoutPkgNamespaces layoutns, String id, String referenceId) throws org.sbml.libsbml.SBMLConstructorException { 255 this(libsbmlJNI.new_GeneralGlyph__SWIG_6(LayoutPkgNamespaces.getCPtr(layoutns), layoutns, id, referenceId), true); 256 } 257 258 259/** 260 * Creates a new {@link GeneralGlyph} from the given {@link XMLNode} 261 <p> 262 * (FOR BACKWARD COMPATIBILITY) 263 */ public 264 GeneralGlyph(XMLNode node, long l2version) throws org.sbml.libsbml.SBMLConstructorException { 265 this(libsbmlJNI.new_GeneralGlyph__SWIG_7(XMLNode.getCPtr(node), node, l2version), true); 266 } 267 268 269/** 270 * Creates a new {@link GeneralGlyph} from the given {@link XMLNode} 271 <p> 272 * (FOR BACKWARD COMPATIBILITY) 273 */ public 274 GeneralGlyph(XMLNode node) throws org.sbml.libsbml.SBMLConstructorException { 275 this(libsbmlJNI.new_GeneralGlyph__SWIG_8(XMLNode.getCPtr(node), node), true); 276 } 277 278 279/** 280 * Copy constructor. 281 <p> 282 * @param source the instance to copy. 283 */ public 284 GeneralGlyph(GeneralGlyph source) throws org.sbml.libsbml.SBMLConstructorException { 285 this(libsbmlJNI.new_GeneralGlyph__SWIG_9(GeneralGlyph.getCPtr(source), source), true); 286 } 287 288 289/** 290 * <p> 291 * Replaces all uses of a given <code>SIdRef</code> type attribute value with another 292 * value. 293 <p> 294 * <p> 295 * In SBML, object identifiers are of a data type called <code>SId</code>. 296 * In SBML Level 3, an explicit data type called <code>SIdRef</code> was 297 * introduced for attribute values that refer to <code>SId</code> values; in 298 * previous Levels of SBML, this data type did not exist and attributes were 299 * simply described to as 'referring to an identifier', but the effective 300 * data type was the same as <code>SIdRef</code> in Level 3. These and 301 * other methods of libSBML refer to the type <code>SIdRef</code> for all 302 * Levels of SBML, even if the corresponding SBML specification did not 303 * explicitly name the data type. 304 <p> 305 * This method works by looking at all attributes and (if appropriate) 306 * mathematical formulas in MathML content, comparing the referenced 307 * identifiers to the value of <code>oldid</code>. If any matches are found, the 308 * matching values are replaced with <code>newid</code>. The method does <em>not</em> 309 * descend into child elements. 310 <p> 311 * @param oldid the old identifier. 312 * @param newid the new identifier. 313 */ public 314 void renameSIdRefs(String oldid, String newid) { 315 libsbmlJNI.GeneralGlyph_renameSIdRefs(swigCPtr, this, oldid, newid); 316 } 317 318 319/** 320 * Returns the id of the associated element. 321 */ public 322 String getReferenceId() { 323 return libsbmlJNI.GeneralGlyph_getReferenceId(swigCPtr, this); 324 } 325 326 327/** 328 * Sets the id of the associated element. 329 */ public 330 int setReferenceId(String id) { 331 return libsbmlJNI.GeneralGlyph_setReferenceId(swigCPtr, this, id); 332 } 333 334 335/** 336 * Returns <code>true</code> if the id of the associated element is not the empty 337 * string. 338 */ public 339 boolean isSetReferenceId() { 340 return libsbmlJNI.GeneralGlyph_isSetReferenceId(swigCPtr, this); 341 } 342 343 344/** 345 * Returns the {@link ListOf} object that hold the reference glyphs. 346 */ public 347 ListOfReferenceGlyphs getListOfReferenceGlyphs() { 348 long cPtr = libsbmlJNI.GeneralGlyph_getListOfReferenceGlyphs__SWIG_0(swigCPtr, this); 349 return (cPtr == 0) ? null : new ListOfReferenceGlyphs(cPtr, false); 350 } 351 352 353/** 354 * Returns the {@link ListOf} object that hold the sub glyphs. 355 */ public 356 ListOfGraphicalObjects getListOfSubGlyphs() { 357 long cPtr = libsbmlJNI.GeneralGlyph_getListOfSubGlyphs__SWIG_0(swigCPtr, this); 358 return (cPtr == 0) ? null : new ListOfGraphicalObjects(cPtr, false); 359 } 360 361 362/** 363 * Returns the reference glyph with the given index. 364 * If the index is invalid, <code>null</code> is returned. 365 */ public 366 ReferenceGlyph getReferenceGlyph(long index) { 367 long cPtr = libsbmlJNI.GeneralGlyph_getReferenceGlyph__SWIG_0(swigCPtr, this, index); 368 return (cPtr == 0) ? null : new ReferenceGlyph(cPtr, false); 369 } 370 371 372/** 373 * Returns the sub glyph with the given index. 374 * If the index is invalid, <code>null</code> is returned. 375 */ public 376 GraphicalObject getSubGlyph(long index) { 377 return (GraphicalObject) libsbml.DowncastSBase(libsbmlJNI.GeneralGlyph_getSubGlyph__SWIG_0(swigCPtr, this, index), false); 378} 379 380 381/** 382 * Adds a new reference glyph to the list. 383 */ public 384 int addReferenceGlyph(ReferenceGlyph glyph) { 385 return libsbmlJNI.GeneralGlyph_addReferenceGlyph(swigCPtr, this, ReferenceGlyph.getCPtr(glyph), glyph); 386 } 387 388 389/** 390 * Adds a new subglyph to the list. 391 */ public 392 int addSubGlyph(GraphicalObject glyph) { 393 return libsbmlJNI.GeneralGlyph_addSubGlyph(swigCPtr, this, GraphicalObject.getCPtr(glyph), glyph); 394 } 395 396 397/** 398 * Returns the number of reference glyph objects. 399 */ public 400 long getNumReferenceGlyphs() { 401 return libsbmlJNI.GeneralGlyph_getNumReferenceGlyphs(swigCPtr, this); 402 } 403 404 405/** 406 * Returns the number of subglyph objects. 407 */ public 408 long getNumSubGlyphs() { 409 return libsbmlJNI.GeneralGlyph_getNumSubGlyphs(swigCPtr, this); 410 } 411 412 413/** 414 * Calls initDefaults from {@link GraphicalObject}. 415 */ public 416 void initDefaults() { 417 libsbmlJNI.GeneralGlyph_initDefaults(swigCPtr, this); 418 } 419 420 421/** 422 * Returns the curve object for the reaction glyph 423 */ public 424 Curve getCurve() { 425 long cPtr = libsbmlJNI.GeneralGlyph_getCurve__SWIG_0(swigCPtr, this); 426 return (cPtr == 0) ? null : new Curve(cPtr, false); 427 } 428 429 430/** 431 * Sets the curve object for the reaction glyph. 432 */ public 433 void setCurve(Curve curve) { 434 libsbmlJNI.GeneralGlyph_setCurve(swigCPtr, this, Curve.getCPtr(curve), curve); 435 } 436 437 438/** 439 * Returns <code>true</code> if the curve consists of one or more segments. 440 */ public 441 boolean isSetCurve() { 442 return libsbmlJNI.GeneralGlyph_isSetCurve(swigCPtr, this); 443 } 444 445 446/** */ public 447 boolean getCurveExplicitlySet() { 448 return libsbmlJNI.GeneralGlyph_getCurveExplicitlySet(swigCPtr, this); 449 } 450 451 452/** 453 * Creates a new {@link ReferenceGlyph} object, adds it to the end of the 454 * list of reference objects and returns a reference to the newly 455 * created object. 456 */ public 457 ReferenceGlyph createReferenceGlyph() { 458 long cPtr = libsbmlJNI.GeneralGlyph_createReferenceGlyph(swigCPtr, this); 459 return (cPtr == 0) ? null : new ReferenceGlyph(cPtr, false); 460 } 461 462 463/** 464 * Creates a new {@link LineSegment} object, adds it to the end of the list of 465 * curve segment objects of the curve and returns a reference to the 466 * newly created object. 467 */ public 468 LineSegment createLineSegment() { 469 return (LineSegment) libsbml.DowncastSBase(libsbmlJNI.GeneralGlyph_createLineSegment(swigCPtr, this), false); 470} 471 472 473/** 474 * Creates a new {@link CubicBezier} object, adds it to the end of the list of 475 * curve segment objects of the curve and returns a reference to the 476 * newly created object. 477 */ public 478 CubicBezier createCubicBezier() { 479 long cPtr = libsbmlJNI.GeneralGlyph_createCubicBezier(swigCPtr, this); 480 return (cPtr == 0) ? null : new CubicBezier(cPtr, false); 481 } 482 483 484/** 485 * Remove the reference glyph with the given index. 486 * A pointer to the object is returned. If no object has been removed, null 487 * is returned. 488 */ public 489 ReferenceGlyph removeReferenceGlyph(long index) { 490 long cPtr = libsbmlJNI.GeneralGlyph_removeReferenceGlyph__SWIG_0(swigCPtr, this, index); 491 return (cPtr == 0) ? null : new ReferenceGlyph(cPtr, false); 492 } 493 494 495/** 496 * Remove the subglyph with the given index. 497 * A pointer to the object is returned. If no object has been removed, null 498 * is returned. 499 */ public 500 GraphicalObject removeSubGlyph(long index) { 501 return (GraphicalObject) libsbml.DowncastSBase(libsbmlJNI.GeneralGlyph_removeSubGlyph__SWIG_0(swigCPtr, this, index), false); 502} 503 504 505/** 506 * Remove the reference glyph with the given <code>id</code>. 507 * A pointer to the object is returned. If no object has been removed, null 508 * is returned. 509 */ public 510 ReferenceGlyph removeReferenceGlyph(String id) { 511 long cPtr = libsbmlJNI.GeneralGlyph_removeReferenceGlyph__SWIG_1(swigCPtr, this, id); 512 return (cPtr == 0) ? null : new ReferenceGlyph(cPtr, false); 513 } 514 515 516/** 517 * Remove the subglyph with the given <code>id</code>. 518 * A pointer to the object is returned. If no object has been removed, null 519 * is returned. 520 */ public 521 GraphicalObject removeSubGlyph(String id) { 522 return (GraphicalObject) libsbml.DowncastSBase(libsbmlJNI.GeneralGlyph_removeSubGlyph__SWIG_1(swigCPtr, this, id), false); 523} 524 525 526/** 527 * Returns the index of the reference glyph with the given <code>id</code>. 528 * If the glyph does not contain a reference glyph with this 529 * id, cpp the 530 * value of the maximum long integer is returned as an indicator. 531 */ public 532 long getIndexForReferenceGlyph(String id) { 533 return libsbmlJNI.GeneralGlyph_getIndexForReferenceGlyph(swigCPtr, this, id); 534 } 535 536 537/** 538 * Returns the index of the subglyph with the given <code>id</code>. 539 * If the glyph does not contain a subglyph with this 540 * id, cpp the 541 * value of the maximum long integer is returned as an indicator. 542 */ public 543 long getIndexForSubGlyph(String id) { 544 return libsbmlJNI.GeneralGlyph_getIndexForSubGlyph(swigCPtr, this, id); 545 } 546 547 548/** 549 * Returns the XML element name of 550 * this SBML object. 551 <p> 552 * @return the string of the name of this element. 553 */ public 554 String getElementName() { 555 return libsbmlJNI.GeneralGlyph_getElementName(swigCPtr, this); 556 } 557 558 559/** 560 * Creates and returns a deep copy of this {@link GeneralGlyph}. 561 <p> 562 * @return a (deep) copy of this {@link GeneralGlyph}. 563 */ public 564 GeneralGlyph cloneObject() { 565 long cPtr = libsbmlJNI.GeneralGlyph_cloneObject(swigCPtr, this); 566 return (cPtr == 0) ? null : new GeneralGlyph(cPtr, true); 567 } 568 569 570/** 571 * Returns the libSBML type code of this object instance. 572 <p> 573 * <p> 574 * LibSBML attaches an identifying code to every kind of SBML object. These 575 * are integer constants known as <em>SBML type codes</em>. The names of all 576 * the codes begin with the characters <code>SBML_</code>. 577 * In the Java language interface for libSBML, the 578 * type codes are defined as static integer constants in the interface class 579 * {@link libsbmlConstants}. Note that different Level 3 580 * package plug-ins may use overlapping type codes; to identify the package 581 * to which a given object belongs, call the <code>getPackageName()</code> 582 * method on the object. 583 <p> 584 * @return the SBML type code for this object: 585 * {@link libsbmlConstants#SBML_LAYOUT_GENERALGLYPH SBML_LAYOUT_GENERALGLYPH}. 586 <p> 587 * <p> 588 * @warning <span class='warning'>The specific integer values of the possible 589 * type codes may be reused by different libSBML plug-ins for SBML Level 3. 590 * packages, To fully identify the correct code, <strong>it is necessary to 591 * invoke both getTypeCode() and getPackageName()</strong>.</span> 592 <p> 593 * @see #getElementName() 594 * @see #getPackageName() 595 */ public 596 int getTypeCode() { 597 return libsbmlJNI.GeneralGlyph_getTypeCode(swigCPtr, this); 598 } 599 600 601/** 602 * Creates an {@link XMLNode} object from this. 603 */ public 604 XMLNode toXML() { 605 return new XMLNode(libsbmlJNI.GeneralGlyph_toXML(swigCPtr, this), true); 606 } 607 608 public void connectToChild() { 609 libsbmlJNI.GeneralGlyph_connectToChild(swigCPtr, this); 610 } 611 612 613/** * @internal */ public 614 void enablePackageInternal(String pkgURI, String pkgPrefix, boolean flag) { 615 libsbmlJNI.GeneralGlyph_enablePackageInternal(swigCPtr, this, pkgURI, pkgPrefix, flag); 616 } 617 618}