/**
* @param callable[] $factoryFunctions An associative array mapping types to factory
* functions. Type names must use the "PT:" prefix for property types (data types),
* and "VT:" for value types, to be compatible with the convention used by
* DispatchingValueFormatter.
* The factory functions will be called with two parameters, the desired target
* type (see the SnakFormatter::FORMAT_XXX constants) and a FormatterOptions object.
* The factory function must return an instance of ValueFormatter suitable for the given target
* format, or null if no formatter for the requested target format is known.
*
* @param Language $defaultLanguage
* @param LanguageFallbackChainFactory $fallbackChainFactory
*/
public function __construct(array $factoryFunctions, Language $defaultLanguage, LanguageFallbackChainFactory $fallbackChainFactory)
{
Assert::parameterElementType('callable', $factoryFunctions, '$factoryFunctions');
$this->factoryFunctions = $factoryFunctions;
$this->defaultLanguage = $defaultLanguage;
$this->languageFallbackChainFactory = $fallbackChainFactory;
}
/**
* @param callable[] $snakFormatterConstructorCallbacks An associative array mapping property
* data type IDs to callbacks. The callbacks will be invoked with two parameters: the
* desired output format, and the FormatterOptions. Each callback must return an
* instance of SnakFormatter.
* @param OutputFormatValueFormatterFactory $valueFormatterFactory
* @param PropertyDataTypeLookup $propertyDataTypeLookup
* @param DataTypeFactory $dataTypeFactory
*/
public function __construct(array $snakFormatterConstructorCallbacks, OutputFormatValueFormatterFactory $valueFormatterFactory, PropertyDataTypeLookup $propertyDataTypeLookup, DataTypeFactory $dataTypeFactory)
{
Assert::parameterElementType('callable', $snakFormatterConstructorCallbacks, '$snakFormatterConstructorCallbacks');
$this->snakFormatterConstructorCallbacks = $snakFormatterConstructorCallbacks;
$this->valueFormatterFactory = $valueFormatterFactory;
$this->propertyDataTypeLookup = $propertyDataTypeLookup;
$this->dataTypeFactory = $dataTypeFactory;
}
/**
* Adds data type definitions. The new definitions are merged with the existing definitions.
* If a data type in $dataTypeDefinitions was already defined, the old definition is not
* replaced but the definitions are merged.
*
* @param array[] $dataTypeDefinitions An associative array mapping property data type ids
* (with the prefix "PT:") and value types (with the prefix "VT:") to data type definitions.
* Each data type definitions are associative arrays, refer to the class level documentation
* for details.
*/
public function registerDataTypes(array $dataTypeDefinitions)
{
Assert::parameterElementType('array', $dataTypeDefinitions, '$dataTypeDefinitions');
foreach ($dataTypeDefinitions as $id => $def) {
Assert::parameter(strpos($id, ':'), "\$dataTypeDefinitions[{$id}]", 'Key must start with a prefix like "PT:" or "VT:".');
if (isset($this->dataTypeDefinitions[$id])) {
$this->dataTypeDefinitions[$id] = array_merge($this->dataTypeDefinitions[$id], $dataTypeDefinitions[$id]);
} else {
$this->dataTypeDefinitions[$id] = $dataTypeDefinitions[$id];
}
}
}
/**
* @param Title $title
* @param array $params
*/
public function __construct(Title $title, array $params)
{
parent::__construct('wikibase-addUsagesForPage', $title, $params);
Assert::parameter(isset($params['pageId']) && is_int($params['pageId']) && $params['pageId'] > 0, '$params["pageId"]', 'must be a positive integer');
Assert::parameter(isset($params['usages']) && is_array($params['usages']) && !empty($params['usages']), '$params["usages"]', 'must be a non-empty array');
Assert::parameter(isset($params['touched']) && is_string($params['touched']) && $params['touched'] !== '', '$params["touched"]', 'must be a timestamp string');
Assert::parameterElementType('array', $params['usages'], '$params["usages"]');
$this->pageId = $params['pageId'];
$this->usages = $params['usages'];
$this->touched = $params['touched'];
$wikibaseClient = WikibaseClient::getDefaultInstance();
$usageUpdater = $wikibaseClient->getStore()->getUsageUpdater();
$idParser = $wikibaseClient->getEntityIdParser();
$this->overrideServices($usageUpdater, $idParser);
}
public function testParameterElementType_bad()
{
$this->setExpectedException('Wikimedia\\Assert\\ParameterTypeException');
Assert::parameterElementType('string', 'foo', 'test');
}
/**
* @param EntityChangeFactory $changeFactory
* @param ChangeTransmitter[] $changeTransmitters
*/
public function __construct(EntityChangeFactory $changeFactory, array $changeTransmitters)
{
Assert::parameterElementType('Wikibase\\Repo\\Notifications\\ChangeTransmitter', $changeTransmitters, '$changeTransmitters');
$this->changeFactory = $changeFactory;
$this->changeTransmitters = $changeTransmitters;
}
/**
* @param callable[] $factoryCallbacks Factory callback functions as returned by
* DataTypeDefinitions::getRdfBuilderFactoryCallbacks(). Callbacks will be invoked
* with the signature ($mode, RdfVocabulary, EntityMentionListener) and must
* return a ValueSnakRdfBuilder (or null).
*/
public function __construct(array $factoryCallbacks)
{
Assert::parameterElementType('callable', $factoryCallbacks, '$factoryCallbacks');
$this->factoryCallbacks = $factoryCallbacks;
}
/**
* @param int[] $ids
*
* @return Change[]
*/
public function loadByChangeIds($ids)
{
Assert::parameterElementType('integer', $ids, '$ids');
return $this->loadChanges(array('change_id' => $ids), array(), __METHOD__);
}
/**
* Registers multiple services (aka a "wiring").
*
* @param array $serviceInstantiators An associative array mapping service names to
* instantiator functions.
*/
public function applyWiring(array $serviceInstantiators)
{
Assert::parameterElementType('callable', $serviceInstantiators, '$serviceInstantiators');
foreach ($serviceInstantiators as $name => $instantiator) {
$this->defineService($name, $instantiator);
}
}
/**
* @param ValueSnakRdfBuilder[] $valueBuilders ValueSnakRdfBuilder objects keyed by data type
* (with prefix "PT:") or value type (with prefix "VT:").
*/
public function __construct(array $valueBuilders)
{
Assert::parameterElementType('Wikibase\\Rdf\\ValueSnakRdfBuilder', $valueBuilders, '$valueBuilders');
$this->valueBuilders = $valueBuilders;
}
/**
* @param callable[] $validatorBuilders
*/
public function __construct(array $validatorBuilders)
{
Assert::parameterElementType('callable', $validatorBuilders, '$validatorBuilders');
$this->validatorBuilders = $validatorBuilders;
}
