public function notifyObservers()
{
for ($i = 0; $i < $this->observers->size(); $i++) {
$observer = $this->observers->get($i);
$observer->update($this->temperature, $this->humidity, $this->pressure);
}
}
public function hasNext()
{
if ($this->position >= $this->items->size()) {
return FALSE;
} else {
return TRUE;
}
}
function testAddSameElementTwice()
{
$list = new ArrayList("string");
$list->add("Hello there");
$list->add("Hello there");
$this->assertEqual(2, $list->size());
}
/**
* Se este objeto foi alterado, como indicado pelo método hasChanged, em seguida,
* notificar todos os seus observadores e, em seguida, chamar o método clearChanged
* para indicar que este objeto não mudou.
* @param \Prime\util\Object $arg
*/
public function notifyObservers()
{
for ($index = 0; $index < count($this->observers->size()); $index++) {
$observer = $this->observers->get($index);
/* @var $observer IObserver */
$observer->update($this);
}
$this->clearChanged();
}
/**
* Turns any supplied ArrayList or array into a HTML5 valid table. A few
* things to note on this function, first is that this function is dependant
* on the second argument to supply the Table Matrix.
*
* How does the Table Matrix work? Since the array needs some list of
* information to pull out of the items that are in the array.
*
* So for example if your array looks like this:
* $arr = [
* {name: "My Name", date: "My Date", password: "******"},
* {name: "Start Name", date: "Some Date", password: "******"},
* {name: "Some Name", date: "End Date", password: "******"}
* ];
*
* Then most likely your table Matrix would be something like this:
* $matrix = [
* {name: "Name", method: "getName"},
* {date: "Date", method: "getDate"}
* ];
*
* Why use this? Well two reasons, most obvious to help formatting, the
* other is to stop unwanted data being leaked into the table (In this case
* the object $passsword)
*
* @param ArrayList|array $table_data
* @param ArrayList|array $table_matrix
* @param ArrayList|array $classes
* @param string $id
* @param int $maxlength
*/
function generateTable($table_data, $table_matrix, $classes = null, $id = null, $maxlength = -1)
{
//Validate
if (!is_array($table_data) && !$table_data instanceof ArrayList) {
throw new Exception('Table Data must be an Array/ArrayList');
}
if (!is_array($table_matrix) && !$table_matrix instanceof ArrayList) {
throw new Exception('Table Matrix is invalid.');
}
//Translate
if (is_array($table_data)) {
$table_data = new ArrayList($table_data);
}
if (is_array($table_matrix)) {
$table_matrix = new ArrayList($table_matrix);
}
//Coordinate
$x = '<table';
if ($classes !== null) {
if (is_string($classes)) {
$x .= ' class="' . $classes . '"';
} else {
if (is_array($classes) || $classes instanceof ArrayList) {
if (is_array($classes)) {
$classes = new ArrayList($classes);
}
$x .= ' class="' . $classes->implode(' ') . '"';
}
}
}
if ($id !== null && is_string($id)) {
$x .= ' id="' . $id . '"';
}
$x .= '>';
//Now we can form our table header
$x .= '<thead><tr>';
foreach ($table_matrix as $thead) {
if (!is_array($thead) && !$thead instanceof ArrayList) {
throw new Exception('Malformed table matrix.');
}
if (is_array($thead)) {
$thead = new ArrayList($thead);
}
if (!$thead->isKeySet('name')) {
throw new Exception('Malformed table matrix. (Need col name)');
}
if (!$thead->isKeySet('method')) {
throw new Exception('Malformed table matrix. (Need col method)');
}
$x .= '<th>' . $thead["name"] . '</th>';
}
$x .= '</tr></thead>';
//Now the table data.
$x .= '<tbody>';
for ($i = 0; $i < $table_data->size(); $i++) {
$obj = $table_data[$i];
//Now iterate over the matrix
$x .= '<tr>';
foreach ($table_matrix as $thead) {
$args = array();
if (is_array($thead)) {
$thead = new ArrayList($thead);
}
if ($thead->isKeySet("args")) {
$args = $def["args"];
}
$method = $thead["method"];
$result;
//Definition
if (is_array($method) || $method instanceof ArrayList) {
if (is_array($method)) {
$method = new ArrayList($method);
}
/*
* If $method is an array then the expected result from a
* call_user_func_array on $array[0] is another object.
*
* Basically we're going to run through until we reach
* $method->size() on each returned object.
*
* e.g. if I have the following:
* {
* getChild() {
* return {getName() {"Simon"}};
* }
* }
*
* I would have the following $method:
* ["getChild", "getName"]
*
* To overcomplicate again, if I had:
* {
* getChild() {
* return {
* getButt() {
* return {getName() { "Simon"}};
* }
* };
* }
* }
*
* And my $method would be:
* ["getChild", "getButt", "getName"]
*
* TECHNICALLY speaking you can supply args, I will make
* this better in the future but for now I wouldn't.
*/
$result = $obj;
foreach ($method as $func) {
$result = call_user_func_array(array($result, $func), $args);
}
} else {
$result = call_user_func_array(array($obj, $thead["method"]), $args);
}
//HTML Fix up for I.E.
if ($result === null || !isset($result) || $result == '') {
$result = ' ';
}
$x .= '<td>' . $result . '</td>';
}
$x .= '</tr>';
if ($maxlength != -1 && $i >= $maxlength) {
break;
}
}
$x .= '</tbody>';
//Finally close up the table.
$x .= '</table>';
return $x;
}
public function calculate($infix)
{
$postfix = new ArrayList();
$stack = new ArrayList();
$i = 0;
$temp = "";
$type = $this->getType($infix[0]);
$lasttype = TType::OPERATION;
$infix = trim($infix);
while ($i < strlen($infix)) {
$type = $this->getType($infix[$i]);
$temp = "";
//Get Token name
while ($type == $this->getType($infix[$i])) {
$temp .= $infix[$i];
$i++;
if ($i == strlen($infix) || $type == TType::OPERATION || $infix[$i - 1] == '(') {
break;
}
}
//Negatives Vorzeichen zu -1* umgeschrieben (Bsp.: -3 => (-1)*3
if ($lasttype == TType::OPERATION && $type == TType::OPERATION) {
if ($temp == '-') {
$postfix->add(new Token("-1", TType::NUMBER));
$temp = "*";
} else {
$postfix->add(new Token("1", TType::NUMBER));
$temp = "*";
}
}
//Fehlender Operator vor Funktionen wird ergänzt
if ($type == TType::NUMBER && $lasttype == TType::FUNC || $type == TType::FUNC && $lasttype == TType::NUMBER) {
$i -= strlen($temp);
$type = TType::OPERATION;
$temp = "*";
}
//Add Token to Tokenlist
switch ($type) {
case TType::NUMBER:
$postfix->add(new Token($temp, $type));
break;
case TType::OPERATION:
for ($j = $stack->size() - 1; $j > -1; $j--) {
if ($this->getValue($temp) > $this->getValue($stack->get($j))) {
$stack->add($temp);
break;
} else {
$postfix->add(new Token($stack->get($j), TType::OPERATION));
$stack->remove($j);
}
}
if ($stack->size() == 0) {
$stack->add($temp);
}
break;
case TType::FUNC:
if (in_array($temp, $this->availableFunc)) {
$func = new FunctionC($temp);
$sub = substr($infix, $i);
$pos = $this->getLastBracket($sub);
$sub = substr($sub, 0, $pos);
while (strpos($sub, ',') !== false) {
$pos2 = strpos($sub, ',');
if (strlen($func->term) === false && $temp == "integral(") {
$func->term = substr($sub, 0, $pos2);
} else {
$func->parameters->add($this->calculate(substr($sub, 0, $pos2)));
}
$sub = substr($sub, $pos2 + 1);
}
$func->parameters->add($this->calculate($sub));
$i += $pos + 1;
$postfix->add(new Token(strval($func->calculate()), TType::NUMBER));
$type = TType::NUMBER;
}
if ($this->variable->size() != 0) {
foreach ($this->variable->arrayList as $v) {
if ($temp == $v->name) {
$postfix->add(new Token(strval($v->wert), TType::NUMBER));
$temp = "";
$type = TType::NUMBER;
}
}
}
break;
}
$lasttype = $type;
}
//Add operation stack to postfix
for ($j = $stack->size() - 1; $j > -1; $j--) {
$postfix->add(new Token($stack->get($j), TType::OPERATION));
$stack->remove($j);
}
//Calculate postfix--> result
/* Lese alle Tokens der postfix Liste nacheinander ein.
* Schreibe alle Zahlen in einen Stack, wird eine Operation gelesen, so führe die Operation mit den letzten
* beiden hinzugefügten Zahlen aus, lösche die beiden Zahlen und ersetze sie mit ihrem Ergebnis
*/
$result = 0.0;
for ($i = 0; $i < $postfix->size(); $i++) {
switch ($postfix->get($i)->type) {
case TType::NUMBER:
$stack->add($postfix->get($i)->name);
break;
case TType::OPERATION:
switch ($postfix->get($i)->name) {
case "+":
$result = doubleval($stack->get($stack->size() - 2)) + doubleval($stack->get($stack->size() - 1));
break;
case "-":
$result = doubleval($stack->get($stack->size() - 2)) - doubleval($stack->get($stack->size() - 1));
break;
case "*":
$result = doubleval($stack->get($stack->size() - 2)) * doubleval($stack->get($stack->size() - 1));
break;
case "/":
$result = doubleval($stack->get($stack->size() - 2)) / doubleval($stack->get($stack->size() - 1));
break;
case "%":
$result = doubleval($stack->get($stack->size() - 2)) % doubleval($stack->get($stack->size() - 1));
break;
case "^":
$result = pow(doubleval($stack->get($stack->size() - 2)), doubleval($stack->get($stack->size() - 1)));
break;
}
$stack->remove($stack->size() - 2);
$stack->remove($stack->size() - 1);
$stack->add(strval($result));
break;
}
}
return doubleval($stack->get(0));
}
/**
* This method tests the add, remove and
* size method of the ArrayList.
*
* @return void
*/
public function testAddAndRemoveAndSize()
{
// initialize a new ArrayList
$list = new ArrayList();
$this->assertEquals(0, $list->size());
$list->add("Element 1");
$list->add("Element 2");
$list->add("Element 3");
$this->assertEquals(3, $list->size());
$list->remove(2);
$this->assertEquals(2, $list->size());
}
//Create our class
class MyClass
{
public $name;
public function __construct($name)
{
$this->name = $name;
}
}
//Create our Objects
$object1 = new MyClass('Hello');
$object2 = new MyClass('World');
$object3 = new MyClass('How');
$object4 = new MyClass('Are');
$object5 = new MyClass('You');
//Create our ArrayList
$myList = new ArrayList();
$myList->add($object1);
$myList->add($object2);
$myList->add($object3);
$myList->add($object4);
$myList->add($object5);
//Create our loop
for ($i = 0; $i < $myList->size(); $i++) {
echo $myList[$i]->name . " ";
}
//Will Print: "Hello World How Are You "
foreach ($myList as $obj) {
echo $obj->name . " ";
}
//Will Print: "Hello World How Are You "
