public function removeObserver(MyObserver $o)
{
$i = $this->observers->indexOf($o);
if ($i >= 0) {
$this->observers->remove($i);
}
}
public function updateFilteredEmailRecipients(ArrayList $recipients, $data, $form)
{
foreach ($recipients as $recipient) {
// check if condition set
if (($field = $recipient->ConditionField()) && $field->ID) {
// get field name
$fieldName = $field->Name;
// get condition value
$conditionValue = $recipient->ConditionFieldValue;
// get field value
$fieldValue = "";
if ($field->hasMethod('getValueFromData')) {
$fieldValue = $field->getValueFromData($data);
} else {
if (isset($data[$fieldName])) {
$fieldValue = $data[$fieldName];
}
}
// remove recipient if values don't match
if (trim($fieldValue) != trim($conditionValue)) {
$recipients->remove($recipient);
}
}
}
}
public function testRemove()
{
// Remove the following lines when you implement this test.
$this->object->remove(4);
$this->assertTrue($this->object->count() == 9);
$this->assertTrue($this->object->indexOf(4) == -1);
}
/**
* normally returns TRUE, but returns FALSE when it, or its parent is in the list.
* todo: add products in other product categories
* @param SiteTree $page
* @return Boolean
*/
function canBeDiscounted(SiteTree $page)
{
if ($this->owner->PageIDs) {
$allowedPageIDs = explode(',', $this->owner->PageIDs);
$checkPages = new ArrayList(array($page));
$alreadyCheckedPageIDs = array();
while ($checkPages->Count()) {
$page = $checkPages->First();
if (array_search($page->ID, $allowedPageIDs) !== false) {
return true;
}
$alreadyCheckedPageIDs[] = $page->ID;
$checkPages->remove($page);
// Parents list update
if ($page->hasMethod('AllParentGroups')) {
$parents = new ArrayList($page->AllParentGroups()->toArray());
} else {
$parents = new ArrayList();
}
$parent = $page->Parent();
if ($parent && $parent->exists()) {
$parents->unshift($parent);
}
foreach ($parents as $parent) {
if (array_search($parent->ID, $alreadyCheckedPageIDs) === false) {
$checkPages->push($parent);
}
}
$checkPages->removeDuplicates();
}
return false;
}
return true;
}
public function testAddRemove()
{
$list = new ArrayList(array(array('Key' => 1), array('Key' => 2)));
$list->add(array('Key' => 3));
$this->assertEquals($list->toArray(), array(array('Key' => 1), array('Key' => 2), array('Key' => 3)));
$list->remove(array('Key' => 2));
$this->assertEquals(array_values($list->toArray()), array(array('Key' => 1), array('Key' => 3)));
}
/**
* Removes an item (or items) from the navigation tree
* @param string $label
* @param string $url
* @return NavigationNode
*/
public function remove($label)
{
foreach ($this->items as $item) {
if ($item->label == $label) {
$this->items->remove($item);
}
}
return $this;
}
/**
* Empty the shopping cart object of all items.
*
*/
public function removeAll()
{
foreach ($this->items as $item) {
$this->items->remove($item);
}
}
/**
* Function to find relevent postage rates, based on supplied country and
* zip/postal code data.
*
* We make this a function as part of Commerce Controller, as there are
* several points in the payment/order process that will make use of this
* functionality
*
* @param $country String listing the country to search, this has to be an ISO 3166 code
* @param $zipcode String listing the zip/postage code to filter by
*/
public function getPostageAreas($country, $zipcode)
{
$return = new ArrayList();
$countries = new ArrayList();
$cart = ShoppingCart::create();
$all_rates = $this->SiteConfig()->PostageAreas();
// First find all area's for this country directly (no wildcards)
foreach ($all_rates as $rate) {
if (!(strpos(strtolower($rate->Country), strtolower($country)) === false)) {
$countries->add($rate);
}
}
// If we have no countries in the list specificly, then check for wildcards
if (!$countries->exists()) {
foreach ($all_rates as $rate) {
if ($rate->Country == "*") {
$countries->add($rate);
}
}
}
// If we have a list of countries check them for post codes
foreach ($countries as $rate) {
$rate_codes = explode(",", $rate->ZipCode);
foreach ($rate_codes as $rate_to_check) {
$curr_length = strlen($rate_to_check);
if (strtolower(substr($zipcode, 0, $curr_length)) == strtolower($rate_to_check)) {
$return->add($rate);
}
}
}
// If we still don't have anything to return, check or list of countries
// for a wildcard
if (!$return->exists()) {
foreach ($countries as $rate) {
if ($rate->ZipCode == "*") {
$return->add($rate);
}
}
}
// Now we have a list of locations, start checking for additional
// rules an remove if not applicable.
$total_cost = str_replace(",", "", $cart->SubTotalCost());
$total_weight = str_replace(",", "", $cart->TotalWeight());
$total_items = str_replace(",", "", $cart->TotalItems());
$max_cost = 0;
$max_weight = 0;
$max_items = 0;
// First loop through and find items that are invalid
foreach ($return as $location) {
if ($location->Calculation == "Price" && (double) $total_cost < $location->Unit) {
$return->remove($location);
}
if ($location->Calculation == "Weight" && (double) $total_weight < $location->Unit) {
$return->remove($location);
}
if ($location->Calculation == "Items" && (double) $total_items < $location->Unit) {
$return->remove($location);
}
}
// Now find max values based on units
foreach ($return as $location) {
if ($location->Calculation == "Price" && $location->Unit > $max_cost) {
$max_cost = $location->Unit;
}
if ($location->Calculation == "Weight" && $location->Unit > $max_weight) {
$max_weight = $location->Unit;
}
if ($location->Calculation == "Items" && $location->Unit > $max_items) {
$max_items = $location->Unit;
}
}
// Now loop through again and calculate which brackets each
// Location fits in
foreach ($return as $location) {
if ($location->Calculation == "Price" && $location->Unit < $max_cost) {
$return->remove($location);
}
if ($location->Calculation == "Weight" && $location->Unit < $max_weight) {
$return->remove($location);
}
if ($location->Calculation == "Items" && $location->Unit < $max_items) {
$return->remove($location);
}
}
return $return;
}
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));
}
public function remove($value)
{
$this->validTypeThrow($value);
return parent::remove($value);
}
/**
* Handler for object read.
*
* The data object will be returned in the following format:
*
* <ClassName>
* <FieldName>Value</FieldName>
* ...
* <HasOneRelName id="ForeignID" href="LinkToForeignRecordInAPI" />
* ...
* <HasManyRelName>
* <ForeignClass id="ForeignID" href="LinkToForeignRecordInAPI" />
* <ForeignClass id="ForeignID" href="LinkToForeignRecordInAPI" />
* </HasManyRelName>
* ...
* <ManyManyRelName>
* <ForeignClass id="ForeignID" href="LinkToForeignRecordInAPI" />
* <ForeignClass id="ForeignID" href="LinkToForeignRecordInAPI" />
* </ManyManyRelName>
* </ClassName>
*
* Access is controlled by two variables:
*
* - static $api_access must be set. This enables the API on a class by class basis
* - $obj->canView() must return true. This lets you implement record-level security
*
* @todo Access checking
*
* @param String $className
* @param Int $id
* @param String $relation
* @return String The serialized representation of the requested object(s) - usually XML or JSON.
*/
protected function getHandler($className, $id, $relationName)
{
$sort = '';
if ($this->request->getVar('sort')) {
$dir = $this->request->getVar('dir');
$sort = array($this->request->getVar('sort') => $dir ? $dir : 'ASC');
}
$limit = array('start' => $this->request->getVar('start'), 'limit' => $this->request->getVar('limit'));
$params = $this->request->getVars();
$responseFormatter = $this->getResponseDataFormatter($className);
if (!$responseFormatter) {
return $this->unsupportedMediaType();
}
// $obj can be either a DataObject or a SS_List,
// depending on the request
if ($id) {
// Format: /api/v1/<MyClass>/<ID>
$obj = $this->getObjectQuery($className, $id, $params)->First();
if (!$obj) {
return $this->notFound();
}
if (!$obj->canView()) {
return $this->permissionFailure();
}
// Format: /api/v1/<MyClass>/<ID>/<Relation>
if ($relationName) {
$obj = $this->getObjectRelationQuery($obj, $params, $sort, $limit, $relationName);
if (!$obj) {
return $this->notFound();
}
// TODO Avoid creating data formatter again for relation class (see above)
$responseFormatter = $this->getResponseDataFormatter($obj->dataClass());
}
} else {
// Format: /api/v1/<MyClass>
$obj = $this->getObjectsQuery($className, $params, $sort, $limit);
}
$this->getResponse()->addHeader('Content-Type', $responseFormatter->getOutputContentType());
$rawFields = $this->request->getVar('fields');
$fields = $rawFields ? explode(',', $rawFields) : null;
if ($obj instanceof SS_List) {
$responseFormatter->setTotalSize($obj->dataQuery()->query()->unlimitedRowCount());
$objs = new ArrayList($obj->toArray());
foreach ($objs as $obj) {
if (!$obj->canView()) {
$objs->remove($obj);
}
}
return $responseFormatter->convertDataObjectSet($objs, $fields);
} else {
if (!$obj) {
$responseFormatter->setTotalSize(0);
return $responseFormatter->convertDataObjectSet(new ArrayList(), $fields);
} else {
return $responseFormatter->convertDataObject($obj, $fields);
}
}
}
/**
* Exclui um observador do conjunto de observadores deste objeto.
* @param \Prime\util\Observer $o
*/
public function deleteObserver(Observer $o)
{
return $this->observers->remove($o);
}
public function remove(MenuComponent $menuComponent)
{
$this->menuComponents->remove($menuComponent);
}
public function remove()
{
$this->items->remove($this->position);
}
/**
* This method tests that a exception is thrown if the
* object with the key, passed to the remove method as
* a parameter, does not exist in the ArrayList.
*
* @return void
*/
public function testDeleteWithException()
{
// initialize a new ArrayList
$list = new ArrayList();
// try to remove a not existing object from the ArrayList
try {
$list->remove(1);
$this->fail("Expect exception!");
} catch (\Exception $e) {
$this->assertEquals("Index 1 out of bounds", $e->getMessage());
}
}
// IList::offsetGet
try {
echo "Getting #-1\n";
Debug::dump($list[-1]);
} catch (Exception $e) {
echo get_class($e), ': ', $e->getMessage(), "\n\n";
}
try {
echo "Getting #0\n";
Debug::dump($list[0]);
} catch (Exception $e) {
echo get_class($e), ': ', $e->getMessage(), "\n\n";
}
// IList::remove
echo "Removing Larry\n";
Debug::dump($list->remove($larry));
echo "Removing Larry second time\n";
Debug::dump($list->remove($larry));
// IList::offsetUnset
try {
echo "Removing using unset\n";
unset($list[-1]);
} catch (Exception $e) {
echo get_class($e), ': ', $e->getMessage(), "\n\n";
}
try {
echo "Removing using unset\n";
unset($list[1]);
} catch (Exception $e) {
echo get_class($e), ': ', $e->getMessage(), "\n\n";
}
