Inheritance diagram for tCO_Collection:

Collaboration diagram for tCO_Collection:

Public Member Functions
	reload_collection ()

	insertElement ( $in_element, $in_before_index=-1, $dont_update=false)

	insertElements ( $in_element_array, $in_before_index=-1)

	deleteElements ( $in_first_index, $in_deletion_length)

	deleteElement ( $in_index)

	deleteThisElement ( $in_element)

	appendElement ( $in_element)

	appendElements ( $in_element_array)

	deleteAllChildren ()

	indexOfThisElement ( $in_element)

	whosYourDaddy ( $in_element)

	areYouMyDaddy ( $in_element, $full_hierachy=true)

	map ( $in_function)

	recursiveMap ( $in_function, $in_hierarchy_level=0, $in_parent_object=NULL, $loop_stopper=Array())

	count ( $is_recursive=false)

	children ()

	children_ids ( $in_raw=false)

	set_children_ids ( $in_new_ids)

	who_are_my_parents ()

	getHierarchy ( $loop_stopper=Array())

Protected Member Functions
	_scrub ()

	_set_up_container ()

Protected Attributes
	$_container
	This contains instances of the records referenced by the IDs stored in the object. More...

Detailed Description

This is a trait for the basic "collection" aggregator functionality.

Yes, I know that a lot of the code could do with some refactoring, and we should do that, but what we have here does work, and having pretty code is less important than having effective, tested, working code. We have a lot on our plate.

Definition at line 37 of file tco_collection.interface.php.

Member Function Documentation

◆ _scrub()

tCO_Collection::_scrub ( )

protected

