Swipes internal structures
@return void
325388
public function cleanup()
    {
        $this->cleaned = true;
        $this->remoteMethods = [];
        $this->localMethods = [];
        $this->persistentCallbacks = [];
        $this->callbacks = [];
    }
1111247
public function run()
	{
		$clip=ob_get_clean();
		if($this->renderClip)
			echo $clip;
		$this->getController()->getClips()->add($this->getId(),$clip);
	}
480549
protected function setUp(): void
    {
        parent::setUp();

        $this->invalidStructure = [
            T_ARRAY => [T_OPEN_PARENTHESIS, T_CLOSE_PARENTHESIS],
            T_OPEN_SHORT_ARRAY => [T_CLOSE_SHORT_ARRAY]
        ];
    }
39915
public function snapshot()
    {
        collect($this->measuredJobs())->each(function ($job) {
            $this->storeSnapshotForJob($job);
        });

        collect($this->measuredQueues())->each(function ($queue) {
            $this->storeSnapshotForQueue($queue);
        });

        $this->storeSnapshotTimestamp();
    }
718855
protected function doProcess()
    {
        $links = $this->links;

        foreach ($this->getTouchArray() as $touchIcon) {
            $links->add($touchIcon);
        }

        foreach (['icon', 'shortcut icon'] as $rel) {
            $links->add(
                [
                    'rel'  => $rel,
                    'href' => $this->getFavicon()
                ]
            );
        }

        return true;
    }
1313111
public static function touchDo() {
		foreach (static::$_lTouch as $sKey => $iExpire) {
			static::conn()->touch($sKey, $iExpire);
		}
		static::$_lTouch = [];
	}
1074986
public function index(): void
    {
        $menus = $this->Menus->find('all');

        $this->set(compact('menus'));
        $this->set('_serialize', ['navMenu']);
    }
251352
public function touchOwners()
    {
        foreach ($this->touches as $relation) {
            $this->$relation()->touch();

            if (! is_null($this->$relation)) {
                $this->$relation->touchOwners();
            }
        }
    }
1152626
private function handleSwish() : void
  {
    if (!class_exists(RouterResolver::class)) throw new RouterUnhandledException;

    SwishHandler::setNamespace((new RouterResolver)->getNamespace());
    SwishHandler::fail($this->swishFails());
    SwishHandler::before($this->swishBefore());
    SwishHandler::after($this->swishAfter());
    SwishHandler::view($this->swishView());
  }
806891
protected function initialize(): void
    {
        if ($this->result === null) {
            $queryBuilder = $this->elasticSearchQuery->getQueryBuilder();
            $this->result = $queryBuilder->fetch();
            $this->nodes = $this->result['nodes'];
            $this->count = $queryBuilder->getTotalItems();
        }
    }
218750
public function init()
    {
        $pages = $this->getModel()->getPages();

        // Check datas
        if (empty($pages)) {
            return;
        }

        global $admin_page_hooks;

        // Set the internal pointer of an array to its first element
        reset($pages);

        // Update identifier
        $identifier = Helpers::urlize(key($pages));
        $this->getModel()->setIdentifier($identifier);

        // Add root single menu if identifier is unknown
        if (!isset($admin_page_hooks[$identifier])) {
            $this->addRootPage();
        }

        // Iterate on pages
        foreach ($pages as $slug => $options) {
            if (empty($options)) {
                continue;
            }

            // Get slug
            $slug = Helpers::urlize($slug);

            // Add child menu
            $this->addChild($slug, $options);
        }
    }
528550
protected function buildStructuredHeaders(): void
    {
        $this->structuredHeaders = array();
        $headers = $this->entry[PoTokens::TRANSLATED];
        $headers = ($headers === null) ? array() : $headers;
        $full = implode('', $headers);
        $headers = explode("\n", $full);
        // split on ':'
        $pattern = '/([a-z0-9\-]+):\s*(.*)/i';
        foreach ($headers as $h) {
            if (preg_match($pattern, trim($h), $matches)) {
                $this->structuredHeaders[strtolower($matches[1])] = array(
                    'key' => $matches[1],
                    'value' => $matches[2],
                );
            }
        }
    }
101212
public function touchIfTouching()
    {
        if ($this->touchingParent()) $this->getParent()->touch();

        if ($this->getParent()->touches($this->relation)) $this->touch();
    }
1174857
public function index()
    {
        $this->loadModel('Menu.MenuLinks');
        $links = $this->MenuLinks
            ->find('threaded')
            ->where([
                'parent_id IN' => $this->MenuLinks
                    ->find()
                    ->select(['id'])
                    ->where(['url' => '/admin/system/structure'])
            ])
            ->all();

        $this->title(__d('system', 'Site’s Structure'));
        $this->set('links', $links);
        $this->Breadcrumb->push('/admin/system/structure');
    }
113748
protected function processTags()
	{
		if (empty($this->tagStack))
		{
			return;
		}

		// Initialize the count tables
		foreach (array_keys($this->tagsConfig) as $tagName)
		{
			$this->cntOpen[$tagName]  = 0;
			$this->cntTotal[$tagName] = 0;
		}

		// Process the tag stack, close tags that were left open and repeat until done
		do
		{
			while (!empty($this->tagStack))
			{
				if (!$this->tagStackIsSorted)
				{
					$this->sortTags();
				}

				$this->currentTag = array_pop($this->tagStack);
				$this->processCurrentTag();
			}

			// Close tags that were left open
			foreach ($this->openTags as $startTag)
			{
				// NOTE: we add tags in hierarchical order (ancestors to descendants) but since
				//       the stack is processed in LIFO order, it means that tags get closed in
				//       the correct order, from descendants to ancestors
				$this->addMagicEndTag($startTag, $this->textLen);
			}
		}
		while (!empty($this->tagStack));
	}
1265230
public function init()
    {
        parent::init();
        $this->stepCallback = $this->add(['Callback', 'urlTrigger'=>$this->name]);

        $this->currentStep = $this->stepCallback->triggered() ?: 0;

        $this->stepTemplate = $this->template->cloneRegion('Step');
        $this->template->del('Step');

        // add buttons
        if ($this->currentStep) {
            $this->buttonPrev = $this->add(['Button', 'Back', 'basic'], 'Left');
            $this->buttonPrev->link($this->stepCallback->getURL($this->currentStep - 1));
        }

        $this->buttonNext = $this->add(['Button', 'Next', 'primary'], 'Right');
        $this->buttonFinish = $this->add(['Button', 'Finish', 'primary'], 'Right');

        $this->buttonNext->link($this->stepCallback->getURL($this->currentStep + 1));
    }
1252951
public function index() {

        /**
         * set lastUpdatedPage
         */
        $query = TableRegistry::get('CmsContent')->find();
        $query->where(['content_type' => 'page']);
        $query->order(['modified' => 'DESC']);
        $this->set('last_page', $query);

        /**
         * set lastUpdatedNews
         */
        $query = TableRegistry::get('CmsContent')->find();
        $query->where(['content_type' => 'news']);
        $query->order(['modified' => 'DESC']);
        $this->set('last_news', $query);

        /**
         * set view
         */
        $this->viewBuilder()->template('dashboard');
    }