Load debugger breakpoints from the storage. Returns a 2-arity array
with the debuggee id and the list of breakpoints.

@return array
772741
public function load()
    {
        $debuggeeId = null;
        $breakpoints = [];

        // Acquire a read lock (non-blocking). If we fail (file is locked
        // for writing), then we return an empty list of breakpoints and
        // skip debugging for this request.
        try {
            $contents = $this->getLock()->synchronize(function () {
                return file_get_contents($this->filename);
            }, [
                'blocking' => false
            ]);
            $data = unserialize($contents);
            $debuggeeId = $data['debuggeeId'];
            $breakpoints = $data['breakpoints'];
        } catch (\RuntimeException $e) {
            // Do nothing
        }
        return [$debuggeeId, $breakpoints];
    }
778134
public function debug()
    {
        // call TransformationMixin functions
        $json_response = $this->sendDebug($this->transform_url,
            $this->api_key, $this->security);

        return $json_response;
    }
709340
public function getDatabases()
    {
        $data = [];

        foreach ($this->getMonitoredDatabases() as $db) {
            $data[] = ['connection' => $db['connection'],
                       'alert_greater_than_mb' => $db['alert_greater_than_mb'],
                       'alert_less_than_mb' => $db['alert_less_than_mb'],
                       'driver' => $this->getDriverName($db['connection']),
                       'status' => $this->checkDatabaseStatus($db['connection']),
                       'size' => $this->getDatabaseSize($db['connection'])];
        }

        return $data;
    }
938445
public function debug() {
		return array(
			'id'         => $this->id(),
			'name'       => strtolower(substr(get_class($this), strlen('elfinderdriver'))),
			'mimeDetect' => $this->mimeDetect,
			'imgLib'     => $this->imgLib
		);
	}
1130869
public org.tensorflow.framework.DebugOptions getDebugOptions() {
    return debugOptions_ == null ? org.tensorflow.framework.DebugOptions.getDefaultInstance() : debugOptions_;
  }
443503
private function initBreakpoints() {
        $this->breakpoints[0]   = -1;
        $this->breakpoints[1]   = -1;
        $this->breakpoints[2]   = array( -0.43, 0.43 );
        $this->breakpoints[3]   = array( -0.67, 0, 0.67 );
        $this->breakpoints[4]   = array( -0.84, -0.25, 0.25, 0.84 );
        $this->breakpoints[5]   = array( -0.97, -0.43, 0, 0.43, 0.97 );
        $this->breakpoints[6]   = array( -1.07, -0.57, -0.18, 0.18, 0.57, 1.07 );
        $this->breakpoints[7]   = array( -1.15, -0.67, -0.32, 0, 0.32, 0.67, 1.15 );
        $this->breakpoints[8]   = array( -1.22, -0.76, -0.43, -0.14, 0.14, 0.43, 0.76, 1.22 );
        $this->breakpoints[9]   = array( -1.28, -0.84, -0.52, -0.25, 0, 0.25, 0.52, 0.84, 1.28 );
    }
1370781
protected function getCliParams() {
		if (empty($_SERVER['argv'])) {
			return [];
		}
		
		$params = preg_grep('/^\-\-zdebug:/', $_SERVER['argv']);
		
		if (empty($params)) {
			return [];
		}
		
		return array_map(function($in) {
			return str_replace('--zdebug:', '', $in);
		}, $params);
	}
952319
public function toArray()
	{
		return [
			'points' => SerializationHelper::serialize($this->points),
			'extensions' => SerializationHelper::serialize($this->extensions),
			'stats' => SerializationHelper::serialize($this->stats)
		];
	}
606894
public function debugInfo()
    {
        return [
            'exists' => $this->exists(),
            'isFile' => $this->isFile(),
            'isImage' => $this->isImage(),
            'path' => $this->path,
            'lastModified' => $this->lastModified,
            'name' => $this->name,
            'dir' => $this->dir,
            'mimeType' => $this->mimeType,
            'extension' => $this->extension,
            'size' => $this->size,
            'type' => $this->type,
            'getFullName' => $this->getFullName()
        ];
    }
656671
protected function getTrace()
    {
        $backtrace = debug_backtrace();
        $index = null;
        $hasNull = false;
        $realClassName = static::__getRealClassName();
        foreach($backtrace as $i => $item)
        {
            if($realClassName === $item['class'])
            {
                $index = $i + 2;
                break;
            }
        }
        if(null === $index)
        {
            return [];
        }
        return array_splice($backtrace, $index);
    }