This is a "garbage collection" method. This checks each of the contained items, and removes the ID if the item does not actually exist (security is not taken into account, so it's an accurate check).

Definition at line 45 of file tco_collection.interface.php.

                                 {
         if (isset($this->context['children_ids'])) {
             $children_ids = $this->context['children_ids'];
         
             if (isset($children_ids) && is_array($children_ids) && count($children_ids)) {
                 $new_ids = Array();
                 foreach ($children_ids as $id) {
                     $id = intval($id); // Belt and suspenders.
                     if ($this->get_access_object()->item_exists($id)) {
                         $new_ids[] = $id;
                     }
                 }
                 $new_ids = array_unique($new_ids);
                 sort($new_ids);
                 $this->context['children_ids'] = $new_ids;
                 $this->update_db();
             }
         } else {
             $this->_container = Array();
         }
     }

◆ _set_up_container()

tCO_Collection::_set_up_container ( )

protected

This method simply sets up the internal container from the object's tags. The tags already need to be loaded when this is called, so it should be called towards the end of the object's constructor.

Definition at line 73 of file tco_collection.interface.php.

                                            {
         if (isset($this->context['children_ids'])) {
             $children_ids = $this->context['children_ids'];
         
             if (isset($children_ids) && is_array($children_ids) && count($children_ids)) {
                 $this->_container = $this->get_access_object()->get_multiple_data_records_by_id($children_ids);
             }
         }
     }

Referenced by CO_User_Collection\load_from_db().

Here is the caller graph for this function:

◆ appendElement()

tCO_Collection::appendElement ( $in_element )

This appends one record to the end of the collection. The element cannot be already in the collection at any level, as that could cause a loop. The logged-in user must have write access to the collection object (not the data object) in order to add the item. You can opt out of the automatic database update.

Returns: true, if the data was successfully added. If a DB update was done, then the response is the one from the update.

Parameters

$in_element The database record to add.

Definition at line 383 of file tco_collection.interface.php.

                                   {
         return $this->insertElement($in_element, -1);
     }

◆ appendElements()

tCO_Collection::appendElements ( $in_element_array )

This appends multiple elements (passed as an array). The logged-in user must have write access to the collection object (not the data object) in order to add the items.

Returns: true, if the data was successfully updated in the DB. false, if none of the items were added.

Parameters

$in_element_array An array of database element instances to be appended.

Definition at line 396 of file tco_collection.interface.php.

                                   {
         return $this->insertElements($in_element_array, -1);
     }

◆ areYouMyDaddy()

tCO_Collection::areYouMyDaddy	(	$in_element,
		$full_hierachy = `true`
	)

This takes an element, and checks to see if it already exists in our hierarchy (anywhere).

Returns: true, if this instance already has the presented object.

Parameters

$in_element	The element to check. This can be an array, in which case, each element is checked.
$full_hierachy	If false, then only this level (not the full hierarchy) will be searched. Default is true.

Definition at line 473 of file tco_collection.interface.php.

                                   {
         $ret = false;
         
         $children = $this->children();
         
         if (isset($children) && is_array($children) && count($children)) {
             foreach ($children as $object) {
                 if ($object == $in_element) {
                     $ret = true;
                     break;
                 } else {
                     if ($full_hierachy && method_exists($object, 'areYouMyDaddy')) {
                         if ($object->areYouMyDaddy($in_element)) {
                             $ret = true;
                             break;
                         }
                     }
                 }
             }
         }
         
         return $ret;
     }

◆ children()

tCO_Collection::children ( )

This is an accessor for the child object array (instances). It should be noted that this may not be the same as the 'children' context variable, because the user may not be allowed to see all of the items.

Returns: the child objects array.

Definition at line 591 of file tco_collection.interface.php.

                                {
         if (!isset($this->_container) || !$this->_container || (!count($this->_container))) {
             $this->_scrub();
             $this->_set_up_container();
         }
         return $this->_container;
     }

Referenced by CO_User_Collection\delete_from_db().

Here is the caller graph for this function:

◆ children_ids()

tCO_Collection::children_ids ( $in_raw = false )

This is an accessor that returns a list of IDs for the direct children of this instance. This is "security vetted," so only IDs of children visible to the logged-in user are returned.

Returns: the child ids array (array of integer).

Parameters

$in_raw This is only valid for "God Mode." If true, then the array is returned with no scrub, and no checks.

Definition at line 606 of file tco_collection.interface.php.

                                   {
         $ret = [];
         if ($in_raw && $this->get_access_object()->god_mode()) {   // God gets it all.
             if (isset($this->context['children'])) {
                 return (array_map('intval', explode(',', $this->context['children'])));
             } else {
                 return [];
             }
         }
         
         $this->_scrub();
         if (isset($this->context['children_ids']) && is_array($this->context['children_ids']) && count ($this->context['children_ids'])) {
             $ids = $this->context['children_ids'];
             if ($this->get_access_object()->god_mode()) {   // God gets it all.
                 $ret = $ids;
             } else {
                 foreach ($ids as $id) {
                     if ($this->get_access_object()->item_exists($id, true)) {
                         $ret[] = intval($id);
                     }
                 }
             }
         }
         
         return $ret;
     }

◆ count()

tCO_Collection::count ( $is_recursive = false )

This counts the direct children of this collection, and returns that count. If recursive, then it counts everything inside, including owners. Remember that this is "security-aware." The collection may have children that are not visible to the current login.

Returns: the number of direct children.

Parameters

$is_recursive If true, then this will also count all "child" collections. Default is false.

Definition at line 564 of file tco_collection.interface.php.

                           {
         $children = $this->children();
         $my_count = 0;
         
         if (isset($children) && is_array($children)) {
             $my_count = count($children);
         
             if ($is_recursive) {
                 foreach ($children as $child) {
                     if (method_exists($child, 'count')) {
                         $my_count += $child->count($is_recursive);
                     }
                 }
             }
         }
         
         return $my_count;
     }

Referenced by CO_User_Collection\is_god(), CO_User_Collection\set_tag(), and CO_User_Collection\set_tags().

Here is the caller graph for this function:

◆ deleteAllChildren()

tCO_Collection::deleteAllChildren ( )

This deletes all children of the container. However, the container may have children we can't see, so we don't delete those. We only delete the ones we know about (which could be all of them).

Returns: true, if the new configuration was successfully updated in the DB.

Definition at line 408 of file tco_collection.interface.php.

                                         {
         if ($this->user_can_write() ) { // You cannot delete from a collection if you don't have write privileges.
             $new_list = [];
         
             if (isset($this->context['children_ids']) && is_array($this->context['children_ids']) && count($this->context['children_ids'])) {
                 foreach ($this->context['children_ids'] as $child_id) {
                     // We save items in the list that we can't see.
                     if ($this->get_access_object()->item_exists($child_id) && !$this->get_access_object()->can_i_see_this_data_record($child_id)) {
                         $new_list[] = $child_id;
                     }
                 }
             }
         
             $this->_children = Array();
             $this->context['children_ids'] = $new_list;
             return $this->update_db();
         }
         
         return false;
     }

◆ deleteElement()

tCO_Collection::deleteElement ( $in_index )

Deletes a single element, by its 0-based index (not recursive). It should be noted that this does not delete the element from the database, and it is not recursive.

Returns: true, if the element was successfully removed from the collection.

Parameters

$in_index The 0-based index of the element we want to delete.

Definition at line 348 of file tco_collection.interface.php.

                                   {
         return $this->deleteElements($in_index, 1);
     }

◆ deleteElements()

tCO_Collection::deleteElements	(	$in_first_index,
		$in_deletion_length
	)

Deletes multiple elements from the collection. It should be noted that this does not delete the elements from the database, and it is not recursive. This is an atomic operation. If any of the elements can't be removed, then non of the elements can be removed. The one exception is that the deletion length can extend past the boundaries of the collection. It will be truncated.

Returns: true, if the elements were successfully removed from the collection.

Parameters

$in_first_index	The starting 0-based index of the first element to be removed from the collection.
$in_deletion_length	The number of elements to remove (including the first one). If this is negative, then elements will be removed from the index, backwards (-1 is the same as 1).

Definition at line 279 of file tco_collection.interface.php.

                                   {
         $ret = false;
         
         if ($this->user_can_write() ) { // You cannot add to a collection if you don't have write privileges.
             $element_ids = Array(); // We will keep track of which IDs we delete, so we can delete them from our context variable.
             
             // If negative, we're going backwards.
             if (0 > $in_deletion_length) {
                 $in_deletion_length = abs($in_deletion_length);
                 $in_first_index -= ($in_deletion_length - 1);
                 $in_first_index = max(0, $in_first_index);  // Make sure we stay within the lane markers.
             }
             
             $last_index_plus_one = min(count($this->_container), $in_first_index + $in_deletion_length);
         
             // We simply record the IDs of each of the elements we'll be deleting.
             for ($i = $in_first_index; $i < $last_index_plus_one; $i++) {
                 $element = $this->_container[$i];
                 $element_ids[] = $element->id();
             }
             
             if ($in_deletion_length == count($element_ids)) {  // Belt and suspenders. Make sure we are actually deleting the requested elements.
                 $new_container = Array();
                 
                 // We build a new container that doesn't have the deleted elements.
                 foreach ($this->_container as $element) {
                     $element_id = $element->id();
                     
                     if (!in_array($element_id, $element_ids)) {
                         $new_container[] = $element_id;
                     }
                 }
                 
                 $new_list = Array();
                 
                 // We build a new list that doesn't have the deleted element IDs.
                 while ($element_id = array_shift($this->context['children_ids'])) {
                     if (!in_array($element_id, $element_ids)) {
                         $new_list[] = $element_id;
                     }
                 }
                 
                 $new_list = array_unique($new_list);
                 sort($new_list);
                 $this->context['children_ids'] = $new_list;
                 
                 $ret = $this->update_db();
                 if (!$this->_batch_mode) {
                     $this->_scrub();
                 }
             }
         } else {
             $this->error = new LGV_Error(   CO_CHAMELEON_Lang_Common::$co_collection_error_code_user_not_authorized,
                                             CO_CHAMELEON_Lang::$co_collection_error_name_user_not_authorized,
                                             CO_CHAMELEON_Lang::$co_collection_error_desc_user_not_authorized);
         }
         
         return $ret;
     }

References CO_CHAMELEON_Lang_Common\$co_collection_error_code_user_not_authorized, CO_CHAMELEON_Lang\$co_collection_error_desc_user_not_authorized, and CO_CHAMELEON_Lang\$co_collection_error_name_user_not_authorized.

◆ deleteThisElement()

tCO_Collection::deleteThisElement ( $in_element )

Deletes a single element, by its actual object reference (not recursive). It should be noted that this does not delete the element from the database, and it is not recursive.

Returns: true, if the element was successfully removed from the collection.

Parameters

$in_element The element we want to delete.

Definition at line 360 of file tco_collection.interface.php.

                                       {
         $ret = false;
         $index = $this->indexOfThisElement($in_element);
         
         if (false !== $index) {
             $ret = $this->deleteElement(intval($index));
         }
         
         return $ret;
     }

◆ getHierarchy()

tCO_Collection::getHierarchy ( $loop_stopper = Array() )

Returns

an instance "map" of the collection. It returns an array of associative arrays. Each associative array has the following elements:

'object' (Required). This is the actual instance that maps to this object.
'children' (optional -may not be instantiated). This is an array of the same associative arrays for any "child objects" of the current object.

Parameters

$loop_stopper This is used to prevent "hierarchy loops." As we descend into recursion, we save the collection ID here. If the ID shows up in a "lower" collection, we don't add that collection. This shouldn't happen anyway, as were're not supposed to have been able to add embedded collections, but we can't be too careful. There can only be one...

Definition at line 683 of file tco_collection.interface.php.

                                       {
         $this->_scrub();
         
         $instance = Array('object' => $this);
         
         if (method_exists($this, 'children') && count($this->children())) {
             $children = $this->children();
             $instance['children'] = Array();
         
             foreach ($children as $child) {
                 if (method_exists($child, 'getHierarchy')) {
                     if (!in_array($child->id(), $loop_stopper)) {
                         $loop_stopper[] = $child->id();
                         $instance['children'][] = $child->getHierarchy($loop_stopper);
                     }
                 } else {
                     $instance['children'][] = Array('object' => $child);
                 }
             }
         }
         
         return $instance;
     }

◆ indexOfThisElement()

tCO_Collection::indexOfThisElement ( $in_element )

Returns: the 0-based index of the given element, or false, if the element is not in the collection (This is not recursive).

Parameters

$in_element The element we're looking for.

Definition at line 433 of file tco_collection.interface.php.

                                           {
         return array_search($in_element, $this->children());
     }

◆ insertElement()

tCO_Collection::insertElement	(	$in_element,
		$in_before_index = `-1`,
		$dont_update = `false`
	)

This inserts one record to just before the indexed item (0-based index). If the index is -1, the length of the collection or larger, then the item will be appeneded. Collection elements cannot be already in the collection at any level, as that could cause a loop. We also don't allow duplicates of any instance in the same level of a collection. Only the first instance is retained. Subsequent copies are removed. The logged-in user must have write access to the collection object (not the data object) in order to add the item. You can opt out of the automatic database update.

Returns: true, if the data was successfully added. If a DB update was done, then the response is the one from the update.

Parameters

$in_element	The database record to add.
$in_before_index	The index of the element (in the current list) BEFORE which the insertion will be made. Default is -1 (append).
$dont_update	true, if we are to skip the DB update (default is false).

Definition at line 102 of file tco_collection.interface.php.

                                   {
         $ret = false;
         
         if ($in_element instanceof A_CO_DB_Table_Base) {
             if ($this->user_can_write() ) { // You cannot add to a collection if you don't have write privileges.
                 if (!(method_exists($in_element, 'insertElement') && $this->areYouMyDaddy($in_element))) {   // Make sure that a collection isn't already in the woodpile somewhere.
                     $id = intval($in_element->id());
                     if (!isset($this->_container) || !is_array($this->_container)) {
                         $this->_container = [];
                     }
                 
                     if (!isset($this->context['children_ids']) || !is_array($this->context['children_ids'])) {
                         $this->context['children_ids'] = [];
                     }
                     
                     if (!in_array($id, $this->context['children_ids'])) {
                         if ((-1 == $in_before_index) || (NULL == $in_before_index) || !isset($in_before_index)) {
                             $in_before_index = count($this->_container);
                         }
                 
                         $before_array = Array();
                 
                         if ($in_before_index) {
                             $before_array = array_slice($this->_container, 0, $in_before_index, false);
                         }
                 
                         $after_array = Array();
                 
                         if ($in_before_index < count($this->_container)) {
                             $end_count = count($this->_container) - $in_before_index;
                             $after_array = array_slice($this->_container, $end_count, false);
                         }
                 
                         $element_array = Array($in_element);
                 
                         $merged = array_merge($before_array, $element_array, $after_array);
                 
                         $this->_container = $merged;
                 
                         $ret = true;
                         if (!isset($this->context['children_ids'])) {
                             $this->context['children_ids'] = Array();
                         }
                 
                         $ids = array_map('intval', $this->context['children_ids']);
                         if (!in_array($id, $ids)) {
                             $ids[] = $id;
                             $ids = array_unique($ids);
                             sort($ids);
                             $this->context['children_ids'] = $ids;
                         }
                     }
                 }
         
                 if ($ret && !$dont_update) {
                     $ret = $this->update_db();
                 }
             } else {
                 $this->error = new LGV_Error(   CO_CHAMELEON_Lang_Common::$co_collection_error_code_user_not_authorized,
                                                 CO_CHAMELEON_Lang::$co_collection_error_name_user_not_authorized,
                                                 CO_CHAMELEON_Lang::$co_collection_error_desc_user_not_authorized);
             }
         }
         
         return $ret;
     }

References CO_CHAMELEON_Lang_Common\$co_collection_error_code_user_not_authorized, CO_CHAMELEON_Lang\$co_collection_error_desc_user_not_authorized, and CO_CHAMELEON_Lang\$co_collection_error_name_user_not_authorized.

◆ insertElements()

tCO_Collection::insertElements	(	$in_element_array,
		$in_before_index = `-1`
	)

This inserts multiple records to just before the indexed item (0-based index). If the index is -1, the length of the collection or larger, then the items will be appeneded. Collection elements cannot be already in the collection at any level, as that could cause a loop. We also don't allow duplicates of any class in the same level of a collection. Only the first instance is retained. Subsequent copies are removed. The logged-in user must have write access to the collection object (not the data objects) in order to add the items. You can opt out of the automatic database update.

Returns: true, if the data was successfully updated in the DB. false, if none of the items were added.

Parameters

$in_element_array	An array of database element instances to be inserted.
$in_before_index	The index of the element (in the current list) BEFORE which the insertion will be made. Default is -1 (append).

Definition at line 182 of file tco_collection.interface.php.

                                   {
         $ret = false;
         
         if ($this->user_can_write() ) { // You cannot add to a collection if you don't have write privileges.
             $i_have_a_daddy = false;
             
             if (is_array($in_element_array) && count($in_element_array)) {
                 foreach ($in_element_array as $element) {
                     // We can't insert nested collections.
                     if (method_exists($element, 'insertElement') && $this->areYouMyDaddy($element)) {
                         $i_have_a_daddy = true;
                         break;
                     }
                 }
             }
             
             if (!$i_have_a_daddy) { // DON'T CROSS THE STREAMS!
                 if (!isset($this->_container) || !is_array($this->_container)) {
                     $this->_container = Array();
                 }
                 
                 if ((-1 == $in_before_index) || (NULL == $in_before_index) || !isset($in_before_index)) {
                     $in_before_index = count($this->_container);
                 }
                 
                 $before_array = Array();
                 
                 if ($in_before_index) {
                     $before_array = array_slice($this->_container, 0, $in_before_index, false);
                 }
                 
                 $after_array = Array();
                 
                 if ($in_before_index < count($this->_container)) {
                     $end_count = count($this->_container) - $in_before_index;
                     $after_array = array_slice($this->_container, $end_count, false);
                 }
                 
                 if (!isset($in_element_array) || !is_array($in_element_array) || !count($in_element_array)) {
                     $in_element_array = [];
                 }
                 
                 $merged = array_merge($before_array, $in_element_array, $after_array);
                 
                 $unique  = array();
                 
                 if (is_array($merged) && count($merged)) {
                     foreach ($merged as $current) {
                         if (!in_array($current, $unique)) {
                             $unique[] = $current;
                         }
                     }
                 }
                 
                 $this->_container = $unique;
                 
                 $ret = true;
             
                 if (!isset($this->context['children_ids'])) {
                     $this->context['children_ids'] = Array();
                 }
                 
                 foreach ($in_element_array as $element) {
                     $id = intval($element->id());
                     $ids = array_map('intval', $this->context['children_ids']);
                     if (!in_array($id, $ids)) {
                         $ids[] = $id;
                         $ids = array_unique($ids);
                         sort($ids);
                         $this->context['children_ids'] = $ids;
                     }
                 }
             }
         
             if ($ret) {
                 $ret = $this->update_db();
             }
         } else {
             $this->error = new LGV_Error(   CO_CHAMELEON_Lang_Common::$co_collection_error_code_user_not_authorized,
                                             CO_CHAMELEON_Lang::$co_collection_error_name_user_not_authorized,
                                             CO_CHAMELEON_Lang::$co_collection_error_desc_user_not_authorized);
         }
         
         return $ret;
     }

References CO_CHAMELEON_Lang_Common\$co_collection_error_code_user_not_authorized, CO_CHAMELEON_Lang\$co_collection_error_desc_user_not_authorized, and CO_CHAMELEON_Lang\$co_collection_error_name_user_not_authorized.

◆ map()

tCO_Collection::map ( $in_function )

This applies a given function to each of the elements in the child list. The function needs to have a signature of function mixed map_func(mixed $item);

Returns: a flat array of function results. The array maps to the children array.

Parameters

$in_function The function to be applied to each element.

Definition at line 506 of file tco_collection.interface.php.

                           {
         $ret = Array();
         
         $children = $this->children();
         
         foreach ($children as $child) {
             $result = $in_function($child);
             $ret[] = $result;
         }
         
         return self::class;
     }

◆ recursiveMap()

tCO_Collection::recursiveMap	(	$in_function,
		$in_hierarchy_level = `0`,
		$in_parent_object = `NULL`,
		$loop_stopper = `Array()`
	)

This applies a given function to each of the elements in the child list, and any embedded (recursive) ones. The function needs to have a signature of function mixed map_func(mixed $item, integer $hierarchy_level, mixed $parent_object);

Returns: a flat array of function results. This array may be larger than the children array, as it will also contain any nested collections.

Parameters

$in_function	This is the function to be applied to all elements.
$in_hierarchy_level	This is a 0-based integer that tells the callback how many "levels deep" the function is.
$in_parent_object	This is the collection object that is the "parent" of the current array.
$loop_stopper	This is used to prevent "hierarchy loops." As we descend into recursion, we save the collection ID here. If the ID shows up in a "lower" collection, we don't add that collection. This shouldn't happen anyway, as were're not supposed to have been able to add embedded collections, but we can't be too careful. There can only be one...

Definition at line 527 of file tco_collection.interface.php.

                                   {
         $in_hierarchy_level = intval($in_hierarchy_level);
         $ret = Array($in_function($this, $in_hierarchy_level, $in_parent_object));
         $children = $this->children();
         
         foreach ($children as $child) {
             if (method_exists($child, 'recursiveMap')) {
                 if (!in_array($child->id(), $loop_stopper)) {
                     $loop_stopper[] = $child->id();
                     $result = $child->recursiveMap($in_function, ++$in_hierarchy_level, $this, $loop_stopper);
                 }
             } else {
                 $result = Array($in_function($child, ++$in_hierarchy_level, $this));
             }
             $ret = array_merge($ret, $result);
         }
         
         return $ret;
     }

◆ reload_collection()

tCO_Collection::reload_collection ( )

This method forces a reload of the collection data.

Definition at line 87 of file tco_collection.interface.php.

                                         {
         $this->_scrub();    // Garbage collection.
         $this->_set_up_container();
     }

◆ set_children_ids()

tCO_Collection::set_children_ids ( $in_new_ids )

This is a "God Mode-only" method that is used to wholesale replace the entire children array.

Returns: true, if the operation was allowed and successful.

Parameters

$in_new_ids This is an array of integers, with the IDs of new children. This entirely replaces the current array.

Definition at line 640 of file tco_collection.interface.php.

                                       {
         $ret = false;
         
         if ($this->get_access_object()->god_mode()) {
             $this->_children = Array();
             $this->context['children'] = implode(',', $in_new_ids);
             unset($this->context['children_ids']);
             $ret = $this->update_db();
         }
         
         return $ret;
     }

◆ who_are_my_parents()

tCO_Collection::who_are_my_parents ( )

Returns: an array of any direct parents of the current object. The returned objects will be collection instances. An empty array will be returned if no parents found.

Definition at line 658 of file tco_collection.interface.php.

                                          {
         $ret = [];
         
         $result = $this->get_access_object()->generic_search(Array('access_class' => Array('%_Collection%', 'use_like' => 1)));
         
         if (isset($result) && is_array($result) && count($result)) {
             foreach ($result as $object) {
                 if (($object instanceof CO_Main_DB_Record) && method_exists($object, 'areYouMyDaddy')) {
                     if ($object->areYouMyDaddy($this, false)) {
                         $ret[] = $object;
                     }
                 }
             }
         }
         
         return $ret;
     }

◆ whosYourDaddy()

tCO_Collection::whosYourDaddy ( $in_element )

This takes an element, and returns its parent collection object (if available). This only checks the current collection and its "child" collection objects.

Returns: an array of instances of a collection class, if that instance is the "parent" of the presented object. It may be this instance, or a "child" instance of this class.

Parameters

$in_element The element to check.

Definition at line 445 of file tco_collection.interface.php.

                                   {
         $ret = NULL;
         $id = intval($in_element->id());
         
         $ret_array = $this->recursiveMap(function($instance, $hierarchy_level, $parent){
                 $id = intval($instance->id());
                 return Array($id, $parent);
             });
         
         if (isset($ret_array) && is_array($ret_array) && count($ret_array)) {
             $ret = Array();
             foreach ($ret_array as $item) {
                 if ($item[0] == $id) {
                     $ret[] = $item[1];
                 }
             }
         }
         
         return $ret;
     }

Member Data Documentation

◆ $_container

tCO_Collection::$_container

protected

This contains instances of the records referenced by the IDs stored in the object.

Definition at line 38 of file tco_collection.interface.php.

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Function Documentation

◆ _scrub()

◆ _set_up_container()

◆ appendElement()

◆ appendElements()

◆ areYouMyDaddy()

◆ children()

◆ children_ids()

◆ count()

◆ deleteAllChildren()

◆ deleteElement()

◆ deleteElements()

◆ deleteThisElement()

◆ getHierarchy()

◆ indexOfThisElement()

◆ insertElement()

◆ insertElements()

◆ map()

◆ recursiveMap()

◆ reload_collection()

◆ set_children_ids()

◆ who_are_my_parents()

◆ whosYourDaddy()

Member Data Documentation

◆ $_container