/**
* Class constructor.
* Initializes the error handler.
* @param \Brickoo\Component\Messaging\MessageDispatcher $messageDispatcher
* @param boolean $convertToException flag to convert errors to exceptions
*/
public function __construct(MessageDispatcher $messageDispatcher, $convertToException = true)
{
Assert::isBoolean($convertToException);
$this->messageDispatcher = $messageDispatcher;
$this->convertToException = $convertToException;
$this->isRegistered = false;
}
/**
* Class constructor.
* @param string $cacheDirectory the directory used for the cache operations
* @param boolean $serializeCacheContent flag to serialize the content cached
* @param string $cacheFileNameSuffix the suffix to add to caching file names
* @throws \InvalidArgumentException if an argument is not valid
*/
public function __construct($cacheDirectory, $serializeCacheContent = true, $cacheFileNameSuffix = ".cache")
{
Assert::isString($cacheDirectory);
Assert::isBoolean($serializeCacheContent);
Assert::isString($cacheFileNameSuffix);
$this->cacheDirectory = rtrim($cacheDirectory, "\\/") . DIRECTORY_SEPARATOR;
$this->serializeCacheContent = $serializeCacheContent;
$this->cacheFileNameSuffix = $cacheFileNameSuffix;
}
/**
* Class constructor.
* @param string $name
* @param string $type
* @param boolean $required
* @throws \InvalidArgumentException
*/
public function __construct($name, $type, $required = true)
{
Assert::isString($name);
Assert::isString($type);
Assert::isBoolean($required);
$this->name = $name;
$this->type = $type;
$this->required = $required;
}
/**
* @param string $filename
* @param integer $mode
* @param boolean $useIncludePath
* @param array $context
* @throws \InvalidArgumentException
*/
public function __construct($filename, $mode, $useIncludePath = false, array $context = array())
{
Assert::isString($filename);
Assert::isInteger($mode);
Assert::isBoolean($useIncludePath);
$this->filename = $filename;
$this->mode = $mode;
$this->useIncludePath = $useIncludePath;
$this->context = $context;
}
/**
* Class constructor.
* @param string $annotationName
* @param integer $target
* @param boolean $required
* @throws \InvalidArgumentException
*/
public function __construct($annotationName, $target = Annotation::TARGET_CLASS, $required = true)
{
Assert::isString($annotationName);
Assert::isInteger($target);
Assert::isBoolean($required);
$this->target = $target;
$this->annotationName = $annotationName;
$this->required = $required;
$this->requiredParameters = [];
$this->optionalParameters = [];
}
/**
* Class constructor.
* @param string $routingPath the routing directory path
* @param string $routingFilename the route filename to look for
* @param boolean $searchRecursively flag to search recursively
* @throws \InvalidArgumentException if an argument is not valid
*/
public function __construct($routingPath, $routingFilename, $searchRecursively = false)
{
Assert::isString($routingPath);
Assert::isString($routingFilename);
Assert::isBoolean($searchRecursively);
if (empty($routingPath)) {
throw new InvalidArgumentException("The routing path cannot be empty.");
}
if (empty($routingFilename)) {
throw new InvalidArgumentException("The routing filename cannot be empty.");
}
$this->routingPath = $routingPath;
$this->routingFilename = $routingFilename;
$this->searchRecursively = $searchRecursively;
}
/**
* @covers Brickoo\Component\Common\Assert::isBoolean
* @expectedException \InvalidArgumentException
*/
public function testIsBooleanThrowsInvalidArgumentException()
{
Assert::isBoolean(null);
}
/**
* Sets the read only mode for all registrations.
* True to allow read only, write operations will be not allowed.
* False for enable read and write operations, locked identifiers will still being locked .
* @param boolean $mode the mode to set
* @return \Brickoo\Component\Common\Registry
*/
public function setReadOnly($mode = true)
{
Assert::isBoolean($mode);
$this->readOnly = $mode;
return $this;
}
/**
* Enable or disable http only.
* @param boolean $httpOnly
* @throws \InvalidArgumentException
* @return \Brickoo\Component\Http\Header\SetCookieHeaderField
*/
public function setHttpOnly($httpOnly)
{
Assert::isBoolean($httpOnly);
$this->httpOnly = $httpOnly;
return $this;
}
/**
* Sets the session cookie parameters.
* @param integer $lifetime the cookie/session lifetime
* @param string $path the request path to listen to
* @param string $domain the domain to listen to
* @param boolean $secure only should be sent while on https mode
* @param boolean $httpOnly restriction to the http protocol
* @throws \InvalidArgumentException if an argument is not valid
* @throws \Brickoo\Component\Session\Exception\SessionAlreadyStartedException
* @return \Brickoo\Component\Session\SessionManager
*/
public function setCookieParams($lifetime, $path, $domain, $secure = false, $httpOnly = false)
{
Assert::isInteger($lifetime);
Assert::isString($path);
Assert::isString($domain);
Assert::isBoolean($secure);
Assert::isBoolean($httpOnly);
$this->checkSessionStart();
session_set_cookie_params($lifetime, $path, $domain, $secure, $httpOnly);
return $this;
}