1016148
public function debug() {
        echo "filePath    = " . $this->filePath . PHP_EOL;
        echo "startMarker = " . $this->startMarker . PHP_EOL;
        echo "endMarker   = " . $this->endMarker . PHP_EOL;
        echo "startIndex  = " . $this->startIndex . PHP_EOL;
        echo "endIndex    = " . $this->endIndex . PHP_EOL;
        echo "numLines    = " . $this->numLines . PHP_EOL;
        echo "Start       = " . print_r($this->beforeLines, true);
        echo "Auto      = " . print_r($this->autoLines, true);
        echo "End         = " . print_r($this->afterLines, true);
        return $this;
    }
275084
public function getResults()
    {
        $results = array();

        $this->debugStart();

        $executeResults = $this->executeGetResults();

        $this->debugStop();

        foreach ($executeResults as $result) {
            $r = $this->getResult($result);
            if ($r != null) {
                $results[] = $r;
            }
        }

        return $results;
    }
784312
public function debug() {
		$debug = parent::debug();
		$debug['sqlCount'] = $this->sqlCnt;
		if ($this->dbError) {
			$debug['dbError'] = $this->dbError;
		}
		return $debug;
	}
279941
public function getLoadingInRounds(): LoadingInRounds
    {
        if ($this->loadingInRounds === null) {
            $loadingInRoundsValue = 0;
            if ($this->weaponlike instanceof RangedWeaponCode) {
                $loadingInRoundsValue = $this->armourer->getLoadingInRoundsByStrengthWithRangedWeapon(
                    $this->weaponlike,
                    $this->getStrengthForWeaponlike()
                );
            }

            $this->loadingInRounds = LoadingInRounds::getIt($loadingInRoundsValue);
        }

        return $this->loadingInRounds;
    }
438946
public function debug()
    {
        $info = array();

        $metadata = $this->getMetadata();

        $referenceFields = array();
        foreach (array_merge($metadata['referencesOne'], $metadata['referencesMany']) as $name => $reference) {
            $referenceFields[] = $reference['field'];
        }

        // fields
        foreach ($metadata['fields'] as $name => $field) {
            if (in_array($name, $referenceFields)) {
                continue;
            }
            $info['fields'][$name] = $this->{'get'.ucfirst($name)}();
        }

        // referencesOne
        foreach ($metadata['referencesOne'] as $name => $referenceOne) {
            $info['referencesOne'][$name] = $this->{'get'.ucfirst($referenceOne['field'])}();
        }

        // referencesMany
        foreach ($metadata['referencesMany'] as $name => $referenceMany) {
            $info['referencesMany'][$name] = $this->{'get'.ucfirst($referenceMany['field'])}();
        }

        // embeddedsOne
        foreach ($metadata['embeddedsOne'] as $name => $embeddedOne) {
            $embedded = $this->{'get'.ucfirst($name)}();
            $info['embeddedsOne'][$name] = $embedded ? $embedded->debug() : null;
        }

        // embeddedsMany
        foreach ($metadata['embeddedsMany'] as $name => $embeddedMany) {
            $info['embeddedsMany'][$name] = array();
            foreach ($this->{'get'.ucfirst($name)}() as $key => $value) {
                $info['embeddedsMany'][$name][$key] = $value->debug();
            }
        }

        return $info;
    }
188049
protected static function get_core_eventlist() {
        global $CFG;

        // Disable developer debugging as deprecated events will fire warnings.
        // Setup backup variables to restore the following settings back to what they were when we are finished.
        $debuglevel          = $CFG->debug;
        $debugdisplay        = $CFG->debugdisplay;
        $debugdeveloper      = $CFG->debugdeveloper;
        $CFG->debug          = 0;
        $CFG->debugdisplay   = false;
        $CFG->debugdeveloper = false;

        $eventinformation = array();
        $directory = $CFG->libdir . '/classes/event';
        $files = self::get_file_list($directory);

        // Remove exceptional events that will cause problems being displayed.
        if (isset($files['unknown_logged'])) {
            unset($files['unknown_logged']);
        }
        foreach ($files as $file => $location) {
            $classname = '\\core\\event\\' . $file;
            // Check to see if this is actually a valid event.
            if (method_exists($classname, 'get_static_info')) {
                $ref = new \ReflectionClass($classname);
                // Ignore abstracts.
                if (!$ref->isAbstract() && $file != 'manager') {
                    $eventinformation[$classname] = $classname::get_name_with_info();
                }
            }
        }
        // Now enable developer debugging as event information has been retrieved.
        $CFG->debug          = $debuglevel;
        $CFG->debugdisplay   = $debugdisplay;
        $CFG->debugdeveloper = $debugdeveloper;
        return $eventinformation;
    }
379755
public List<BreakpointMessageInterface> getBreakpointsEnabledList() {
		if (mode.equals(Mode.safe)) {
			return new ArrayList<>();
		}
		return getBreakpointsModel().getBreakpointsEnabledList();
	}