<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Object
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function example_obj(Object $g)
{
/*implementation*/
}
public function example_bool($b)
{
}
public function example_int($i)
{
}
public function example_float($f)
{
}
public function example_double($d)
{
}
public function example_string($s)
{
}
public function example_obj_array($gs)
{
}
public function example_primitive_array($is)
{
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Mentor Attributes
private $capacity;
private $id;
private $name;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aCapacity, $aId, $aName)
{
$this->capacity = $aCapacity;
$this->id = $aId;
$this->name = $aName;
}
public function __construct()
{
$this->capacity = "31";
$this->name = "Umple";
}
//------------------------
// INTERFACE
//------------------------
public function setCapacity($aCapacity)
{
$wasSet = false;
$this->capacity = $aCapacity;
$wasSet = true;
return $wasSet;
}
public function setId($aId)
{
$wasSet = false;
$this->id = $aId;
$wasSet = true;
return $wasSet;
}
public function setName($aName)
{
$wasSet = false;
$this->name = $aName;
$wasSet = true;
return $wasSet;
}
public function getCapacity()
{
return $this->capacity;
}
public function getId()
{
return $this->id;
}
public function getName()
{
return $this->name;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Router implements NetworkNode
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Router Attributes
private $ipAddress;
//Router State Machines
private static $StatusDisconnected = 1;
private static $StatusConnected = 2;
private $status;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aIpAddress)
{
$this->ipAddress = $aIpAddress;
$this->setStatus(self::$StatusDisconnected);
}
//------------------------
// INTERFACE
//------------------------
public function getStatusFullName()
{
$answer = $this->getStatus();
return $answer;
}
public function getStatus()
{
if ($this->status == self::$StatusDisconnected) { return "StatusDisconnected"; }
elseif ($this->status == self::$StatusConnected) { return "StatusConnected"; }
return null;
}
public function createConnection()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusDisconnected)
{
$this->setStatus(self::$StatusConnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
public function disconnectRequest()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusConnected)
{
$this->setStatus(self::$StatusDisconnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
private function setStatus($aStatus)
{
$this->status = $aStatus;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function connect()
{
return "";
}
public function disconnect()
{
return "";
}
public function errorDetected()
{
return "";
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Router implements NetworkNode
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Router Attributes
private $ipAddress;
//Router State Machines
private static $StatusDisconnected = 1;
private static $StatusConnected = 2;
private $status;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aIpAddress)
{
$this->ipAddress = $aIpAddress;
$this->setStatus(self::$StatusDisconnected);
}
//------------------------
// INTERFACE
//------------------------
public function getStatusFullName()
{
$answer = $this->getStatus();
return $answer;
}
public function getStatus()
{
if ($this->status == self::$StatusDisconnected) { return "StatusDisconnected"; }
elseif ($this->status == self::$StatusConnected) { return "StatusConnected"; }
return null;
}
public function connect()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusDisconnected)
{
$this->setStatus(self::$StatusConnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
public function disconnect()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusConnected)
{
$this->setStatus(self::$StatusDisconnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
public function errorDetected()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusConnected)
{
$this->setStatus(self::$StatusDisconnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
private function setStatus($aStatus)
{
$this->status = $aStatus;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Router implements NetworkNode
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Router Attributes
private $ipAddress;
//Router State Machines
private static $StatusDisconnected = 1;
private static $StatusConnected = 2;
private $status;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aIpAddress)
{
$this->ipAddress = $aIpAddress;
$this->setStatus(self::$StatusDisconnected);
}
//------------------------
// INTERFACE
//------------------------
public function getStatusFullName()
{
$answer = $this->getStatus();
return $answer;
}
public function getStatus()
{
if ($this->status == self::$StatusDisconnected) { return "StatusDisconnected"; }
elseif ($this->status == self::$StatusConnected) { return "StatusConnected"; }
return null;
}
public function connect()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusDisconnected)
{
$this->setStatus(self::$StatusConnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
public function disconnect()
{
$wasEventProcessed = false;
$aStatus = $this->status;
if ($aStatus == self::$StatusConnected)
{
$this->setStatus(self::$StatusDisconnected);
$wasEventProcessed = true;
}
return $wasEventProcessed;
}
private function setStatus($aStatus)
{
$this->status = $aStatus;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function errorDetected()
{
return "";
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function showMe()
{
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function foo(int $a)
{
// line 22 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
System.out.println("Starting foo...");
// END OF UMPLE BEFORE INJECTION
if(a < 0) {
// line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
System.out.println("Returning from foo, a: " + a);
// END OF UMPLE AFTER INJECTION
return 4;
}
// line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
System.out.println("Returning from foo, a: " + a);
// END OF UMPLE AFTER INJECTION
return 3;
}
public function foo(int $a, $b)
{
// line 22 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
System.out.println("Starting foo...");
// END OF UMPLE BEFORE INJECTION
if(a > 0 && "".equals(b)) {
// line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
System.out.println("Returning from foo, a: " + a);
// END OF UMPLE AFTER INJECTION
return 3;
}
// line 18 "ClassTemplateTest_CodeInjectionsParametersUnspecified.ump"
System.out.println("Returning from foo, a: " + a);
// END OF UMPLE AFTER INJECTION
return 1;
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Mentor
{
//------------------------
// STATIC VARIABLES
//------------------------
public static $MAX = 100;
public static $MIN = -99;
public static $HELLO = "Hello";
private static $nextX = 1;
private static $mentorsById = array();
//------------------------
// MEMBER VARIABLES
//------------------------
//Mentor Attributes
private $str;
private $str2;
private $someName;
private $lDoub;
private $lBool;
private $name;
private $d;
private $t;
private $i;
private $id;
private $p;
private $q;
private $r;
private $s;
private $tt;
private $u;
private $v;
private $w;
//Autounique Attributes
private $x;
//Helper Variables
private $canSetStr2;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aStr, $aD, $aI, $aId)
{
$this->str = $aStr;
$this->canSetStr2 = true;
$this->someName = NULL;
$this->lDoub = 0;
$this->lBool = false;
$this->name = "Johannes";
$this->d = $aD;
$this->t = new Time();
$this->i = $aI;
$this->resetP();
$this->q = "chicken";
$this->resetR();
$this->s = "123";
$this->tt = date("y-m-d", strtotime("1978-12-25"));
$this->u = date("h:i:s", strtotime("12:13:14"));
$this->resetV();
$this->resetW();
$this->x = self::$nextX++;
if (!$this->setId($aId))
{
throw new RuntimeException("Cannot create due to duplicate id. See https://manual.umple.org?RE003ViolationofUniqueness.html");
}
}
//------------------------
// INTERFACE
//------------------------
public function setStr2($aStr2)
{
$wasSet = false;
if (!$this->canSetStr2) { return false; }
$this->canSetStr2 = false;
$this->str2 = $aStr2;
$wasSet = true;
return $wasSet;
}
public function setSomeName($aSomeName)
{
$wasSet = false;
$this->someName = $aSomeName;
$wasSet = true;
return $wasSet;
}
public function setLDoub($aLDoub)
{
$wasSet = false;
$this->lDoub = $aLDoub;
$wasSet = true;
return $wasSet;
}
public function setLBool($aLBool)
{
$wasSet = false;
$this->lBool = $aLBool;
$wasSet = true;
return $wasSet;
}
public function setName($aName)
{
$wasSet = false;
$this->name = $aName;
$wasSet = true;
return $wasSet;
}
public function setD($aD)
{
$wasSet = false;
$this->d = $aD;
$wasSet = true;
return $wasSet;
}
public function setI($aI)
{
$wasSet = false;
$this->i = $aI;
$wasSet = true;
return $wasSet;
}
public function setId($aId)
{
$wasSet = false;
if (isset($this->id)) {
$anOldId = $this->getId();
}
if (isset($anOldId) && $anOldId === $aId) {
return true;
}
if (Mentor::hasWithId($aId)) {
return $wasSet;
}
$this->id = $aId;
$wasSet = true;
if (isset($anOldId)) {
unset(Mentor::$mentorsById[(string)$anOldId]);
}
Mentor::$mentorsById[(string)$aId] = $this;
return $wasSet;
}
public function setP($aP)
{
$wasSet = false;
$this->p = $aP;
$wasSet = true;
return $wasSet;
}
public function resetP()
{
$wasReset = false;
$this->p = $this->getDefaultP();
$wasReset = true;
return $wasReset;
}
public function setQ($aQ)
{
$wasSet = false;
$this->q = $aQ;
$wasSet = true;
return $wasSet;
}
public function setR($aR)
{
$wasSet = false;
$this->r = $aR;
$wasSet = true;
return $wasSet;
}
public function resetR()
{
$wasReset = false;
$this->r = $this->getDefaultR();
$wasReset = true;
return $wasReset;
}
public function setTt($aTt)
{
$wasSet = false;
$this->tt = $aTt;
$wasSet = true;
return $wasSet;
}
public function setU($aU)
{
$wasSet = false;
$this->u = $aU;
$wasSet = true;
return $wasSet;
}
public function setV($aV)
{
$wasSet = false;
$this->v = $aV;
$wasSet = true;
return $wasSet;
}
public function resetV()
{
$wasReset = false;
$this->v = $this->getDefaultV();
$wasReset = true;
return $wasReset;
}
public function setW($aW)
{
$wasSet = false;
$this->w = $aW;
$wasSet = true;
return $wasSet;
}
public function resetW()
{
$wasReset = false;
$this->w = $this->getDefaultW();
$wasReset = true;
return $wasReset;
}
public function getStr()
{
return $this->str;
}
public function getStr2()
{
return $this->str2;
}
public function getSomeName()
{
return $this->someName;
}
public function getLDoub()
{
return $this->lDoub;
}
public function getLBool()
{
return $this->lBool;
}
public function getName()
{
return $this->name;
}
public function getD()
{
return $this->d;
}
public function getI()
{
return $this->i;
}
public function getDerivedTwiceI()
{
return i*2;
}
public function getId()
{
return $this->id;
}
public static function getWithId($aId)
{
return Mentor::$mentorsById[(string)$aId];
}
public static function hasWithId($aId)
{
return array_key_exists((string)$aId, Mentor::$mentorsById);
}
public function getP()
{
return $this->p;
}
public function getDefaultP()
{
return "robot";
}
public function getQ()
{
return $this->q;
}
public function getR()
{
return $this->r;
}
public function getDefaultR()
{
return "";
}
public function getS()
{
return $this->s;
}
public function getTt()
{
return $this->tt;
}
public function getU()
{
return $this->u;
}
public function getV()
{
return $this->v;
}
public function getDefaultV()
{
return date("y-m-d", strtotime("1978-12-26"));
}
public function getW()
{
return $this->w;
}
public function getDefaultW()
{
return date("h:i:s", strtotime("12:59:59"));
}
public function getX()
{
return $this->x;
}
public function isLBool()
{
return $this->lBool;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
unset(Mentor::$mentorsById[(string)$this->getId()]);
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Teacher
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Teacher Associations
private $myStudents;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->myStudents = array();
}
//------------------------
// INTERFACE
//------------------------
public function getMyStudent_index($index)
{
$aMyStudent = $this->myStudents[$index];
return $aMyStudent;
}
public function getMyStudents()
{
$newMyStudents = $this->myStudents;
return $newMyStudents;
}
public function numberOfMyStudents()
{
$number = count($this->myStudents);
return $number;
}
public function hasMyStudents()
{
$has = $this->numberOfMyStudents() > 0;
return $has;
}
public function indexOfMyStudent($aMyStudent)
{
$wasFound = false;
$index = 0;
foreach($this->myStudents as $myStudent)
{
if ($myStudent->equals($aMyStudent))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public static function minimumNumberOfMyStudents()
{
return 0;
}
public function addMyStudentVia()
{
return new Person($this);
}
public function addMyStudent($aMyStudent)
{
$wasAdded = false;
if ($this->indexOfMyStudent($aMyStudent) !== -1) { return false; }
$existingTeacher = $aMyStudent->getTeacher();
$isNewTeacher = $existingTeacher != null && $this !== $existingTeacher;
if ($isNewTeacher)
{
$aMyStudent->setTeacher($this);
}
else
{
$this->myStudents[] = $aMyStudent;
}
$wasAdded = true;
return $wasAdded;
}
public function removeMyStudent($aMyStudent)
{
$wasRemoved = false;
//Unable to remove aMyStudent, as it must always have a teacher
if ($this !== $aMyStudent->getTeacher())
{
unset($this->myStudents[$this->indexOfMyStudent($aMyStudent)]);
$this->myStudents = array_values($this->myStudents);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addMyStudentAt($aMyStudent, $index)
{
$wasAdded = false;
if($this->addMyStudent($aMyStudent))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfMyStudents()) { $index = $this->numberOfMyStudents() - 1; }
array_splice($this->myStudents, $this->indexOfMyStudent($aMyStudent), 1);
array_splice($this->myStudents, $index, 0, array($aMyStudent));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveMyStudentAt($aMyStudent, $index)
{
$wasAdded = false;
if($this->indexOfMyStudent($aMyStudent) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfMyStudents()) { $index = $this->numberOfMyStudents() - 1; }
array_splice($this->myStudents, $this->indexOfMyStudent($aMyStudent), 1);
array_splice($this->myStudents, $index, 0, array($aMyStudent));
$wasAdded = true;
}
else
{
$wasAdded = $this->addMyStudentAt($aMyStudent, $index);
}
return $wasAdded;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
foreach ($this->myStudents as $aMyStudent)
{
$aMyStudent->delete();
}
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Registration
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Registration Attributes
private $grade;
//Registration Associations
private $student;
private $courseSection;
//Helper Variables
private $cachedHashCode;
private $canSetStudent;
private $canSetCourseSection;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aGrade, $aStudent, $aCourseSection)
{
$this->cachedHashCode = -1;
$this->canSetStudent = true;
$this->canSetCourseSection = true;
$this->grade = $aGrade;
$didAddStudent = $this->setStudent($aStudent);
if (!$didAddStudent)
{
throw new Exception("Unable to create registration due to student. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
}
$didAddCourseSection = $this->setCourseSection($aCourseSection);
if (!$didAddCourseSection)
{
throw new Exception("Unable to create registration due to courseSection. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
}
}
//------------------------
// INTERFACE
//------------------------
public function setGrade($aGrade)
{
$wasSet = false;
$this->grade = $aGrade;
$wasSet = true;
return $wasSet;
}
public function getGrade()
{
return $this->grade;
}
public function getStudent()
{
return $this->student;
}
public function getCourseSection()
{
return $this->courseSection;
}
public function setStudent($aStudent)
{
$wasSet = false;
if (!$this->canSetStudent) { return false; }
if ($aStudent === NULL)
{
return wasSet;
}
$existingStudent = $this->student;
$this->student = $aStudent;
if (!$existingStudent->is_null() && !$existingStudent->equals($aStudent))
{
$existingStudent->removeRegistration($this);
}
if (!$this->student->addRegistration($this))
{
$this->student = $existingStudent;
$wasSet = false;
}
else
{
$wasSet = true;
}
return $wasSet;
}
public function setCourseSection($aCourseSection)
{
$wasSet = false;
if (!$this->canSetCourseSection) { return false; }
if ($aCourseSection === NULL)
{
return wasSet;
}
$existingCourseSection = $this->courseSection;
$this->courseSection = $aCourseSection;
if (!$existingCourseSection->is_null() && !$existingCourseSection->equals($aCourseSection))
{
$existingCourseSection->removeRegistration($this);
}
if (!$this->courseSection->addRegistration($this))
{
$this->courseSection = $existingCourseSection;
$wasSet = false;
}
else
{
$wasSet = true;
}
return $wasSet;
}
public function equals($compareTo)
{
if ($compareTo == null) { return false; }
if (get_class($this) != get_class($compareTo)) { return false; }
if ($this->student != $compareTo->student)
{
return false;
}
if ($this->courseSection != $compareTo->courseSection)
{
return false;
}
return true;
}
public function hashCode()
{
if ($this->cachedHashCode != -1)
{
return $this->cachedHashCode;
}
$this->cachedHashCode = 17;
if ($this->student != null)
{
$this->cachedHashCode = $this->cachedHashCode * 23 + spl_object_hash($this->student);
}
else
{
$this->cachedHashCode = $this->cachedHashCode * 23;
}
if ($this->courseSection != null)
{
$this->cachedHashCode = $this->cachedHashCode * 23 + spl_object_hash($this->courseSection);
}
else
{
$this->cachedHashCode = $this->cachedHashCode * 23;
}
$this->canSetStudent = false;
$this->canSetCourseSection = false;
return $this->cachedHashCode;
}
public function delete()
{
$placeholderStudent = $this->student;
$this->student = null;
$placeholderStudent->removeRegistration($this);
$placeholderCourseSection = $this->courseSection;
$this->courseSection = null;
$placeholderCourseSection->removeRegistration($this);
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Registration
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Registration Attributes
private $grade;
//Registration Associations
private $student;
private $courseSection;
//Helper Variables
private $cachedHashCode;
private $canSetStudent;
private $canSetCourseSection;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aGrade, $aStudent, $aCourseSection)
{
$this->cachedHashCode = -1;
$this->canSetStudent = true;
$this->canSetCourseSection = true;
$this->grade = $aGrade;
$didAddStudent = $this->setStudent($aStudent);
if (!$didAddStudent)
{
throw new Exception("Unable to create registration due to student. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
}
$didAddCourseSection = $this->setCourseSection($aCourseSection);
if (!$didAddCourseSection)
{
throw new Exception("Unable to create registration due to courseSection. See https://manual.umple.org?RE002ViolationofAssociationMultiplicity.html");
}
}
//------------------------
// INTERFACE
//------------------------
public function setGrade($aGrade)
{
$wasSet = false;
$this->grade = $aGrade;
$wasSet = true;
return $wasSet;
}
public function getGrade()
{
return $this->grade;
}
public function getStudent()
{
return $this->student;
}
public function getCourseSection()
{
return $this->courseSection;
}
public function setStudent($aStudent)
{
$wasSet = false;
if (!$this->canSetStudent) { return false; }
if ($aStudent === NULL)
{
return wasSet;
}
$existingStudent = $this->student;
$this->student = $aStudent;
if (!$existingStudent->is_null() && !$existingStudent->equals($aStudent))
{
$existingStudent->removeRegistration($this);
}
if (!$this->student->addRegistration($this))
{
$this->student = $existingStudent;
$wasSet = false;
}
else
{
$wasSet = true;
}
return $wasSet;
}
public function setCourseSection($aCourseSection)
{
$wasSet = false;
if (!$this->canSetCourseSection) { return false; }
if ($aCourseSection === NULL)
{
return wasSet;
}
$existingCourseSection = $this->courseSection;
$this->courseSection = $aCourseSection;
if (!$existingCourseSection->is_null() && !$existingCourseSection->equals($aCourseSection))
{
$existingCourseSection->removeRegistration($this);
}
if (!$this->courseSection->addRegistration($this))
{
$this->courseSection = $existingCourseSection;
$wasSet = false;
}
else
{
$wasSet = true;
}
return $wasSet;
}
public function equals($compareTo)
{
if ($compareTo == null) { return false; }
if (get_class($this) != get_class($compareTo)) { return false; }
if ($this->student != $compareTo->student)
{
return false;
}
if ($this->courseSection != $compareTo->courseSection)
{
return false;
}
return true;
}
public function hashCode()
{
if ($this->cachedHashCode != -1)
{
return $this->cachedHashCode;
}
$this->cachedHashCode = 17;
if ($this->student != null)
{
$this->cachedHashCode = $this->cachedHashCode * 23 + spl_object_hash($this->student);
}
else
{
$this->cachedHashCode = $this->cachedHashCode * 23;
}
if ($this->courseSection != null)
{
$this->cachedHashCode = $this->cachedHashCode * 23 + spl_object_hash($this->courseSection);
}
else
{
$this->cachedHashCode = $this->cachedHashCode * 23;
}
$this->canSetStudent = false;
$this->canSetCourseSection = false;
return $this->cachedHashCode;
}
public function delete()
{
$placeholderStudent = $this->student;
$this->student = null;
$placeholderStudent->removeRegistration($this);
$placeholderCourseSection = $this->courseSection;
$this->courseSection = null;
$placeholderCourseSection->removeRegistration($this);
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Attributes
private $someStrings;
private $numbers;
private $objects;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->someStrings = array("a","b","c");
$this->numbers = array(1,2,3,10);
$this->objects = array(new Token("first"),new Token("second"));
}
//------------------------
// INTERFACE
//------------------------
public function addSomeString($aSomeString)
{
$wasAdded = false;
$this->someStrings[] = $aSomeString;
$wasAdded = true;
return $wasAdded;
}
public function removeSomeString($aSomeString)
{
$wasRemoved = false;
unset($this->someStrings[$this->indexOfSomeString($aSomeString)]);
$this->someStrings = array_values($this->someStrings);
$wasRemoved = true;
return $wasRemoved;
}
public function addNumber($aNumber)
{
$wasAdded = false;
$this->numbers[] = $aNumber;
$wasAdded = true;
return $wasAdded;
}
public function removeNumber($aNumber)
{
$wasRemoved = false;
unset($this->numbers[$this->indexOfNumber($aNumber)]);
$this->numbers = array_values($this->numbers);
$wasRemoved = true;
return $wasRemoved;
}
public function addObject($aObject)
{
$wasAdded = false;
$this->objects[] = $aObject;
$wasAdded = true;
return $wasAdded;
}
public function removeObject($aObject)
{
$wasRemoved = false;
unset($this->objects[$this->indexOfObject($aObject)]);
$this->objects = array_values($this->objects);
$wasRemoved = true;
return $wasRemoved;
}
public function getSomeString($index)
{
$aSomeString = $this->someStrings[$index];
return $aSomeString;
}
public function getSomeStrings()
{
$newSomeStrings = $this->someStrings;
return $newSomeStrings;
}
public function numberOfSomeStrings()
{
$number = count($this->someStrings);
return $number;
}
public function hasSomeStrings()
{
$has = someStrings.size() > 0;
return $has;
}
public function indexOfSomeString($aSomeString)
{
$rawAnswer = array_search($aSomeString,$this->someStrings);
$index = $rawAnswer == null && $rawAnswer !== 0 ? -1 : $rawAnswer;
return $index;
}
public function getNumber($index)
{
$aNumber = $this->numbers[$index];
return $aNumber;
}
public function getNumbers()
{
$newNumbers = $this->numbers;
return $newNumbers;
}
public function numberOfNumbers()
{
$number = count($this->numbers);
return $number;
}
public function hasNumbers()
{
$has = numbers.size() > 0;
return $has;
}
public function indexOfNumber($aNumber)
{
$rawAnswer = array_search($aNumber,$this->numbers);
$index = $rawAnswer == null && $rawAnswer !== 0 ? -1 : $rawAnswer;
return $index;
}
public function getObject($index)
{
$aObject = $this->objects[$index];
return $aObject;
}
public function getObjects()
{
$newObjects = $this->objects;
return $newObjects;
}
public function numberOfObjects()
{
$number = count($this->objects);
return $number;
}
public function hasObjects()
{
$has = objects.size() > 0;
return $has;
}
public function indexOfObject($aObject)
{
$rawAnswer = array_search($aObject,$this->objects);
$index = $rawAnswer == null && $rawAnswer !== 0 ? -1 : $rawAnswer;
return $index;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
// This is a student
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Associations
/**
* I am a multiline comment above an association.
*/
private $bars;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->bars = array();
}
//------------------------
// INTERFACE
//------------------------
public function getBar_index($index)
{
$aBar = $this->bars[$index];
return $aBar;
}
public function getBars()
{
$newBars = $this->bars;
return $newBars;
}
public function numberOfBars()
{
$number = count($this->bars);
return $number;
}
public function hasBars()
{
$has = $this->numberOfBars() > 0;
return $has;
}
public function indexOfBar($aBar)
{
$wasFound = false;
$index = 0;
foreach($this->bars as $bar)
{
if ($bar->equals($aBar))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public static function minimumNumberOfBars()
{
return 0;
}
public function addBarVia()
{
return new Bar($this);
}
public function addBar($aBar)
{
$wasAdded = false;
if ($this->indexOfBar($aBar) !== -1) { return false; }
$existingFoo = $aBar->getFoo();
$isNewFoo = $existingFoo != null && $this !== $existingFoo;
if ($isNewFoo)
{
$aBar->setFoo($this);
}
else
{
$this->bars[] = $aBar;
}
$wasAdded = true;
return $wasAdded;
}
public function removeBar($aBar)
{
$wasRemoved = false;
//Unable to remove aBar, as it must always have a foo
if ($this !== $aBar->getFoo())
{
unset($this->bars[$this->indexOfBar($aBar)]);
$this->bars = array_values($this->bars);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addBarAt($aBar, $index)
{
$wasAdded = false;
if($this->addBar($aBar))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBars()) { $index = $this->numberOfBars() - 1; }
array_splice($this->bars, $this->indexOfBar($aBar), 1);
array_splice($this->bars, $index, 0, array($aBar));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveBarAt($aBar, $index)
{
$wasAdded = false;
if($this->indexOfBar($aBar) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBars()) { $index = $this->numberOfBars() - 1; }
array_splice($this->bars, $this->indexOfBar($aBar), 1);
array_splice($this->bars, $index, 0, array($aBar));
$wasAdded = true;
}
else
{
$wasAdded = $this->addBarAt($aBar, $index);
}
return $wasAdded;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
foreach ($this->bars as $aBar)
{
$aBar->delete();
}
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Student Attributes
private $grade;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->grade = "";
}
//------------------------
// INTERFACE
//------------------------
public function setGrade($aGrade)
{
$wasSet = false;
$this->grade = $aGrade;
$wasSet = true;
return $wasSet;
}
public function getGrade()
{
return $this->grade;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Token
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Token Attributes
private $p;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aP)
{
$this->p = $aP;
}
//------------------------
// INTERFACE
//------------------------
public function setP($aP)
{
$wasSet = false;
$this->p = $aP;
$wasSet = true;
return $wasSet;
}
public function getP()
{
return $this->p;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
// This is a student
// Multiple comments
// on several lines
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
abstract class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
/*
* I am a class comment.
*
* Notice how there are 4 empty lines below me.
*
*
*
*
* And 2 below me.
*
*
* These lines should come out as we see here.
* Comments such as these are often used to improve readability through whitespace clarity.
*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Attributes
/**
* I am a multiline comment above an attribute.
*/
private $name;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aName)
{
$this->name = $aName;
}
//------------------------
// INTERFACE
//------------------------
public function setName($aName)
{
$wasSet = false;
$this->name = $aName;
$wasSet = true;
return $wasSet;
}
public function getName()
{
return $this->name;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Token
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Attributes
/**
* Inline comment above attribute.
*/
private $testAttribute1;
/**
* Multiple inline comments
* above attribute.
*/
private $testAttribute2;
/**
* Multiline comment above attribute.
*/
private $testAttribute3;
/**
* Multiple multiline comments
* above attribute.
*/
private $testAttribute4;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aTestAttribute1, $aTestAttribute2, $aTestAttribute3, $aTestAttribute4)
{
$this->testAttribute1 = $aTestAttribute1;
$this->testAttribute2 = $aTestAttribute2;
$this->testAttribute3 = $aTestAttribute3;
$this->testAttribute4 = $aTestAttribute4;
}
//------------------------
// INTERFACE
//------------------------
public function setTestAttribute1($aTestAttribute1)
{
$wasSet = false;
$this->testAttribute1 = $aTestAttribute1;
$wasSet = true;
return $wasSet;
}
public function setTestAttribute2($aTestAttribute2)
{
$wasSet = false;
$this->testAttribute2 = $aTestAttribute2;
$wasSet = true;
return $wasSet;
}
public function setTestAttribute3($aTestAttribute3)
{
$wasSet = false;
$this->testAttribute3 = $aTestAttribute3;
$wasSet = true;
return $wasSet;
}
public function setTestAttribute4($aTestAttribute4)
{
$wasSet = false;
$this->testAttribute4 = $aTestAttribute4;
$wasSet = true;
return $wasSet;
}
public function getTestAttribute1()
{
return $this->testAttribute1;
}
public function getTestAttribute2()
{
return $this->testAttribute2;
}
public function getTestAttribute3()
{
return $this->testAttribute3;
}
public function getTestAttribute4()
{
return $this->testAttribute4;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class SubMentor extends Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aName)
{
parent::__construct($aName);
}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
parent::delete();
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class SubMentor2 extends Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//SubMentor2 Attributes
private $subName;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aName, $aSubName)
{
parent::__construct($aName);
$this->subName = $aSubName;
}
//------------------------
// INTERFACE
//------------------------
public function setSubName($aSubName)
{
$wasSet = false;
$this->subName = $aSubName;
$wasSet = true;
return $wasSet;
}
public function getSubName()
{
return $this->subName;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
parent::delete();
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Token
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Token Attributes
private $positions;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->positions = array();
}
//------------------------
// INTERFACE
//------------------------
public function addPosition($aPosition)
{
$wasAdded = false;
$this->positions[] = $aPosition;
$wasAdded = true;
return $wasAdded;
}
public function removePosition($aPosition)
{
$wasRemoved = false;
unset($this->positions[$this->indexOfPosition($aPosition)]);
$this->positions = array_values($this->positions);
$wasRemoved = true;
return $wasRemoved;
}
public function getPosition($index)
{
$aPosition = $this->positions[$index];
return $aPosition;
}
public function getPositions()
{
$newPositions = $this->positions;
return $newPositions;
}
public function numberOfPositions()
{
$number = count($this->positions);
return $number;
}
public function hasPositions()
{
$has = positions.size() > 0;
return $has;
}
public function indexOfPosition($aPosition)
{
$rawAnswer = array_search($aPosition,$this->positions);
$index = $rawAnswer == null && $rawAnswer !== 0 ? -1 : $rawAnswer;
return $index;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function foo(int $a)
{
// line 26 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
System.out.println("Starting foo...");
// END OF UMPLE BEFORE INJECTION
// line 38 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
System.out.println("Starting execution...");
// END OF UMPLE BEFORE INJECTION
if(a < 0) {
return 4;
}
return 3;
}
public function foo(int $a, $b)
{
// line 26 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
System.out.println("Starting foo...");
// END OF UMPLE BEFORE INJECTION
if(a > 0 && "".equals(b)) {
// line 30 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
System.out.println("Returning from foo, a: " + a ", b: " + b);
// END OF UMPLE AFTER INJECTION
return 3;
}
// line 30 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
System.out.println("Returning from foo, a: " + a ", b: " + b);
// END OF UMPLE AFTER INJECTION
return 1;
}
public function bar()
{
// line 34 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
// TODO: fix asap
// END OF UMPLE BEFORE INJECTION
// line 38 "ClassTemplateTest_CodeInjectionsParametersMulti.ump"
System.out.println("Starting execution...");
// END OF UMPLE BEFORE INJECTION
int a = 4;
if(a == 3) return 2;
return 1;
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function foo(int $a)
{
// line 18 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
System.out.println("Starting foo with argument: " + a);
// END OF UMPLE BEFORE INJECTION
if(a < 0) {
// line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return 0;
}
else if(a == 1) {
// line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return -1;
}
else {
// line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return 4;
}
for(int i = 0; i < a; i++)
if(i == a/4) {
// line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return a;
}
// line 22 "ClassTemplateTest_CodeInjectionsNoBraces.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return 4;
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Application
{
//------------------------
// STATIC VARIABLES
//------------------------
private static $theInstance = null;
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
private function __construct()
{}
public static function getInstance()
{
if(self::$theInstance == null)
{
self::$theInstance = new Application();
}
return self::$theInstance;
}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
/**
* I am a method comment.
*
* Notice how there are 4 empty lines below me.
*
*
*
*
* And 2 below me.
*
*
* These lines should come out as we see here.
* Comments such as these are often used to improve readability through whitespace clarity.
*/
public function testMethod()
{
// I am a test method.
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Teacher extends Person
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Teacher Attributes
private $position;
//Teacher Associations
private $students;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aName, $aAge, $aPosition)
{
parent::__construct($aName, $aAge);
$this->position = $aPosition;
$this->students = array();
}
//------------------------
// INTERFACE
//------------------------
public function setPosition($aPosition)
{
$wasSet = false;
$this->position = $aPosition;
$wasSet = true;
return $wasSet;
}
public function getPosition()
{
return $this->position;
}
public function getStudent_index($index)
{
$aStudent = $this->students[$index];
return $aStudent;
}
public function getStudents()
{
$newStudents = $this->students;
return $newStudents;
}
public function numberOfStudents()
{
$number = count($this->students);
return $number;
}
public function hasStudents()
{
$has = $this->numberOfStudents() > 0;
return $has;
}
public function indexOfStudent($aStudent)
{
$wasFound = false;
$index = 0;
foreach($this->students as $student)
{
if ($student->equals($aStudent))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public static function minimumNumberOfStudents()
{
return 0;
}
public function addStudentVia($aName, $aAge, $aStudentID)
{
return new Student($aName, $aAge, $aStudentID, $this);
}
public function addStudent($aStudent)
{
$wasAdded = false;
if ($this->indexOfStudent($aStudent) !== -1) { return false; }
$existingTeacher = $aStudent->getTeacher();
$isNewTeacher = $existingTeacher != null && $this !== $existingTeacher;
if ($isNewTeacher)
{
$aStudent->setTeacher($this);
}
else
{
$this->students[] = $aStudent;
}
$wasAdded = true;
return $wasAdded;
}
public function removeStudent($aStudent)
{
$wasRemoved = false;
//Unable to remove aStudent, as it must always have a teacher
if ($this !== $aStudent->getTeacher())
{
unset($this->students[$this->indexOfStudent($aStudent)]);
$this->students = array_values($this->students);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addStudentAt($aStudent, $index)
{
$wasAdded = false;
if($this->addStudent($aStudent))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfStudents()) { $index = $this->numberOfStudents() - 1; }
array_splice($this->students, $this->indexOfStudent($aStudent), 1);
array_splice($this->students, $index, 0, array($aStudent));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveStudentAt($aStudent, $index)
{
$wasAdded = false;
if($this->indexOfStudent($aStudent) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfStudents()) { $index = $this->numberOfStudents() - 1; }
array_splice($this->students, $this->indexOfStudent($aStudent), 1);
array_splice($this->students, $index, 0, array($aStudent));
$wasAdded = true;
}
else
{
$wasAdded = $this->addStudentAt($aStudent, $index);
}
return $wasAdded;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
foreach ($this->students as $aStudent)
{
$aStudent->delete();
}
parent::delete();
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Student Attributes
private $number;
private $number2;
//Helper Variables
private $canSetNumber2;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aNumber)
{
$this->number = $aNumber;
$this->canSetNumber2 = true;
}
//------------------------
// INTERFACE
//------------------------
public function setNumber2($aNumber2)
{
$wasSet = false;
if (!$this->canSetNumber2) { return false; }
$this->canSetNumber2 = false;
$this->number2 = $aNumber2;
$wasSet = true;
return $wasSet;
}
public function getNumber()
{
return $this->number;
}
public function getNumber2()
{
return $this->number2;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
public function foo(int $a)
{
// line 35 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
// END OF UMPLE BEFORE INJECTION
// line 38 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
System.out.println("Starting foo with argument: " + a);
// END OF UMPLE BEFORE INJECTION
if ($a < 0) {
// line 43 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
// END OF UMPLE AFTER INJECTION
// line 46 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return 0;
} else if ($a == 1) {
// line 43 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
// END OF UMPLE AFTER INJECTION
// line 46 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return -1;
} else {
// line 43 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
// END OF UMPLE AFTER INJECTION
// line 46 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return 4;
}
for ($i = 0; $i < $a; $i++) {
// TODO: call foo()
if ($i == $a / 4) {
// line 43 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
// END OF UMPLE AFTER INJECTION
// line 46 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return $a;
}
}
// line 43 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
// END OF UMPLE AFTER INJECTION
// line 46 "ClassTemplateTest_CodeInjectionsSingleLine.ump"
System.out.println("Returning from foo!");
// END OF UMPLE AFTER INJECTION
return 4;
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Student
{
//------------------------
// STATIC VARIABLES
//------------------------
public static $a = "";
//------------------------
// MEMBER VARIABLES
//------------------------
//Student Attributes
/**
* Comment for an internal attribute
*/
private $b;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aB)
{
$this->b = $aB;
}
//------------------------
// INTERFACE
//------------------------
public function getC()
{
return 1+1;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
/*
This is a student
Multiple comments
on several lines
*/
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Associations
/**
* I am a inline comment above an association.
*/
private $bars;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->bars = array();
}
//------------------------
// INTERFACE
//------------------------
public function getBar_index($index)
{
$aBar = $this->bars[$index];
return $aBar;
}
public function getBars()
{
$newBars = $this->bars;
return $newBars;
}
public function numberOfBars()
{
$number = count($this->bars);
return $number;
}
public function hasBars()
{
$has = $this->numberOfBars() > 0;
return $has;
}
public function indexOfBar($aBar)
{
$wasFound = false;
$index = 0;
foreach($this->bars as $bar)
{
if ($bar->equals($aBar))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public static function minimumNumberOfBars()
{
return 0;
}
public function addBarVia()
{
return new Bar($this);
}
public function addBar($aBar)
{
$wasAdded = false;
if ($this->indexOfBar($aBar) !== -1) { return false; }
$existingFoo = $aBar->getFoo();
$isNewFoo = $existingFoo != null && $this !== $existingFoo;
if ($isNewFoo)
{
$aBar->setFoo($this);
}
else
{
$this->bars[] = $aBar;
}
$wasAdded = true;
return $wasAdded;
}
public function removeBar($aBar)
{
$wasRemoved = false;
//Unable to remove aBar, as it must always have a foo
if ($this !== $aBar->getFoo())
{
unset($this->bars[$this->indexOfBar($aBar)]);
$this->bars = array_values($this->bars);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addBarAt($aBar, $index)
{
$wasAdded = false;
if($this->addBar($aBar))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBars()) { $index = $this->numberOfBars() - 1; }
array_splice($this->bars, $this->indexOfBar($aBar), 1);
array_splice($this->bars, $index, 0, array($aBar));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveBarAt($aBar, $index)
{
$wasAdded = false;
if($this->indexOfBar($aBar) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBars()) { $index = $this->numberOfBars() - 1; }
array_splice($this->bars, $this->indexOfBar($aBar), 1);
array_splice($this->bars, $index, 0, array($aBar));
$wasAdded = true;
}
else
{
$wasAdded = $this->addBarAt($aBar, $index);
}
return $wasAdded;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
foreach ($this->bars as $aBar)
{
$aBar->delete();
}
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
// This is a student
class Student
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
/**
* Inline comment above method.
*/
public function testMethod1()
{
// I am a comment inside a method.
}
/**
* Multiple inline comments
* above method.
*/
public function testMethod2()
{
// I am a comment inside a method.
}
/**
* Multiline comment above method.
*/
public function testMethod3()
{
// I am a comment inside a method.
}
/**
* Multiple multiline comments
* above method.
*/
public function testMethod4()
{
// I am a comment inside a method.
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Associations
/**
* Inline comment above association.
*/
private $bar1s;
/**
* Multiple inline comments
* above association.
*/
private $bar2s;
/**
* Multiline comment above association.
*/
private $bar3s;
/**
* Multiple multiline comments
* above association.
*/
private $bar4s;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->bar1s = array();
$this->bar2s = array();
$this->bar3s = array();
$this->bar4s = array();
}
//------------------------
// INTERFACE
//------------------------
public function getBar1_index($index)
{
$aBar1 = $this->bar1s[$index];
return $aBar1;
}
public function getBar1s()
{
$newBar1s = $this->bar1s;
return $newBar1s;
}
public function numberOfBar1s()
{
$number = count($this->bar1s);
return $number;
}
public function hasBar1s()
{
$has = $this->numberOfBar1s() > 0;
return $has;
}
public function indexOfBar1($aBar1)
{
$wasFound = false;
$index = 0;
foreach($this->bar1s as $bar1)
{
if ($bar1->equals($aBar1))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public function getBar2_index($index)
{
$aBar2 = $this->bar2s[$index];
return $aBar2;
}
public function getBar2s()
{
$newBar2s = $this->bar2s;
return $newBar2s;
}
public function numberOfBar2s()
{
$number = count($this->bar2s);
return $number;
}
public function hasBar2s()
{
$has = $this->numberOfBar2s() > 0;
return $has;
}
public function indexOfBar2($aBar2)
{
$wasFound = false;
$index = 0;
foreach($this->bar2s as $bar2)
{
if ($bar2->equals($aBar2))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public function getBar3_index($index)
{
$aBar3 = $this->bar3s[$index];
return $aBar3;
}
public function getBar3s()
{
$newBar3s = $this->bar3s;
return $newBar3s;
}
public function numberOfBar3s()
{
$number = count($this->bar3s);
return $number;
}
public function hasBar3s()
{
$has = $this->numberOfBar3s() > 0;
return $has;
}
public function indexOfBar3($aBar3)
{
$wasFound = false;
$index = 0;
foreach($this->bar3s as $bar3)
{
if ($bar3->equals($aBar3))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public function getBar4_index($index)
{
$aBar4 = $this->bar4s[$index];
return $aBar4;
}
public function getBar4s()
{
$newBar4s = $this->bar4s;
return $newBar4s;
}
public function numberOfBar4s()
{
$number = count($this->bar4s);
return $number;
}
public function hasBar4s()
{
$has = $this->numberOfBar4s() > 0;
return $has;
}
public function indexOfBar4($aBar4)
{
$wasFound = false;
$index = 0;
foreach($this->bar4s as $bar4)
{
if ($bar4->equals($aBar4))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public static function minimumNumberOfBar1s()
{
return 0;
}
public function addBar1Via()
{
return new Bar1($this);
}
public function addBar1($aBar1)
{
$wasAdded = false;
if ($this->indexOfBar1($aBar1) !== -1) { return false; }
$existingFoo = $aBar1->getFoo();
$isNewFoo = $existingFoo != null && $this !== $existingFoo;
if ($isNewFoo)
{
$aBar1->setFoo($this);
}
else
{
$this->bar1s[] = $aBar1;
}
$wasAdded = true;
return $wasAdded;
}
public function removeBar1($aBar1)
{
$wasRemoved = false;
//Unable to remove aBar1, as it must always have a foo
if ($this !== $aBar1->getFoo())
{
unset($this->bar1s[$this->indexOfBar1($aBar1)]);
$this->bar1s = array_values($this->bar1s);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addBar1At($aBar1, $index)
{
$wasAdded = false;
if($this->addBar1($aBar1))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar1s()) { $index = $this->numberOfBar1s() - 1; }
array_splice($this->bar1s, $this->indexOfBar1($aBar1), 1);
array_splice($this->bar1s, $index, 0, array($aBar1));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveBar1At($aBar1, $index)
{
$wasAdded = false;
if($this->indexOfBar1($aBar1) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar1s()) { $index = $this->numberOfBar1s() - 1; }
array_splice($this->bar1s, $this->indexOfBar1($aBar1), 1);
array_splice($this->bar1s, $index, 0, array($aBar1));
$wasAdded = true;
}
else
{
$wasAdded = $this->addBar1At($aBar1, $index);
}
return $wasAdded;
}
public static function minimumNumberOfBar2s()
{
return 0;
}
public function addBar2Via()
{
return new Bar2($this);
}
public function addBar2($aBar2)
{
$wasAdded = false;
if ($this->indexOfBar2($aBar2) !== -1) { return false; }
$existingFoo = $aBar2->getFoo();
$isNewFoo = $existingFoo != null && $this !== $existingFoo;
if ($isNewFoo)
{
$aBar2->setFoo($this);
}
else
{
$this->bar2s[] = $aBar2;
}
$wasAdded = true;
return $wasAdded;
}
public function removeBar2($aBar2)
{
$wasRemoved = false;
//Unable to remove aBar2, as it must always have a foo
if ($this !== $aBar2->getFoo())
{
unset($this->bar2s[$this->indexOfBar2($aBar2)]);
$this->bar2s = array_values($this->bar2s);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addBar2At($aBar2, $index)
{
$wasAdded = false;
if($this->addBar2($aBar2))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar2s()) { $index = $this->numberOfBar2s() - 1; }
array_splice($this->bar2s, $this->indexOfBar2($aBar2), 1);
array_splice($this->bar2s, $index, 0, array($aBar2));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveBar2At($aBar2, $index)
{
$wasAdded = false;
if($this->indexOfBar2($aBar2) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar2s()) { $index = $this->numberOfBar2s() - 1; }
array_splice($this->bar2s, $this->indexOfBar2($aBar2), 1);
array_splice($this->bar2s, $index, 0, array($aBar2));
$wasAdded = true;
}
else
{
$wasAdded = $this->addBar2At($aBar2, $index);
}
return $wasAdded;
}
public static function minimumNumberOfBar3s()
{
return 0;
}
public function addBar3Via()
{
return new Bar3($this);
}
public function addBar3($aBar3)
{
$wasAdded = false;
if ($this->indexOfBar3($aBar3) !== -1) { return false; }
$existingFoo = $aBar3->getFoo();
$isNewFoo = $existingFoo != null && $this !== $existingFoo;
if ($isNewFoo)
{
$aBar3->setFoo($this);
}
else
{
$this->bar3s[] = $aBar3;
}
$wasAdded = true;
return $wasAdded;
}
public function removeBar3($aBar3)
{
$wasRemoved = false;
//Unable to remove aBar3, as it must always have a foo
if ($this !== $aBar3->getFoo())
{
unset($this->bar3s[$this->indexOfBar3($aBar3)]);
$this->bar3s = array_values($this->bar3s);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addBar3At($aBar3, $index)
{
$wasAdded = false;
if($this->addBar3($aBar3))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar3s()) { $index = $this->numberOfBar3s() - 1; }
array_splice($this->bar3s, $this->indexOfBar3($aBar3), 1);
array_splice($this->bar3s, $index, 0, array($aBar3));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveBar3At($aBar3, $index)
{
$wasAdded = false;
if($this->indexOfBar3($aBar3) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar3s()) { $index = $this->numberOfBar3s() - 1; }
array_splice($this->bar3s, $this->indexOfBar3($aBar3), 1);
array_splice($this->bar3s, $index, 0, array($aBar3));
$wasAdded = true;
}
else
{
$wasAdded = $this->addBar3At($aBar3, $index);
}
return $wasAdded;
}
public static function minimumNumberOfBar4s()
{
return 0;
}
public function addBar4Via()
{
return new Bar4($this);
}
public function addBar4($aBar4)
{
$wasAdded = false;
if ($this->indexOfBar4($aBar4) !== -1) { return false; }
$existingFoo = $aBar4->getFoo();
$isNewFoo = $existingFoo != null && $this !== $existingFoo;
if ($isNewFoo)
{
$aBar4->setFoo($this);
}
else
{
$this->bar4s[] = $aBar4;
}
$wasAdded = true;
return $wasAdded;
}
public function removeBar4($aBar4)
{
$wasRemoved = false;
//Unable to remove aBar4, as it must always have a foo
if ($this !== $aBar4->getFoo())
{
unset($this->bar4s[$this->indexOfBar4($aBar4)]);
$this->bar4s = array_values($this->bar4s);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addBar4At($aBar4, $index)
{
$wasAdded = false;
if($this->addBar4($aBar4))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar4s()) { $index = $this->numberOfBar4s() - 1; }
array_splice($this->bar4s, $this->indexOfBar4($aBar4), 1);
array_splice($this->bar4s, $index, 0, array($aBar4));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveBar4At($aBar4, $index)
{
$wasAdded = false;
if($this->indexOfBar4($aBar4) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfBar4s()) { $index = $this->numberOfBar4s() - 1; }
array_splice($this->bar4s, $this->indexOfBar4($aBar4), 1);
array_splice($this->bar4s, $index, 0, array($aBar4));
$wasAdded = true;
}
else
{
$wasAdded = $this->addBar4At($aBar4, $index);
}
return $wasAdded;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
foreach ($this->bar1s as $aBar1)
{
$aBar1->delete();
}
foreach ($this->bar2s as $aBar2)
{
$aBar2->delete();
}
foreach ($this->bar3s as $aBar3)
{
$aBar3->delete();
}
foreach ($this->bar4s as $aBar4)
{
$aBar4->delete();
}
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
/**
* I am a comment above a method.
*/
public function testMethod()
{
// I am a comment inside a method.
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Teacher
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Teacher Associations
private $myFooss;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{
$this->myFooss = array();
}
//------------------------
// INTERFACE
//------------------------
public function getMyFooss_index($index)
{
$aMyFooss = $this->myFooss[$index];
return $aMyFooss;
}
public function getMyFooss()
{
$newMyFooss = $this->myFooss;
return $newMyFooss;
}
public function numberOfMyFooss()
{
$number = count($this->myFooss);
return $number;
}
public function hasMyFooss()
{
$has = $this->numberOfMyFooss() > 0;
return $has;
}
public function indexOfMyFooss($aMyFooss)
{
$wasFound = false;
$index = 0;
foreach($this->myFooss as $myFooss)
{
if ($myFooss->equals($aMyFooss))
{
$wasFound = true;
break;
}
$index += 1;
}
$index = $wasFound ? $index : -1;
return $index;
}
public static function minimumNumberOfMyFooss()
{
return 0;
}
public static function maximumNumberOfMyFooss()
{
return 2;
}
public function addMyFoossVia()
{
if ($this->numberOfMyFooss() >= self::maximumNumberOfMyFooss())
{
return null;
}
else
{
return new Foo($this);
}
}
public function addMyFooss($aMyFooss)
{
$wasAdded = false;
if ($this->indexOfMyFooss($aMyFooss) !== -1) { return false; }
if ($this->numberOfMyFooss() >= self::maximumNumberOfMyFooss())
{
return $wasAdded;
}
$existingTeacher = $aMyFooss->getTeacher();
$isNewTeacher = $existingTeacher != null && $this !== $existingTeacher;
if ($isNewTeacher)
{
$aMyFooss->setTeacher($this);
}
else
{
$this->myFooss[] = $aMyFooss;
}
$wasAdded = true;
return $wasAdded;
}
public function removeMyFooss($aMyFooss)
{
$wasRemoved = false;
//Unable to remove aMyFooss, as it must always have a teacher
if ($this !== $aMyFooss->getTeacher())
{
unset($this->myFooss[$this->indexOfMyFooss($aMyFooss)]);
$this->myFooss = array_values($this->myFooss);
$wasRemoved = true;
}
return $wasRemoved;
}
public function addMyFoossAt($aMyFooss, $index)
{
$wasAdded = false;
if($this->addMyFooss($aMyFooss))
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfMyFooss()) { $index = $this->numberOfMyFooss() - 1; }
array_splice($this->myFooss, $this->indexOfMyFooss($aMyFooss), 1);
array_splice($this->myFooss, $index, 0, array($aMyFooss));
$wasAdded = true;
}
return $wasAdded;
}
public function addOrMoveMyFoossAt($aMyFooss, $index)
{
$wasAdded = false;
if($this->indexOfMyFooss($aMyFooss) !== -1)
{
if($index < 0 ) { $index = 0; }
if($index > $this->numberOfMyFooss()) { $index = $this->numberOfMyFooss() - 1; }
array_splice($this->myFooss, $this->indexOfMyFooss($aMyFooss), 1);
array_splice($this->myFooss, $index, 0, array($aMyFooss));
$wasAdded = true;
}
else
{
$wasAdded = $this->addMyFoossAt($aMyFooss, $index);
}
return $wasAdded;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{
foreach ($this->myFooss as $aMyFooss)
{
$aMyFooss->delete();
}
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
/**
* I am a comment above a method.
*/
public function testMethod()
{
// I am a comment inside a method.
}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Foo
{
//------------------------
// MEMBER VARIABLES
//------------------------
//Foo Attributes
/**
* I am a inline comment above an attribute.
*/
private $bar;
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct($aBar)
{
$this->bar = $aBar;
}
//------------------------
// INTERFACE
//------------------------
public function setBar($aBar)
{
$wasSet = false;
$this->bar = $aBar;
$wasSet = true;
return $wasSet;
}
public function getBar()
{
return $this->bar;
}
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>
<?php
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.35.0.7523.c616a4dce modeling language!*/
class Mentor
{
//------------------------
// MEMBER VARIABLES
//------------------------
//------------------------
// CONSTRUCTOR
//------------------------
public function __construct()
{}
//------------------------
// INTERFACE
//------------------------
public function equals($compareTo)
{
return $this == $compareTo;
}
public function delete()
{}
}
?>