public function pushBindings(BlazeContext $context)
{
$requestUri = $context->getRequest()->getRequestURI()->getPath();
// remove the prefix of the url e.g. BlazeFrameworkServer/
if (!$requestUri->endsWith('/')) {
$requestUri = $requestUri->concat('/');
}
$requestUri = $requestUri->substring($context->getApplication()->getUrlPrefix()->replace('*', '')->length());
// Requesturl has always to start with a '/'
if ($requestUri->length() == 0 || $requestUri->charAt(0) != '/') {
$requestUri = new String('/' . $requestUri->toNative());
}
foreach ($this->mapping as $navigationRule) {
$regex = '/^' . str_replace(array('/', '*'), array('\\/', '.*'), $navigationRule->getMapping()) . '$/';
if ($requestUri->matches($regex)) {
$bindingParts = $requestUri->substring(strlen($navigationRule->getMapping()) - 1)->split('/');
$count = count($bindingParts);
$newValue = null;
// Look for the bindings
$binds = $navigationRule->getBindings();
for ($i = 0; $i < $binds->count(); $i++) {
if ($i < $count && $bindingParts[$i] != '') {
$newValue = $bindingParts[$i];
} else {
$newValue = $binds->get($i)->getDefault();
}
if ($newValue !== null) {
$binds->get($i)->getReference()->setValue($context, $newValue);
$newValue = null;
}
}
}
}
}
/**
*
* @param blaze\lang\String|string $name The name of the cookie
* @param blaze\lang\String|string $value The value of the cookie
*/
public function __construct($name, $value)
{
$name = new String($name);
if ($name->startsWith('$') || $name->contains(',') || $name->contains(';') || $name->contains(' ')) {
throw new IllegalArgumentException('The name of a cookie can only contain alphanumeric characters but not commas, semicolons, whitespaces or begin with $ character.');
}
$this->name = $name;
$this->value = String::asWrapper($value);
}
/**
* Returns the login timeout in seconds.
*
* @return int The timeout in seconds.
*/
public function unregisterDriver($protocol)
{
$protocol = String::asNative($protocol);
if (array_key_exists($protocol, $this->drivers)) {
unset($this->drivers[$protocol]);
}
}
/**
* Generate a new BigDecimal Object.
* @param <int|string|float|blaze\lang\Number> $value Is a native String, with scale and algebric sign
* @param <type> $scale If value has no scale you can define the scale
*/
public function __construct($value, $scale = null)
{
if (($class = Number::getNumberClass($value)) !== null) {
$className = $class->getName()->toNative();
$value = $className::asNative($value);
} else {
if (!self::isNativeType($value)) {
throw new \blaze\lang\NumberFormatException('Not a valid representation of BigDecimal!');
}
}
$this->value = String::asNative($value);
if ($scale != null) {
$this->scale = $scale;
} else {
$ar = explode('.', $this->value);
$count = count($ar);
if ($count > 2) {
throw new \blaze\lang\NumberFormatException('Not a valid representation of BigDecimal!');
}
if ($count == 2) {
$this->scale = strlen($ar[1]);
} else {
$this->scale = 0;
}
}
}
public function next()
{
if ($this->hasNext()) {
$this->returnObj = $this->rsd->getResultClassInstance();
foreach ($this->rsd->getFieldMappings() as $column => $propertyPath) {
$classesPath = $propertyPath->getClassesPath();
$namesPath = $propertyPath->getNamesPath();
for ($i = 0; $i < count($namesPath); $i++) {
switch (\blaze\lang\String::asNative($classesPath[$i])) {
case 'int':
$this->setObjectValue($this->returnObj, $namesPath, $this->rs->getInt($column));
break;
case 'blaze\\lang\\String':
$this->setObjectValue($this->returnObj, $namesPath, $this->rs->getString($column));
break;
case 'blaze\\util\\Date':
$this->setObjectValue($this->returnObj, $namesPath, $this->rs->getDate($column));
break;
default:
$this->setObjectValue($this->returnObj, $namesPath, null);
break;
}
}
}
} else {
$this->returnObj = null;
}
$this->hasNext = null;
return $this->returnObj;
}
/**
* Returns an instance of TypeChecker for the specified type.
*
* @param string|blaze\lang\String|blaze\lang\ClassWrapper $type
* @return blaze\collections\TypeChecker
*/
public static function getInstance($type)
{
if ($type === null) {
throw new blaze\lang\NullPointerException();
}
$class = null;
$type = null;
$typeName = null;
if ($type instanceof \blaze\lang\ClassWrapper) {
$class = $type;
$typeName = $type->getName();
} else {
$type = \blaze\lang\String::asNative($type);
if (in_array($type, self::$basicTypes)) {
$type = $type;
$typeName = new \blaze\lang\String($type);
} else {
$class = \blaze\lang\ClassWrapper::forName($type);
$typeName = $class->getName();
}
}
if (!array_key_exists($typeName, self::$typeCheckers)) {
self::$typeCheckers[$typeName] = new TypeChecker($type, $class, $typeName);
}
return self::$typeCheckers[$typeName];
}
public function getImmediate()
{
if ($this->immediate == null) {
return false;
}
$imm = $this->getResolvedExpression($this->immediate);
return \blaze\lang\Boolean::isType($imm) ? $imm : \blaze\lang\String::asWrapper($imm)->trim()->compareToIgnoreCase('true') == 0;
}
public function save(\blaze\persistence\cfg\Configuration $config, $file)
{
$f = null;
if ($file instanceof \blaze\io\File) {
$f = $file;
} else {
$f = new \blaze\io\File(\blaze\lang\String::asNative($file));
}
}
/**
*
* @param blaze\lang\String|string|int $identifier
* @param mixed $value
* @return blaze\lang\PreparedStatement
*/
protected function set($identifier, $value, $type = \PDO::PARAM_STR)
{
if (\blaze\lang\String::isType($identifier)) {
$this->stmt->bindValue(':' . $identifier, $value, $type);
} else {
$this->stmt->bindValue($identifier + 1, $value, $type);
}
//|\PDO::PARAM_INPUT_OUTPUT);
}
public function getValue(\blaze\web\application\BlazeContext $context, $subExpressions, $subBrackets)
{
$left = $this->getLeftOperation()->getValue($context, $subExpressions, $subBrackets);
$right = $this->getRightOperation()->getValue($context, $subExpressions, $subBrackets);
if (\blaze\lang\String::isType($left) || \blaze\lang\String::isType($right)) {
return $left . $right;
} else {
return $left + $right;
}
}
/**
* Construct a new FileInputStream.
* @param string|blaze\lang\String|blaze\io\File $file
* @throws blaze\lang\IllegalArgumentException If invalid argument specified.
* @throws blaze\io\IOException If any IO error occurs
*/
public function __construct($file, $append = false, $binary = true)
{
if ($file instanceof \blaze\io\File) {
$this->file = $file;
} elseif (\blaze\lang\String::isType($file)) {
$this->file = new \blaze\io\File($file);
} else {
throw new \blaze\lang\IllegalArgumentException('Invalid argument type for $file.');
}
parent::__construct($this->file->getAbsolutePath()->toNative(), $append, $binary);
}
/**
* @param \blaze\lang\String|string $protocol
* @return blaze\net\URLStreamHandler
*/
public function createURLStreamHandler($protocol)
{
switch (\blaze\lang\String::asWrapper($protocol)->toLowerCase()->toNative()) {
case 'http':
break;
case 'https':
break;
case 'ftp':
break;
}
}
public function forwardEngineerXmlFile(\blaze\io\File $file)
{
$buf = new \blaze\lang\StringBuffer();
$t = new \blaze\persistence\meta\driver\XmlMetaDriver();
$cd = $t->parseFile($file);
$cd->generate($buf);
$fileName = \blaze\lang\String::asWrapper($cd->getName());
$fileName = $fileName->substring($fileName->lastIndexOf('\\') + 1);
$writer = new \blaze\io\output\FileWriter(new \blaze\io\File($this->dir, $fileName . '.php'));
$writer->write($buf->toString());
$writer->close();
}
public static function asNative($value)
{
if (static::isWrapperType($value)) {
return $value->toNative();
} else {
if (static::isNativeType($value)) {
return $value;
} else {
return String::asNative($value);
}
}
}
public function write($str, $off = 0, $len = -1)
{
$str = \blaze\lang\String::asNative($str);
if ($off > 0) {
if ($len > 0) {
$str = substr($str, $off, $len);
} else {
$str = substr($str, $off);
}
}
return $this->out->write(serialize($str));
}
public function addFieldMapping(SingleFieldDescriptor $fieldDescriptor, $columnAlias = null)
{
if ($columnAlias === null) {
$columnAlias = $fieldDescriptor->getColumnDescriptor()->getName();
}
if ($columnAlias === null) {
throw new \blaze\lang\Exception('No column name available');
}
$columnAlias = \blaze\lang\String::asNative($columnAlias);
$propPath = new PropertyPath();
$propPath->addPathStep($fieldDescriptor->getType(), $fieldDescriptor->getName());
$this->columnAliasToPropertyPathMapping[$columnAlias] = $propPath;
}
private function getCondition($left, $right, $operator, $leftNegation = false, $rightNegation = false, $negation = false)
{
if (\blaze\lang\String::isType($left)) {
$left = new \blaze\persistence\ooql\Value($left, \blaze\persistence\ooql\Value::TYPE_STRING, $leftNegation);
} else {
$left = new \blaze\persistence\ooql\Value($left, \blaze\persistence\ooql\Value::TYPE_SCALAR, $leftNegation);
}
if (\blaze\lang\String::isType($right)) {
$right = new \blaze\persistence\ooql\Value($right, \blaze\persistence\ooql\Value::TYPE_STRING, $rightNegation);
} else {
$right = new \blaze\persistence\ooql\Value($right, \blaze\persistence\ooql\Value::TYPE_SCALAR, $rightNegation);
}
return new \blaze\persistence\ooql\Condition($left, $right, $operator, $negation);
}
/**
*
* @param string|blaze\lang\String|blaze\io\File|blaze\io\output\FileOutputStream $fileOrStream
*/
public function __construct($fileOrStream, $append = false)
{
$stream = null;
if ($fileOrStream instanceof FileOutputStream) {
$stream = $fileOrStream;
} else {
if ($fileOrStream instanceof \blaze\io\File || \blaze\lang\String::isType($fileOrStream)) {
$stream = new FileOutputStream($fileOrStream, $append, false);
} else {
throw new \blaze\lang\IllegalArgumentException('Invalid argument type for $fileOrStream.');
}
}
parent::__construct($stream);
}
protected function resolveSubParts(\blaze\web\application\BlazeContext $context, $subExpressions, $subBrackets, $expressionString)
{
if (\blaze\lang\String::isNativeType($expressionString)) {
while (preg_match('/\\{([0-9]*)\\}/', $expressionString, $matches) != 0) {
$val = $subExpressions[\blaze\lang\Integer::asNative($matches[1])]->getValue($context);
$expressionString = str_replace($matches[0], $val, $expressionString);
}
while (preg_match('/\\(([0-9]*)\\)/', $expressionString, $matches) != 0) {
$val = $subBrackets[\blaze\lang\Integer::asNative($matches[1])]->getValue($context);
$expressionString = str_replace($matches[0], $val, $expressionString);
}
}
return $expressionString;
}
public function write($str, $off = 0, $len = -1)
{
$str = \blaze\lang\String::asNative($str);
if ($off > 0) {
if ($len > 0) {
$str = substr($str, $off, $len);
} else {
$str = substr($str, $off);
}
}
if (fwrite($this->stream, $str) === false) {
throw new \blaze\io\IOException('Error writing to stream.');
}
}
/**
* Checks the key and returns it as native string when wrapper is false, otherwise as blaze\lang\String.
* @return string|blaze\lang\String
*/
private static function getCheckedKey($key, $wrapper = false)
{
if ($wrapper) {
$key = \blaze\lang\String::asWrapper($key);
if ($key->length() < 1) {
throw new CacheException('The length of the key must be at least one char!');
}
} else {
$key = \blaze\lang\String::asNative($key);
if (strlen($key) < 1) {
throw new CacheException('The length of the key must be at least one char!');
}
}
return $key;
}
public function on($left, $right, $operator, $leftNegation = false, $rightNegation = false, $negation = false)
{
if ($this->onClause === null) {
$this->onClause = new \blaze\persistence\ooql\OnClause();
}
if (\blaze\lang\String::isType($left)) {
$left = new \blaze\persistence\ooql\Value($left, \blaze\persistence\ooql\Value::TYPE_STRING);
} else {
$left = new \blaze\persistence\ooql\Value($left, \blaze\persistence\ooql\Value::TYPE_SCALAR);
}
if (\blaze\lang\String::isType($right)) {
$right = new \blaze\persistence\ooql\Value($right, \blaze\persistence\ooql\Value::TYPE_STRING);
} else {
$right = new \blaze\persistence\ooql\Value($right, \blaze\persistence\ooql\Value::TYPE_SCALAR);
}
$this->onClause->setCondition(new \blaze\persistence\ooql\Condition($left, $right, $operator, $negation));
}
/**
*
* @return FileSystem
*/
public static function getInstance()
{
if (self::$instance === null) {
switch (String::asNative(\blaze\lang\System::getProperty('host.fs'))) {
case 'UNIX':
self::$instance = new UnixFileSystem();
break;
case 'WIN32':
self::$instance = new Win32FileSystem();
break;
case 'WINNT':
self::$instance = new WinNTFileSystem();
break;
default:
throw new \blaze\lang\Exception('Host uses unsupported filesystem, unable to proceed');
}
}
return self::$instance;
}
public function condition($left, $right, $operator, $leftNegation = false, $rightNegation = false, $negation = false)
{
if ($left instanceof \blaze\persistence\ooql\Condition || $left instanceof \blaze\persistence\ooql\Value) {
$this->left = $left;
} else {
if (\blaze\lang\String::isType($left)) {
$this->left = new \blaze\persistence\ooql\Value($left, \blaze\persistence\ooql\Value::TYPE_STRING, $leftNegation);
} else {
$this->left = new \blaze\persistence\ooql\Value($left, \blaze\persistence\ooql\Value::TYPE_SCALAR, $leftNegation);
}
}
if ($right instanceof \blaze\persistence\ooql\Condition || $right instanceof \blaze\persistence\ooql\Value) {
$this->rightConditionable = $right;
} else {
if (\blaze\lang\String::isType($right)) {
$this->rightConditionable = new \blaze\persistence\ooql\Value($right, \blaze\persistence\ooql\Value::TYPE_STRING, $rightNegation);
} else {
$this->rightConditionable = new \blaze\persistence\ooql\Value($right, \blaze\persistence\ooql\Value::TYPE_SCALAR, $rightNegation);
}
}
$this->operator = $operator;
$this->negation = $negation;
return $this;
}
/**
*
* @param \blaze\persistence\meta\ClassDescriptor $config
* @param File $file
*/
public function save(\blaze\persistence\meta\ClassDescriptor $config, $file)
{
$f = null;
if ($file instanceof \blaze\io\File) {
$f = $file;
} else {
$f = new \blaze\io\File(\blaze\lang\String::asNative($file));
}
$doc = new \DOMDocument();
$root = $doc->createElement('persistence-mapping');
$doc->appendChild($root);
$node = $doc->createElement('class');
$root->appendChild($node);
AttributeUtil::set($node, 'package', $config->getPackage());
AttributeUtil::set($node, 'name', $config->getName());
AttributeUtil::set($node, 'schema', $config->getTableDescriptor()->getSchema());
AttributeUtil::set($node, 'table', $config->getTableDescriptor()->getName());
foreach ($config->getIdentifiers() as $member) {
$this->saveId($node, $doc, $member);
}
foreach ($config->getSingleFields() as $member) {
$this->saveField($node, $doc, $member);
}
foreach ($config->getCollectionFields() as $member) {
$this->saveCollection($node, $doc, $member);
}
$doc->save($f->getAbsolutePath());
}
/**
* Description
*
* @param blaze\lang\String|string $url Description of the parameter $var
* @return blaze\net\URL Description of what the method returns
* @throws blaze\lang\Exception
*/
public static function parseURL(\blaze\lang\String $url)
{
$idx = $url->indexOf('://');
if ($idx == -1) {
throw new \blaze\lang\Exception('Invalid URL');
}
$parts = parse_url($url);
if ($parts === false) {
throw new \blaze\lang\Exception('Invalid URL');
}
$scheme = isset($parts['scheme']) ? $parts['scheme'] : null;
$host = isset($parts['host']) ? $parts['host'] : null;
$port = isset($parts['port']) ? $parts['port'] : null;
$user = isset($parts['user']) ? $parts['user'] : null;
$password = isset($parts['pass']) ? $parts['pass'] : null;
$path = isset($parts['path']) ? $parts['path'] : null;
$query = isset($parts['query']) ? $parts['query'] : null;
$fragment = isset($parts['fragment']) ? $parts['fragment'] : null;
return new URL($scheme, $user, $password, $host, $port, $path, $query, $fragment);
}
private function getWhereColumn($string, $classMetas, \blaze\persistence\EntityManager $em)
{
$str = \blaze\lang\String::asWrapper($string);
if ($str->startsWith(':') && !$str->contains(' ')) {
return $string;
} else {
if ($str->equalsIgnoreCase('?')) {
return $string;
} else {
if ($str->startsWith('"') && $str->endsWith('"')) {
return $string;
} else {
if (\blaze\lang\Number::getNumberClass($string) !== null) {
return $string;
}
}
}
}
$parts = explode('.', $string);
$alias = null;
foreach ($classMetas as $classAlias => $meta) {
if ($parts[0] === $classAlias) {
$alias = array_shift($parts);
break;
}
}
if (count($classMetas) == 1) {
$meta = array_shift($classMetas);
$column = $this->recursiveColumnLookup($meta, $parts);
} else {
foreach ($classMetas as $classAlias => $meta) {
if ($alias === null || $alias === $classAlias) {
$column = $this->recursiveColumnLookup($meta, $parts);
}
}
}
if ($alias !== null) {
return $alias . '.' . $column;
} else {
return $column;
}
}
/**
* check if the literal address string has %nn appended
* returns -1 if not, or the numeric value otherwise.
*
* %nn may also be a string that represents the displayName of
* a currently available NetworkInterface.
* @return int
*/
private static function checkNumericZone(\blaze\lang\String $s)
{
$percent = $s->indexOf('%');
$slen = $s->length();
$digit = null;
$zone = 0;
if ($percent == -1) {
return -1;
}
for ($i = $percent + 1; $i < $slen; $i++) {
$c = $s->charAt($i);
if ($c == ']') {
if ($i == $percent + 1) {
/* empty per-cent field */
return -1;
}
break;
}
if (($digit = \baze\lang\Character::digit($c, 10)) < 0) {
return -1;
}
$zone = $zone * 10 + $digit;
}
return $zone;
}
public function getConstant($name)
{
try {
return new Method($this->reflectionClass->getConstant(String::asNative($name)));
} catch (\ReflectionException $e) {
throw new NoSuchFieldException($e->getMessage(), $e->getCode());
}
}
/**
* Appends a value to a property if it already exists with a delimiter
*
* If the property does not, it just adds it.
*
* @param string $key
* @param mixed $value
* @param string $delimiter
*/
public function append(\blaze\lang\String $key, \blaze\lang\String $value, \blaze\lang\String $delimiter = null)
{
if ($delimiter === null) {
$delimiter = new \blaze\lang\String(',');
}
$newValue = $value;
if (isset($this->properties[$key]) && !empty($this->properties[$key])) {
$newValue = $this->properties[$key] . $delimiter . $value;
}
$this->properties[$key->toNative()] = \blaze\lang\String::asWrapper($newValue);
}
