_id
stringlengths 2
7
| title
stringlengths 3
151
| partition
stringclasses 3
values | text
stringlengths 83
13k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q267800
|
Reaction.initStaticApp
|
test
|
public static function initStaticApp()
{
$config = static::getConfigReader()->get('appStatic');
$config['class'] = StaticApplicationInterface::class;
//Use config after creation, so Reaction::$app will be available inside StaticApplicationInterface components
$appLateConfig = [];
$appLateConfigKeys = ['components'];
foreach ($appLateConfigKeys as $appKey) {
if (isset($config[$appKey])) {
$appLateConfig[$appKey] = $config[$appKey];
unset($config[$appKey]);
}
}
static::$app = static::create($config);
Container::setDefaultServiceLocator(static::$app);
if (!empty($appLateConfig)) {
static::configure(static::$app, $appLateConfig);
}
}
|
php
|
{
"resource": ""
}
|
q267801
|
CSRFGuard.tokensMatch
|
test
|
protected function tokensMatch(Request $request)
{
$token = $this->getTokenFromRequest($request);
$storedToken = $this->getToken();
return is_string($storedToken) &&
is_string($token) &&
hash_equals($storedToken, $token);
}
|
php
|
{
"resource": ""
}
|
q267802
|
CSRFGuard.getTokenFromRequest
|
test
|
protected function getTokenFromRequest(Request $request)
{
$token = $request->getParameter($this->key) ?: $request->getHeader('X-CSRF-TOKEN');
return $token;
}
|
php
|
{
"resource": ""
}
|
q267803
|
DarkSkyPlugin.init
|
test
|
public function init()
{
$config = $this->getConfig();
if (!isset($config['api_key'])) {
throw new \Exception('Unable to locate darksky_api_key in bot configuration.');
}
$this->darksky = new \DarkSky($config['api_key']);
$plugin = $this; // PHP 5.3, you suck.
// Look at all this weather!
$this->bot->onChannel('/^!ds (\w+)(.*)/', function(Event $event) use ($plugin) {
$matches = $event->getMatches();
switch($cmd = $matches[0]) {
case 'now':
case 'current':
$plugin->getCurrentWeather(trim($matches[1]), $event);
break;
case 'forecast':
case 'at':
$plugin->getPrecipitation(trim($matches[1]), $event);
break;
default:
$plugin->addErrorMsg($event, "Unknown command: $cmd");
break;
}
});
}
|
php
|
{
"resource": ""
}
|
q267804
|
DarkSkyPlugin.getCurrentWeather
|
test
|
public function getCurrentWeather($where, $event)
{
if (!$found = $this->getLatLongForLocation($where)) {
$this->addLatLongError($event);
return;
}
try {
list($lat, $long) = $found;
$forecast = $this->darksky->getBriefForecast($lat, $long);
$event->addResponse(
Response::msg(
$event->getRequest()->getSource(),
sprintf('[Weather for %s] Currently: %s, %s degrees. For the next hour: %s',
$where,
$forecast['currentSummary'],
$forecast['currentTemp'],
$forecast['hourSummary']
)
)
);
} catch (\Exception $ex) {
$this->addErrorMsg($event, "Oops, I'm unable to get the weather for that location...");
return;
}
}
|
php
|
{
"resource": ""
}
|
q267805
|
DarkSkyPlugin.getPrecipitation
|
test
|
public function getPrecipitation($match, $event)
{
$location = explode('@', $match);
$where = trim($location[0]);
$when = trim($location[1]);
if (!$found = $this->getLatLongForLocation($where)) {
$this->addLatLongError($event);
return;
}
try {
$time = new \DateTime($when);
list($lat, $long) = $found;
$precipitation = $this->darksky->getPrecipitation(array(
'lat' => $lat,
'long' => $long,
'time' => $time->getTimestamp()
));
$chanceOfRain = $precipitation['precipitation'][0]['probability'] * 100;
$intensity = $precipitation['precipitation'][0]['intensity'];
$event->addResponse(
Response::msg(
$event->getRequest()->getSource(),
sprintf('[Weather for %s @ %s] %s (%d%% chance of rain)',
$where,
$time->format('g:ia'),
$this->getEnglishIntensity($intensity),
$chanceOfRain
)
)
);
} catch (\Exception $ex) {
$this->addErrorMsg($event, "Oops. I'm unable to get the precipitation for that location at that time...");
return;
}
}
|
php
|
{
"resource": ""
}
|
q267806
|
DarkSkyPlugin.getLatLongForLocation
|
test
|
public function getLatLongForLocation($location)
{
$encoded = urlencode($location);
$response = json_decode(
file_get_contents("http://maps.googleapis.com/maps/api/geocode/json?sensor=false&address=$encoded"),
true
);
if ($response['status'] === 'OK') {
$lat = $response['results'][0]['geometry']['location']['lat'];
$long = $response['results'][0]['geometry']['location']['lng'];
return array($lat, $long);
}
return false;
}
|
php
|
{
"resource": ""
}
|
q267807
|
DarkSkyPlugin.addErrorMsg
|
test
|
public function addErrorMsg($event, $msg)
{
$event->addResponse(Response::msg($event->getRequest()->getSource(), $msg));
}
|
php
|
{
"resource": ""
}
|
q267808
|
DarkSkyPlugin.getEnglishIntensity
|
test
|
private function getEnglishIntensity($intensity)
{
$desc = 'no';
if ($intensity >= 2 && $intensity < 15) {
$desc = 'sporadic';
} else if ($intensity >= 15 && $intensity < 30) {
$desc = 'light';
} else if ($intensity >= 30 && $intensity < 45) {
$desc = 'moderate';
} else if ($intensity > 45) {
$desc = 'heavy';
}
return $desc . ' rain';
}
|
php
|
{
"resource": ""
}
|
q267809
|
NativeAnnotations.classAnnotations
|
test
|
public function classAnnotations(string $class): array
{
$index = static::CLASS_CACHE . $class;
return self::$annotations[$index]
?? self::$annotations[$index] = $this->setAnnotationValues(
[
'class' => $class,
],
...$this->parser->getAnnotations(
$this->getClassReflection($class)->getDocComment()
)
);
}
|
php
|
{
"resource": ""
}
|
q267810
|
NativeAnnotations.classMembersAnnotations
|
test
|
public function classMembersAnnotations(string $class): array
{
$index = static::CLASS_MEMBERS_CACHE . $class;
if (isset(self::$annotations[$index])) {
return self::$annotations[$index];
}
return self::$annotations[$index] = array_merge(
$this->propertiesAnnotations($class),
$this->methodsAnnotations($class)
);
}
|
php
|
{
"resource": ""
}
|
q267811
|
NativeAnnotations.classAndMembersAnnotations
|
test
|
public function classAndMembersAnnotations(string $class): array
{
$index = static::CLASS_AND_MEMBERS_CACHE . $class;
if (isset(self::$annotations[$index])) {
return self::$annotations[$index];
}
return self::$annotations[$index] = array_merge(
$this->classAnnotations($class),
$this->classMembersAnnotations($class)
);
}
|
php
|
{
"resource": ""
}
|
q267812
|
NativeAnnotations.propertyAnnotations
|
test
|
public function propertyAnnotations(string $class, string $property): array
{
$index = static::PROPERTY_CACHE . $class . $property;
return self::$annotations[$index]
?? self::$annotations[$index] = $this->setAnnotationValues(
[
'class' => $class,
'property' => $property,
],
...$this->parser->getAnnotations(
$this->getPropertyReflection($class, $property)->getDocComment()
)
);
}
|
php
|
{
"resource": ""
}
|
q267813
|
NativeAnnotations.propertyAnnotationsType
|
test
|
public function propertyAnnotationsType(string $type, string $class, string $property): array
{
return $this->filterAnnotationsByType(
$type,
...$this->propertyAnnotations(
$class,
$property
)
);
}
|
php
|
{
"resource": ""
}
|
q267814
|
NativeAnnotations.propertiesAnnotations
|
test
|
public function propertiesAnnotations(string $class): array
{
$index = static::PROPERTIES_CACHE . $class;
if (isset(self::$annotations[$index])) {
return self::$annotations[$index];
}
$annotations = [];
// Get the class's reflection
$reflection = $this->getClassReflection($class);
// Iterate through the properties
foreach ($reflection->getProperties() as $property) {
$index = static::METHOD_CACHE . $class . $property->getName();
// Set the property's reflection class in the cache
self::$reflections[$index] = $property;
// Iterate through all the property's annotations
foreach ($this->propertyAnnotations(
$class,
$property->getName()
) as $propertyAnnotation) {
// Set the annotation in the list
$annotations[] = $propertyAnnotation;
}
}
self::$annotations[$index] = $annotations;
return $annotations;
}
|
php
|
{
"resource": ""
}
|
q267815
|
NativeAnnotations.methodAnnotations
|
test
|
public function methodAnnotations(string $class, string $method): array
{
$index = static::METHOD_CACHE . $class . $method;
$reflection = $this->getMethodReflection($class, $method);
return self::$annotations[$index]
?? self::$annotations[$index] = $this->setAnnotationValues(
[
'class' => $class,
'method' => $method,
],
...$this->getReflectionFunctionAnnotations(
$reflection
)
);
}
|
php
|
{
"resource": ""
}
|
q267816
|
NativeAnnotations.methodAnnotationsType
|
test
|
public function methodAnnotationsType(string $type, string $class, string $method): array
{
return $this->filterAnnotationsByType(
$type,
...$this->methodAnnotations(
$class,
$method
)
);
}
|
php
|
{
"resource": ""
}
|
q267817
|
NativeAnnotations.methodsAnnotations
|
test
|
public function methodsAnnotations(string $class): array
{
$index = static::METHODS_CACHE . $class;
if (isset(self::$annotations[$index])) {
return self::$annotations[$index];
}
$annotations = [];
// Get the class's reflection
$reflection = $this->getClassReflection($class);
// Iterate through the methods
foreach ($reflection->getMethods() as $method) {
$index = static::METHOD_CACHE . $class . $method->getName();
// Set the method's reflection class in the cache
self::$reflections[$index] = $method;
// Iterate through all the method's annotations
foreach ($this->methodAnnotations(
$class,
$method->getName()
) as $methodAnnotation) {
// Set the annotation in the list
$annotations[] = $methodAnnotation;
}
}
self::$annotations[$index] = $annotations;
return $annotations;
}
|
php
|
{
"resource": ""
}
|
q267818
|
NativeAnnotations.functionAnnotations
|
test
|
public function functionAnnotations(string $function): array
{
$index = static::FUNCTION_CACHE . $function;
return self::$annotations[$index]
?? self::$annotations[$index] = $this->setAnnotationValues(
[
'function' => $function,
],
...$this->getReflectionFunctionAnnotations(
$this->getFunctionReflection($function)
)
);
}
|
php
|
{
"resource": ""
}
|
q267819
|
NativeAnnotations.filterAnnotationsByType
|
test
|
public function filterAnnotationsByType(string $type, Annotation ...$annotations): array
{
// Set a list of annotations to return
$annotationsList = [];
// Iterate through the annotation
foreach ($annotations as $annotation) {
// If the annotation's type matches the type requested
if ($annotation->getAnnotationType() === $type) {
// Set the annotation in the list
$annotationsList[] = $annotation;
}
}
return $annotationsList;
}
|
php
|
{
"resource": ""
}
|
q267820
|
NativeAnnotations.setAnnotationValues
|
test
|
protected function setAnnotationValues(array $properties, Annotation ...$annotations): array
{
foreach ($annotations as $annotation) {
$annotation->setClass($properties['class'] ?? null);
$annotation->setProperty($properties['property'] ?? null);
$annotation->setMethod($properties['method'] ?? null);
$annotation->setFunction($properties['function'] ?? null);
}
return $annotations;
}
|
php
|
{
"resource": ""
}
|
q267821
|
NativeAnnotations.getClassReflection
|
test
|
public function getClassReflection(string $class): ReflectionClass
{
$index = static::CLASS_CACHE . $class;
return self::$reflections[$index]
?? self::$reflections[$index] = new ReflectionClass($class);
}
|
php
|
{
"resource": ""
}
|
q267822
|
NativeAnnotations.getPropertyReflection
|
test
|
public function getPropertyReflection(string $class, string $property): ReflectionProperty
{
$index = static::PROPERTY_CACHE . $class . $property;
return self::$reflections[$index]
?? self::$reflections[$index] =
new ReflectionProperty($class, $property);
}
|
php
|
{
"resource": ""
}
|
q267823
|
NativeAnnotations.getMethodReflection
|
test
|
public function getMethodReflection(string $class, string $method): ReflectionMethod
{
$index = static::METHOD_CACHE . $class . $method;
return self::$reflections[$index]
?? self::$reflections[$index] =
new ReflectionMethod($class, $method);
}
|
php
|
{
"resource": ""
}
|
q267824
|
NativeAnnotations.getFunctionReflection
|
test
|
public function getFunctionReflection(string $function): ReflectionFunction
{
$index = static::FUNCTION_CACHE . $function;
return self::$reflections[$index]
?? self::$reflections[$index] = new ReflectionFunction($function);
}
|
php
|
{
"resource": ""
}
|
q267825
|
NativeAnnotations.getDependencies
|
test
|
protected function getDependencies(ReflectionParameter ...$parameters): array
{
// Setup to find any injectable objects through the service container
$dependencies = [];
// Iterate through the method's parameters
foreach ($parameters as $parameter) {
// We only care for classes
if ($parameter->getClass()) {
// Set the injectable in the array
$dependencies[] = $parameter->getClass()->getName();
}
}
return $dependencies;
}
|
php
|
{
"resource": ""
}
|
q267826
|
Segment.getLength
|
test
|
public function getLength()
{
return sqrt(
pow(($this->getPointB()->getAbscissa() - $this->getPointA()->getAbscissa()), 2)
+
pow(($this->getPointB()->getOrdinate() - $this->getPointA()->getOrdinate()), 2)
);
}
|
php
|
{
"resource": ""
}
|
q267827
|
Segment.getCenter
|
test
|
public function getCenter()
{
$abscissas = array(
$this->getPointA()->getAbscissa(), $this->getPointB()->getAbscissa()
);
$ordinates = array(
$this->getPointA()->getOrdinate(), $this->getPointB()->getOrdinate()
);
return new Point(
((max($abscissas) - min($abscissas)) / 2),
((max($ordinates) - min($ordinates)) / 2)
);
}
|
php
|
{
"resource": ""
}
|
q267828
|
ActiveForm.run
|
test
|
public function run()
{
if (!empty($this->_fields)) {
throw new InvalidCallException('Each beginField() should have a matching endField() call.');
}
$content = ob_get_clean();
echo $this->htmlHlp->beginForm($this->action, $this->method, $this->options);
echo $content;
if ($this->enableClientScript) {
$this->registerClientScript();
}
echo $this->htmlHlp->endForm();
}
|
php
|
{
"resource": ""
}
|
q267829
|
ActiveForm.field
|
test
|
public function field($model, $attribute, $options = [])
{
$config = $this->fieldConfig;
if ($config instanceof \Closure) {
$config = call_user_func($config, $model, $attribute);
}
if (!isset($config['class'])) {
$config['class'] = $this->fieldClass;
}
return Reaction::create(ArrayHelper::merge($config, $options, [
'model' => $model,
'attribute' => $attribute,
'form' => $this,
]));
}
|
php
|
{
"resource": ""
}
|
q267830
|
Config.has
|
test
|
public function has($key)
{
if (strpos($key, '.') === false) {
return $this->hasByKey($key);
}
return $this->hasByPath($key);
}
|
php
|
{
"resource": ""
}
|
q267831
|
DirectoryModel.getDisplayDirname
|
test
|
public function getDisplayDirname()
{
$_dirname = $this->dirname;
if (empty($_dirname)) $_dirname = basename($this->getPath());
return ucwords( str_replace( '_', ' ', $_dirname ) );
}
|
php
|
{
"resource": ""
}
|
q267832
|
DirectoryModel.scanDir
|
test
|
public function scanDir($recursive = false)
{
if (!$this->exists()) return false;
$_dir = opendir($this->getPath().$this->dirname);
$data = array();
while ($entry = @readdir($_dir)) {
if (!in_array($entry, $this->ignore)) {
if (is_dir($this->getPath().$this->dirname.'/'.$entry)) {
if (true === $recursive){
$_new_dir = new DirectoryModel;
$_new_dir->setPath( $this->getPath().$this->dirname );
$_new_dir->setDirname( $entry );
$data[] = $_new_dir->scanDir( $recursive );
} else {
$data[] = $entry;
}
} else {
$data[] = $entry;
}
}
}
closedir($_dir);
return $data;
}
|
php
|
{
"resource": ""
}
|
q267833
|
Header.header
|
test
|
final public static function header($string, $replace = true, $http_response_code = null)
{
if ( !$headers = http\Header::parse($string) ) Returns;
$header = key($headers);
if ( $replace || !isset(self::$list[$header]) ) {
self::$list[$header] = array();
}
self::$list[$header][] = $string;
if ( strtolower($header) == 'location' ) $http_response_code = 302;
if ( $http_response_code ) self::$code = $http_response_code;
}
|
php
|
{
"resource": ""
}
|
q267834
|
Header.headers_list
|
test
|
final public static function headers_list()
{
$results = array();
foreach (self::$list as $headers) {
$results = array_merge($results, $headers);
}
return $results;
}
|
php
|
{
"resource": ""
}
|
q267835
|
DBOperator.createDB
|
test
|
public function createDB($DBName, $charset = 'utf8', $collation = 'utf8_unicode_ci') {
QC::executeSQL($this->generateDBSQL($DBName, $charset, $collation));
return $this;
}
|
php
|
{
"resource": ""
}
|
q267836
|
DBOperator.getDBTables
|
test
|
public function getDBTables($force_fetch = false) {
if ($this->_tables && !$force_fetch) return $this->_tables;
$res = QC::executeSQL('SHOW TABLES');
$this->_tables = array();
if ($res->rowCount()) {
$res = $res->fetchAll(\PDO::FETCH_NUM);
foreach($res as $info) {
$this->_tables[$info[0]] = array('name'=>$info[0]);
}
}
return $this->_tables;
}
|
php
|
{
"resource": ""
}
|
q267837
|
DBOperator.updateDBFromStructure
|
test
|
public function updateDBFromStructure($structure, $safeUpdate = true) {
$diffs = $this->getDifferenceSQL($structure);
if ($diffs['result'] === true) {
QC::executeSQL('SET FOREIGN_KEY_CHECKS = 0');
if (!empty($diffs['sql']['ADD'])) QC::executeArrayOfSQL($diffs['sql']['ADD']);
if (!empty($diffs['sql']['CHANGE'])) QC::executeArrayOfSQL($diffs['sql']['CHANGE']);
if (!empty($diffs['sql']['DROP']) && !$safeUpdate) QC::executeArrayOfSQL($diffs['sql']['DROP']);
}
}
|
php
|
{
"resource": ""
}
|
q267838
|
DBOperator.updateDBRelations
|
test
|
public function updateDBRelations($modelName, $structure) {
if (empty($structure['relations'])) return true;
foreach($structure['relations'] as $relationName => $relationInfo) {
$info = ModelOperator::calculateRelationVariables($modelName, $relationName);
switch($info['relationType']) {
case 'many_to_many':
$this->updateManyTable($info);
break;
case 'many_to_one':
break;
case 'one_to_many':
break;
}
}
}
|
php
|
{
"resource": ""
}
|
q267839
|
DBOperator.updateManyTable
|
test
|
public function updateManyTable($info) {
$structure = array(
'table' => $info['manyTable'],
'columns' => array(),
'indexes' => array(),
'constraints' => array(),
);
$localName = Inflector::singularize($info['localTable']);
$foreignName = Inflector::singularize($info['foreignTable']);
$structure['columns']['id'] = array('type' => 'int(11) unsigned', 'auto_increment'=>true);
$structure['columns']['id_'. $localName] = 'int(11) unsigned';
$structure['columns']['id_'. $foreignName] = 'int(11) unsigned';
$structure['indexes']['primary'] = array('columns'=>array('id'), 'type'=>'primary');
$structure['indexes']['unique_id_'.$localName.'_id_'.$foreignName] = array(
'columns' => array(
'id_'.$localName,
'id_'.$foreignName
),
'type' => 'unique'
);
$foreignKeysInfo = array(
'local_table' => $info['manyTable'],
'foreign_table' => $info['localTable'],
'local_field' => 'id_'.$localName,
'foreign_field' => $info['foreignKey']
);
$structure['constraints'][$this->generateForeignKeyName($foreignKeysInfo)] = $foreignKeysInfo;
$foreignKeysInfo = array(
'local_table' => $info['manyTable'],
'foreign_table' => $info['foreignTable'],
'local_field' => 'id_'.$foreignName,
'foreign_field' => $info['foreignKey']
);
$structure['constraints'][$this->generateForeignKeyName($foreignKeysInfo)] = $foreignKeysInfo;
$diffs = $this->getDifferenceSQL($structure, $info['manyTable']);
if ($diffs['result'] === true) {
QC::executeSQL('SET FOREIGN_KEY_CHECKS = 0');
if (!empty($diffs['sql']['ADD'])) {
try {
QC::executeArrayOfSQL($diffs['sql']['ADD']);
} catch(\Exception $e) {
var_dump($e->getMessage());die();
}
}
}
return $diffs['result'];
}
|
php
|
{
"resource": ""
}
|
q267840
|
DBOperator.generateTableSQL
|
test
|
public function generateTableSQL($structure) {
$sql = 'CREATE TABLE' . ' IF NOT EXISTS `' . $structure['table'].'` (' . "\n";
foreach($structure['columns'] as $column=>$info) {
if (!is_array($info)) $info = array('type'=>$info);
if (!isset($info['name'])) $info['name'] = $column;
if (!empty($info['virtual'])) continue;
$sql .= $this->generateColumnSQL($info).','."\n";
}
if (!empty($structure['indexes'])) {
foreach($structure['indexes'] as $name=>$info) {
if (!isset($info['name'])) $info['name'] = $name;
$sql .= $this->generateIndexSQL($info).','."\n";
}
}
if (!empty($structure['constraints'])) {
foreach($structure['constraints'] as $info) {
$info['local_table'] = $structure['table'];
$sql .= $this->generateConstraintSQL($info).','."\n";
}
}
$sql = substr($sql, 0, -2).')';
$sql .= ' ENGINE = '.(empty($info['engine']) ? 'INNODB' : $info['engine']).' CHARACTER SET='.(empty($info['charset']) ? 'utf8' : $info['charset']).' COLLATE='.(empty($info['collate']) ? 'utf8_unicode_ci' : $info['collate']);
return $sql;
}
|
php
|
{
"resource": ""
}
|
q267841
|
DBOperator.generateColumnSQL
|
test
|
private function generateColumnSQL($info) {
$sql = '';
if (isset($info['old_name'])) {
$sql = '`'.$info['old_name'].'` ';
}
$sql .= '`'.$info['name'].'` '.$this->getSQLTypeForField($info);
if (isset($info['unsigned'])) $sql .= ' unsigned';
if (isset($info['zerofill'])) $sql .= ' zerofill';
if (isset($info['auto_increment'])) {
$sql .= ' NOT NULL auto_increment';
} elseif (isset($info['default']) && (strpos($info['default'], '#sql#') === false)) {
$sql .= ' DEFAULT \''.$info['default']."'";
} elseif (isset($info['not_null'])) {
$sql .= ' NOT NULL';
}
//var_dump($sql);die();
return $sql;
}
|
php
|
{
"resource": ""
}
|
q267842
|
DBOperator.generateIndexSQL
|
test
|
private function generateIndexSQL($info) {
$keys = $info['columns'];
$sql = '';
if (!isset($info['type'])) $info['type'] = ($info['name'] == 'primary' ? 'primary' : 'simple');
switch ($info['type']) {
case 'primary':
$sql .= 'PRIMARY KEY (`'.(is_array($keys) ? implode('`, `', $keys) : $keys).'`)';
break;
case 'unique':
case 'simple':
$sql .= ($info['type'] == 'unique' ? 'UNIQUE ' : '').'KEY '.'`'.$info['name'].'` (`'.(is_array($keys) ? implode('`, `', $keys) : $keys).'`)';
break;
}
return $sql;
}
|
php
|
{
"resource": ""
}
|
q267843
|
DBOperator.generateConstraintSQL
|
test
|
private function generateConstraintSQL($info) {
$name = isset($info['name']) ? $info['name'] : $this->generateForeignKeyName($info);
$sql = 'CONSTRAINT `'.$name.'` FOREIGN KEY (`'.$info['local_field'].'`) REFERENCES `'
.$info['foreign_table'].'` (`'.$info['foreign_field'].'`) '.
'ON DELETE '.(empty($info['on_delete']) ? 'SET NULL' : $info['on_delete']).' ON UPDATE '.(empty($info['on_update']) ? 'CASCADE' : $info['on_update']);
return $sql;
}
|
php
|
{
"resource": ""
}
|
q267844
|
Keyvalue.getKeyvaluesByKeyType
|
test
|
public static function getKeyvaluesByKeyType($keyType)
{
if (empty($keyType)) {
// return empty array
return [];
}
$tableCache = static::tableToArray();
// Read through the entire table cache looking for keys that match
// the keyType
$result = [];
foreach ($tableCache as $key => $value) {
list($storedType, $storedValue) = explode('__', $key, 2);
if ($storedType == $keyType) {
$result[$value->keyvalue] = $value;
}
}
return $result;
}
|
php
|
{
"resource": ""
}
|
q267845
|
Keyvalue.getKeyValuesByType
|
test
|
public static function getKeyValuesByType($keyType)
{
$keyvalues = self::getKeyvaluesByKeyType($keyType);
// Sort through the enums of the found type and reformat those
// as a keyvalue => keyname list.
$list = [];
/** @var Keyvalue $keyvalue */
foreach ($keyvalues as $keyvalue) {
$list[$keyvalue->keyvalue] = $keyvalue->keyname;
}
return $list;
}
|
php
|
{
"resource": ""
}
|
q267846
|
AnnotationsReader.getClass
|
test
|
public function getClass($class, $refresh = false)
{
$reflector = $this->getClassReflection($class);
$cacheKey = $reflector->getName();
if (!$refresh && $this->cacheExists($cacheKey)) {
return $this->getFromCache($cacheKey);
}
/** @var array|null $annotations */
$annotations = $this->reader->getClassAnnotations($reflector);
$annotations = is_array($annotations) ? $annotations : [];
$this->setToCache($cacheKey, $annotations);
return $annotations;
}
|
php
|
{
"resource": ""
}
|
q267847
|
AnnotationsReader.getClassExact
|
test
|
public function getClassExact($class, $annotationClass, $refresh = false)
{
$annotations = $this->getClass($class, $refresh);
foreach ($annotations as $annotation) {
if ($annotation instanceof $annotationClass) {
return $annotation;
}
}
return null;
}
|
php
|
{
"resource": ""
}
|
q267848
|
AnnotationsReader.getProperty
|
test
|
public function getProperty($property, $class = null, $refresh = false)
{
$propertyReflection = $this->getPropertyReflection($property, $class);
$classReflection = $propertyReflection->getDeclaringClass();
$cacheKey = $classReflection->getName() . '$' . $propertyReflection->getName();
if (!$refresh && $this->cacheExists($cacheKey)) {
return $this->getFromCache($cacheKey);
}
/** @var array|null $annotations */
$annotations = $this->reader->getPropertyAnnotations($propertyReflection);
$annotations = is_array($annotations) ? $annotations : [];
$this->setToCache($cacheKey, $annotations);
return $annotations;
}
|
php
|
{
"resource": ""
}
|
q267849
|
AnnotationsReader.getPropertyExact
|
test
|
public function getPropertyExact($property, $annotationClass, $class = null, $refresh = false)
{
$annotations = $this->getProperty($property, $class, $refresh);
foreach ($annotations as $annotation) {
if ($annotation instanceof $annotationClass) {
return $annotation;
}
}
return null;
}
|
php
|
{
"resource": ""
}
|
q267850
|
AnnotationsReader.getMethod
|
test
|
public function getMethod($method, $class = null, $refresh = false)
{
$methodReflection = $this->getMethodReflection($method, $class);
$classReflection = $methodReflection->getDeclaringClass();
$cacheKey = $classReflection->getName() . '#' . $methodReflection->getName();
if (!$refresh && $this->cacheExists($cacheKey)) {
return $this->getFromCache($cacheKey);
}
/** @var array|null $annotations */
$annotations = $this->reader->getMethodAnnotations($methodReflection);
$annotations = is_array($annotations) ? $annotations : [];
$this->setToCache($cacheKey, $annotations);
return $annotations;
}
|
php
|
{
"resource": ""
}
|
q267851
|
AnnotationsReader.getMethodExact
|
test
|
public function getMethodExact($method, $annotationClass, $class = null, $refresh = false)
{
$annotations = $this->getMethod($method, $class, $refresh);
foreach ($annotations as $annotation) {
if ($annotation instanceof $annotationClass) {
return $annotation;
}
}
return null;
}
|
php
|
{
"resource": ""
}
|
q267852
|
AnnotationsReader.getReader
|
test
|
protected function getReader()
{
if (!isset($this->_reader)) {
ClassFinderHelper::findClassesPsr4($this->annotationNamespaces);
$this->_reader = new IndexedReader(new AnnotationReader());
}
return $this->_reader;
}
|
php
|
{
"resource": ""
}
|
q267853
|
AnnotationsReader.getMethodReflection
|
test
|
protected function getMethodReflection($method, $class = null)
{
if (is_object($method) && $method instanceof \ReflectionMethod) {
return $method;
}
if ($class === null) {
throw new InvalidArgumentException("Argument 'class' must be set");
}
return ReflectionHelper::getMethodReflection($class, $method);
}
|
php
|
{
"resource": ""
}
|
q267854
|
AnnotationsReader.getFromCache
|
test
|
protected function getFromCache($key)
{
return isset($this->_cache[$key]) ? $this->_cache[$key] : null;
}
|
php
|
{
"resource": ""
}
|
q267855
|
AnnotationsReader.setToCache
|
test
|
protected function setToCache($key, $value = null)
{
if (!isset($value)) {
unset($this->_cache[$value]);
return;
}
$this->_cache[$key] = $value;
}
|
php
|
{
"resource": ""
}
|
q267856
|
MockSettings.getPaths
|
test
|
private static function getPaths($key){
$paths = array();
$sourcePaths = explode(".", $key);
foreach ($sourcePaths as $sourcePath){
$subPaths = preg_split('/\[(.*?)\]/',$sourcePath,-1,PREG_SPLIT_NO_EMPTY|PREG_SPLIT_DELIM_CAPTURE);
if($subPaths !== FALSE){
$paths = array_merge($paths,$subPaths);
}
}
return $paths;
}
|
php
|
{
"resource": ""
}
|
q267857
|
ExtendedCache.processKey
|
test
|
protected function processKey($key) {
if (is_string($key)) {
return $key;
} else {
$keyStr = Json::encode($key);
return md5($keyStr);
}
}
|
php
|
{
"resource": ""
}
|
q267858
|
Observed.checkEventClassName
|
test
|
private function checkEventClassName(string $eventClassName): Observed
{
if (!\class_exists($eventClassName)) {
throw new \RuntimeException('Missing event class '.$eventClassName);
}
$interfacesList = \class_implements($eventClassName);
if (!isset($interfacesList['Teknoo\States\LifeCycle\Event\EventInterface'])) {
throw new \RuntimeException('The event class does not implement the EventInterface');
}
$this->eventClassName = $eventClassName;
return $this;
}
|
php
|
{
"resource": ""
}
|
q267859
|
Observed.buildEvent
|
test
|
private function buildEvent()
{
$currentEnabledStates = $this->getObject()->listEnabledStates();
$lastEnabledStates = $this->getLastEnabledStates();
//New state = current states - old states
$incomingStates = \array_diff($currentEnabledStates, $lastEnabledStates);
//Outgoing state = lst states - current states
$outgoingStates = \array_diff($lastEnabledStates, $currentEnabledStates);
$eventClassName = $this->eventClassName;
$this->lastEvent = new $eventClassName($this, $incomingStates, $outgoingStates);
return $this;
}
|
php
|
{
"resource": ""
}
|
q267860
|
ArrayTools.avg
|
test
|
public static function avg($array)
{
$total = 0;
foreach ($array as $value) {
if (is_numeric($value)) {
$total += $value;
}
}
return $total / count($array);
}
|
php
|
{
"resource": ""
}
|
q267861
|
QueryParameters.orderBy
|
test
|
public function orderBy($field, $direction = self::ASCENDING) {
$this->orderBy = [$field, $direction];
return $this;
}
|
php
|
{
"resource": ""
}
|
q267862
|
TypeHint.read
|
test
|
public function read()
{
if (is_null($constructor = $this->reflector->getConstructor())) {
return [];
}
$parameters = [];
foreach ($constructor->getParameters() as $reflectionParameter) {
/**
* @var \ReflectionParameter $parameter
*/
$parameter = [
"isClass" => ! is_null($reflectionParameter->getClass()),
"hasDefaultValue" => $reflectionParameter->isDefaultValueAvailable(),
];
if ($parameter["isClass"]) {
$parameter["value"] = $reflectionParameter->getClass()->getName();
}
if ($parameter["hasDefaultValue"]) {
$parameter["defaultValue"] = $reflectionParameter->getDefaultValue();
}
$parameters[] = $parameter;
}
return $parameters;
}
|
php
|
{
"resource": ""
}
|
q267863
|
PropertyAccessor.getValue
|
test
|
public function getValue($object, $path)
{
$paths = (array) preg_split('#(\[((?>[^\[\]]+)|(?R))*\])#i', $path, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
for ($i = 0; $i < count($paths); ++$i) {
$path = trim((string) $paths[$i], '.');
if ('[' == substr($path, 0, 1)) {
++$i;
}
if (preg_match('#[^a-z0-9\.\]\[]+#i', $path)) {
$expression = trim($path, '[]');
$object = $this->filter($object, $expression);
} else {
$object = $this->accessor->getValue($object, $path);
}
if (null === $object) {
break;
}
}
return $object;
}
|
php
|
{
"resource": ""
}
|
q267864
|
PropertyAccessor.setValue
|
test
|
public function setValue($object, $path, $value)
{
$this->accessor->setValue($object, $path, $value);
}
|
php
|
{
"resource": ""
}
|
q267865
|
PropertyAccessor.filter
|
test
|
public function filter(array $objects, $expression)
{
$filteredObjects = [];
foreach ($objects as $key => $object) {
try {
if (@$this->language->evaluate('object.'.$expression, ['object' => $object])) {
$filteredObjects[] = $object;
}
} catch (\Exception $exception) {
// Property does not exist: ignore this item
}
}
return $filteredObjects;
}
|
php
|
{
"resource": ""
}
|
q267866
|
PHPMailerMail.setFrom
|
test
|
public function setFrom(string $address, string $name = ''): bool
{
return $this->PHPMailer->setFrom($address, $name);
}
|
php
|
{
"resource": ""
}
|
q267867
|
PHPMailerMail.addAddress
|
test
|
public function addAddress(string $address, string $name = ''): bool
{
return $this->PHPMailer->addAddress($address, $name);
}
|
php
|
{
"resource": ""
}
|
q267868
|
PHPMailerMail.addReplyTo
|
test
|
public function addReplyTo(string $address, string $name = ''): bool
{
return $this->PHPMailer->addReplyTo($address, $name);
}
|
php
|
{
"resource": ""
}
|
q267869
|
PHPMailerMail.addCC
|
test
|
public function addCC(string $address, string $name = ''): bool
{
return $this->PHPMailer->addCC($address, $name);
}
|
php
|
{
"resource": ""
}
|
q267870
|
PHPMailerMail.addBCC
|
test
|
public function addBCC(string $address, string $name = ''): bool
{
return $this->PHPMailer->addBCC($address, $name);
}
|
php
|
{
"resource": ""
}
|
q267871
|
PHPMailerMail.addAttachment
|
test
|
public function addAttachment(string $path, string $name = ''): bool
{
return $this->PHPMailer->addAttachment($path, $name);
}
|
php
|
{
"resource": ""
}
|
q267872
|
CacheAllCommand.run
|
test
|
public function run(string $sync = null): int
{
$containerCache = console()->matchCommand(ContainerCacheCommand::COMMAND);
$consoleCache = console()->matchCommand(ConsoleCacheCommand::COMMAND);
$eventsCache = console()->matchCommand(EventsCacheCommand::COMMAND);
$routesCache = console()->matchCommand(RoutesCacheCommand::COMMAND);
console()->dispatchCommand($containerCache);
console()->dispatchCommand($consoleCache);
console()->dispatchCommand($eventsCache);
console()->dispatchCommand($routesCache);
$configCache = console()->matchCommand(ConfigCacheCommand::COMMAND);
console()->dispatchCommand($configCache);
if (null !== $sync && config()['app']['debug']) {
$files = [
config()['console']['cacheFilePath'],
config()['container']['cacheFilePath'],
config()['events']['cacheFilePath'],
config()['routing']['cacheFilePath'],
config()['cacheFilePath'],
];
foreach ($files as $file) {
copy($file, str_replace('site', 'sync', $file));
output()->writeMessage('Copied: ' . $file, true);
}
}
return 0;
}
|
php
|
{
"resource": ""
}
|
q267873
|
Router.setReferer
|
test
|
public static function setReferer($uri = null)
{
if (empty($uri)) $uri = UrlHelper::getRequestUrl();
CarteBlanche::getContainer()->get('session')->set('referer', $uri);
return true;
}
|
php
|
{
"resource": ""
}
|
q267874
|
Router.getReferer
|
test
|
public static function getReferer()
{
return (CarteBlanche::getContainer()->get('session')->has('referer') ?
CarteBlanche::getContainer()->get('session')->get('referer') : null);
}
|
php
|
{
"resource": ""
}
|
q267875
|
Router.buildUrl
|
test
|
public function buildUrl($param = null, $value = null, $separator = '&')
{
if (!is_array($param) && !empty($value)) {
$param = array( $param=>$value );
}
$default_args = array(
'controller' => CarteBlanche::getConfig('routing.mvc.default_controller'),
'action' => CarteBlanche::getConfig('routing.mvc.default_action')
);
if (!empty($param)) {
foreach ($param as $_var=>$_val) {
if (!empty($_val)) {
$_meth = 'fromUrl'.TextHelper::toCamelCase($_var);
if (method_exists($this, $_meth)) {
$_val = call_user_func_array(array($this, $_meth), array($_val));
}
if (array_key_exists($_var, $default_args) && (
$_val===$default_args[$_var] || strtolower($_val)===$default_args[$_var] || parent::urlEncode($_val)===$default_args[$_var]
)) {
unset($param[$_var]);
}
}
}
}
return parent::generateUrl($param, CarteBlanche::getPath('root_file'), '', $separator);
}
|
php
|
{
"resource": ""
}
|
q267876
|
DownSynchronizer.downloadPackage
|
test
|
protected function downloadPackage()
{
$this->crowdinClient->api('export')->execute();
$path = $this->createArchiveDirectory();
/** @var Download $download */
$download = $this->crowdinClient->api('download');
$download->setCopyDestination($path);
$download->setPackage(self::CROWDIN_PACKAGE);
$download->execute();
$this->archive->setFilename(self::CROWDIN_PACKAGE);
$this->archive->setPath($path);
}
|
php
|
{
"resource": ""
}
|
q267877
|
DownSynchronizer.extractPackage
|
test
|
protected function extractPackage($projectPath)
{
$this->archive->setExtractPath($projectPath);
$this->archive->extract()->remove();
}
|
php
|
{
"resource": ""
}
|
q267878
|
DownSynchronizer.resetDefaultLocaleTranslations
|
test
|
protected function resetDefaultLocaleTranslations()
{
$translations = $this->translationsFinder->getDefaultLocaleTranslations();
foreach ($translations as $translation) {
$this->gitHandler->reset($translation->getPathname());
}
}
|
php
|
{
"resource": ""
}
|
q267879
|
Request_With_Content_Types._strpos
|
test
|
protected function _strpos( $haystack, $needle ) {
return function_exists( 'mb_strpos' ) ? mb_strpos( $haystack, $needle ) : strpos( $haystack, $needle );
}
|
php
|
{
"resource": ""
}
|
q267880
|
BackendMenuBuilder.createSidebarMenu
|
test
|
public function createSidebarMenu(Request $request)
{
$menu = $this->factory->createItem('root', array(
'childrenAttributes' => array(
'class' => 'big-menu',
)
));
$section = 'sidebar';
$menu->addChild('home',array(
'route' => '',//Route
'labelAttributes' => array('icon' => 'icon-home'),
))->setLabel($this->translate(sprintf('app.backend.menu.%s.home', $section)));
$this->addExampleMenu($menu, $section);
$menu->addChild('support', array(
'route' => self::ROUTE_DEFAULT,
'labelAttributes' => array('icon' => 'icon-info'),
))->setLabel($this->translate(sprintf('app.backend.menu.%s.support', 'sidebar')));
return $menu;
}
|
php
|
{
"resource": ""
}
|
q267881
|
BackendMenuBuilder.addExampleMenu
|
test
|
function addExampleMenu(ItemInterface $menu, $section) {
$child = $this->factory->createItem('example',
$this->getSubLevelOptions(array(
'uri' => null,
'labelAttributes' => array('icon' => 'icon-book',),
))
)
->setLabel($this->translate(sprintf('app.backend.menu.%s.example.main', $section)));
$child
->addChild('example.company', array(
'route' => '',
))
->setLabel($this->translate(sprintf('app.backend.menu.%s.example.company', $section)));
$child
->addChild('example.technical_reports', array(
'route' => '',
))
->setLabel($this->translate(sprintf('app.backend.menu.%s.example.technical_reports', $section)));
$subchild = $this->factory->createItem('subexample',
$this->getSubLevelOptions(array(
'uri' => null,
'labelAttributes' => array('icon' => 'icon-book',),
))
)
->setLabel($this->translate(sprintf('app.backend.menu.%s.example.other.main', $section)));
$subchild
->addChild('example.other.admin', array(
'route' => self::ROUTE_DEFAULT,
))
->setLabel($this->translate(sprintf('app.backend.menu.%s.example.other.admin', $section)));
$subchild->addChild('example.other.groups', array(
'route' => self::ROUTE_DEFAULT,
))
->setLabel($this->translate(sprintf('app.backend.menu.%s.example.other.groups', $section)));
$child->addChild($subchild);
$menu->addChild($child);
}
|
php
|
{
"resource": ""
}
|
q267882
|
MigrationsServiceProvider.register
|
test
|
public function register() {
$this->loadEntitiesFrom(__DIR__);
$this->app->singleton('migration.repository', function($app) {
return new DoctrineMigrationRepository(
function() use($app) {
return $app->make(EntityManagerInterface::class);
},
function() use($app) {
return $app->make(SchemaTool::class);
},
function() use($app) {
return $app->make(ClassMetadataFactory::class);
}
);
});
$this->app->bind(MigrationRepositoryInterface::class, 'migration.repository');
}
|
php
|
{
"resource": ""
}
|
q267883
|
LiveFilesystemPublisher.publishPages
|
test
|
public function publishPages($urls)
{
LivePubHelper::init_pub();
$r = $this->realPublishPages($urls);
LivePubHelper::stop_pub();
return $r;
}
|
php
|
{
"resource": ""
}
|
q267884
|
Updater.update
|
test
|
public function update($params = array())
{
$this->adapter->execute($this->toSql(), array_merge($this->params(), $this->params(true), $params));
return true;
}
|
php
|
{
"resource": ""
}
|
q267885
|
GettextPoFile.load
|
test
|
public function load($context, $filePath = null)
{
if (isset($filePath)) {
$this->filePath = $filePath;
}
if (!isset($this->_messages)) {
$this->loadAll();
}
return isset($this->_messages[$context]) ? $this->_messages[$context] : [];
}
|
php
|
{
"resource": ""
}
|
q267886
|
GettextPoFile.getCategories
|
test
|
public function getCategories()
{
if (!isset($this->_messages)) {
$this->loadAll();
}
$categories = array_keys($this->_messages);
sort($categories);
return $categories;
}
|
php
|
{
"resource": ""
}
|
q267887
|
GetOrderInvoiceRequestHandler.getFileName
|
test
|
protected function getFileName(Response $response)
{
$headers = $response->getHeaders();
$contentDisposition = isset($headers['Content-Disposition'][0]) ? $headers['Content-Disposition'][0] : null;
if ($contentDisposition && preg_match('/filename="(.+)"/', $contentDisposition, $filename)) {
return $filename[1];
}
return null;
}
|
php
|
{
"resource": ""
}
|
q267888
|
NativeServerRequest.validateUploadedFiles
|
test
|
protected function validateUploadedFiles(array $uploadedFiles): void
{
foreach ($uploadedFiles as $file) {
if (\is_array($file)) {
$this->validateUploadedFiles($file);
continue;
}
if (! $file instanceof UploadedFile) {
throw new InvalidUploadedFile(
'Invalid leaf in uploaded files structure'
);
}
}
}
|
php
|
{
"resource": ""
}
|
q267889
|
AbstractDetection.initResultObject
|
test
|
protected function initResultObject()
{
if(!array_key_exists('default', $this->config)) {
return null;
}
// init default value from data
foreach ($this->config['default'] as $defaultKey => $defaultValue) {
Tools::runSetter($this->resultObject, $defaultKey, $defaultValue);
}
}
|
php
|
{
"resource": ""
}
|
q267890
|
AbstractDetection.getPattern
|
test
|
private function getPattern(string $patternId, array $patternData): array
{
if (array_key_exists('default', $patternData) && $patternData['default'] === true) {
return ['pattern' => sprintf('/%s/', $patternId), 'version' => $patternId];
}
return ['pattern' => sprintf('/%s/', $patternData['pattern']), 'version' => array_key_exists('version', $patternData) ? $patternData['version'] : $patternId];
}
|
php
|
{
"resource": ""
}
|
q267891
|
AbstractDetection.setAttributes
|
test
|
protected function setAttributes(array $info)
{
$result = $this->detector->getResultObject();
if (array_key_exists('attributes', $info)) {
foreach ($info['attributes'] as $attributeKey => $attributeValue) {
Tools::runSetter($result, $attributeKey, $attributeValue);
}
}
}
|
php
|
{
"resource": ""
}
|
q267892
|
AbstractDetection.detectByKey
|
test
|
protected function detectByKey($keyName = 'family'): array
{
foreach ($this->config as $key => $data) {
if ($key === 'default') {
continue;
}
$detectedData = $this->detectByType($key);
if (!empty($detectedData)) {
return array_merge($detectedData, [$keyName => $key]);
}
}
return [];
}
|
php
|
{
"resource": ""
}
|
q267893
|
Environment.onShell
|
test
|
public function onShell(): bool {
$check = true;
if (PHP_SAPI != Environment::SERVER_CLI) {
$check = false;
}
return $check;
}
|
php
|
{
"resource": ""
}
|
q267894
|
Base.getConfig
|
test
|
public function getConfig()
{
if (!isset($config)) {
$this->config = $this->getServiceLocator()->get('FzyCommon\Config');
}
return $this->config;
}
|
php
|
{
"resource": ""
}
|
q267895
|
Location.DMSLatitude
|
test
|
public function DMSLatitude($format = '%d %d %F %s') {
$lat = $this->convertDecToDMS($this->latitude());
$direction = 'N';
if ($lat['degrees'] < 0) {
$direction = 'S';
}
return sprintf($format, $lat['degrees'], $lat['minutes'], $lat['seconds'], $direction);
}
|
php
|
{
"resource": ""
}
|
q267896
|
Location.DMSLongitude
|
test
|
public function DMSLongitude($format = '%d %d %F %s') {
$long = $this->convertDecToDMS($this->longitude());
$direction = 'E';
if ($long['degrees'] < 0) {
$direction = 'W';
}
return sprintf($format, $long['degrees'], $long['minutes'], $long['seconds'], $direction);
}
|
php
|
{
"resource": ""
}
|
q267897
|
Location.latitudeRange
|
test
|
public function latitudeRange($distance) {
$long = deg2rad($this->longitude());
$lat = deg2rad($this->latitude());
$radius = $this->earthRadius($this->latitude());
$angle = $distance / $radius;
$rightangle = pi() / 2;
$minlat = $lat - $angle;
if ($minlat < -$rightangle) { // wrapped around the south pole
$overshoot = -$minlat - $rightangle;
$minlat = -$rightangle + $overshoot;
if ($minlat > $maxlat) { $maxlat = $minlat; }
$minlat = -$rightangle;
}
$maxlat = $lat + $angle;
if ($maxlat > $rightangle) { // wrapped around the north pole
$overshoot = $maxlat - $rightangle;
$maxlat = $rightangle - $overshoot;
if ($maxlat < $minlat) { $minlat = $maxlat; }
$maxlat = $rightangle;
}
return array(
'min' => rad2deg($minlat),
'max' => rad2deg($maxlat),
);
}
|
php
|
{
"resource": ""
}
|
q267898
|
Location.longitudeRange
|
test
|
public function longitudeRange($distance) {
$long = deg2rad($this->longitude());
$lat = deg2rad($this->latitude());
$radius = $this->earthRadius($this->latitude());
$angle = $distance / $radius;
$diff = asin(sin($angle) / cos($lat));
$minlong = $long - $diff;
if ($minlong < -pi()) {
$minlong = $minlong + pi() * 2;
}
$maxlong = $long + $diff;
if ($maxlong > pi()) {
$maxlong = $maxlong - pi() * 2;
}
return array(
'min' => rad2deg($minlong),
'max' => rad2deg($maxlong),
);
}
|
php
|
{
"resource": ""
}
|
q267899
|
Location.distance
|
test
|
public function distance(LocationInterface $location, $method = 'default') {
if (!isset($this->distanceCache[$method])) {
if (!isset($this->distanceMethods[$method])) {
throw new Exception('Distance method not registered.');
}
elseif (!class_exists($this->distanceMethods[$method])) {
throw new Exception('The class associated with the name does not exist.');
}
// @todo: Should this verify the proper interface is implemented? If not
// it will simply explode.
$this->distanceCache[$method] = new $this->distanceMethods[$method];
}
return $this->distanceCache[$method]->distance($this, $location);
}
|
php
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.