@param null                 $variable
@param null                 $property
@param AbstractBuilder|null $expression

@return AssignPropertyOperator
331611
public function assignProperty($variable = null, $property = null, AbstractBuilder $expression = null)
    {
        $assignProperty = new AssignPropertyOperator($variable, $property, $expression);
        $assignProperty->setType($assignProperty::TYPE_ASSIGN_OBJECT_PROPERTY);

        return $assignProperty;
    }
412209
public function assign($var, $value = null)
    {
        if (is_string($var)) {
            $this->_vars[$var] = $value;

            return $this;
        }

        if (is_array($var)) {
            foreach ($var as $key => $value) {
                if ($value instanceof AbstractClassContent) {
                    // trying to load subcontent
                    $subcontent = $this->getApplication()
                            ->getEntityManager()
                            ->getRepository(ClassUtils::getRealClass($value))
                            ->load($value, $this->getApplication()->getBBUserToken());
                    if (null !== $subcontent) {
                        $value = $subcontent;
                    }
                }

                $this->_vars[$key] = $value;
            }
        }

        return $this;
    }
31452
public function evaluate($expression, &$code = null)
    {
        $exprcompiler = new ScriptCompiler(new ExpressionParser(), new ExpressionTokenizer());

        $z = $this;
        $_value = null;
        $code = '$z->set(array(\'_\'), ' . $exprcompiler->compile($expression) . ');';
        eval($code);

        return $z->resolve(array('_'));
    }
900304
public function bind(&$property) : FormObjectFieldBindingBuilder
    {
        $typeDefiner  = $this->class->property($property);
        $propertyName = $this->loadTypeDefiner($typeDefiner);

        return new FormObjectFieldBindingBuilder(function (IField $field) use ($propertyName) {
            $this->fieldPropertyMap[$field->getName()] = $propertyName;
        });
    }
151906
public function set($property, $value = null)
    {
        if (is_string($property) && $value != '') {
            $property = [$property => $value];
        }

        foreach ($property as $name => $value) {
            $this->properties[$name] = $value;
        }

        return $this;
    }
1041489
public static void setProperty(Object bean, String expression, Object value) {
		BeanPath.create(expression).set(bean, value);
	}
550556
public function buildExpression(Expression $expr = null)
    {
        if (!$this->defaultExpression) {
            $this->defaultExpression = Expr::same(BindingState::ENABLED, BindingDescriptor::STATE)
                ->andSame(AssetPlugin::BINDING_TYPE, BindingDescriptor::TYPE_NAME)
                ->andEndsWith('{,/**/*}', BindingDescriptor::QUERY);
        }

        if (!$expr) {
            return $this->defaultExpression;
        }

        $traverser = new ExpressionTraverser();
        $traverser->addVisitor($this);

        return $this->defaultExpression->andX($traverser->traverse($expr));
    }
853795
public function where($key, $operator = null, $value = null): IQueryBuilderHandler
    {
        // If two params are given then assume operator is =
        if (\func_num_args() === 2) {
            $value = $operator;
            $operator = '=';
        }

        if (\is_bool($value) === true) {
            $value = (int)$value;
        }

        return $this->whereHandler($key, $operator, $value);
    }
559631
public function assign($var, $value = null) {

        $invalidProperties = ['__rawContents'];

		if(is_array($var)) {
			foreach($var as $k => $v) {
			    if(in_array($k, $invalidProperties)) {
			        throw new SimpleTemplateException("Tried to assign invalid property '%s'", $k);
                }
				$this->bufferInstance->$k = $v;
			}

			return $this;
		}

        if(in_array($var, $invalidProperties)) {
            throw new SimpleTemplateException("Tried to assign invalid property '%s'", $var);
        }

		$this->bufferInstance->$var = $value;

		return $this;
	}
94414
public static function assignProperty($object, $property, $value)
    {
        $refl = new \ReflectionObject($object);
        $prop = $refl->getProperty($property);
        $prop->setAccessible(true);
        $prop->setValue($object, $value);

        return $value;
    }
702440
public function set($property, $value = null)
	{
		if (is_array($property))
		{
			foreach ($property as $p => $v)
			{
				$this->set($p, $v);
			}
			return $this;
		}

		$this->values[$property] = $value;

		return $this;
	}
1143201
public static function generateFromVariable(
        $order = null,
        $skip = null,
        $limit = null,
        array $mapping = array(),
        $search = null
    ) {
        $configuration = new static();

        $configuration->setPaginateConfiguration($order, $skip, $limit, $mapping, $search);

        return $configuration;
    }
132132
public function get_property( $name, $value = null ) {
		if ( ! array_key_exists( $name, $this->properties ) ) {
			$this->properties[ $name ] = new Variable_Property( $this, $name, $value );
		}

		return $this->properties[ $name ];
	}
1041779
public function assignString(Variable $variable, $value, CompilationContext $context, $useCodePrinter = true, $doCopy = null)
    {
        return $this->assignHelper('ZVAL_STRING', $this->getVariableCode($variable), $value, $context, $useCodePrinter, null);
    }
289995
protected function assignHelper($macro, $variableName, $value, CompilationContext $context, $useCodePrinter, $doCopy = null)
    {
        if ($value instanceof Variable) {
            $value = $value->getName();
        } else {
            $value = 'ZVAL_STRING' == $macro ? '"'.$value.'"' : $value;
        }

        $copyStr = '';
        if (true === $doCopy) {
            $copyStr = ', 1';
        } elseif (false === $doCopy) {
            $copyStr = ', 0';
        } elseif (isset($doCopy)) {
            $copyStr = ', '.$doCopy;
        }

        $output = $macro.'('.$variableName.', '.$value.$copyStr.');';
        if ($useCodePrinter) {
            $context->codePrinter->output($output);
        }

        return $output;
    }
295827
@NonNull
    public static SelectResult.As property(@NonNull String property) {
        if (property == null) {
            throw new IllegalArgumentException("property cannot be null.");
        }
        return new SelectResult.As(PropertyExpression.property(property));
    }
140689
static public function buildExpression($property, $operator, $parameter = null)
    {
        FilterOperator::isValid($operator, true);

        $expr = new Expr();
        switch (intval($operator)) {
            case FilterOperator::NOT_EQUAL:
                return $expr->neq($property, $parameter);
            case FilterOperator::LOWER_THAN:
                return $expr->lt($property, $parameter);
            case FilterOperator::LOWER_THAN_OR_EQUAL:
                return $expr->lte($property, $parameter);
            case FilterOperator::GREATER_THAN:
                return $expr->gt($property, $parameter);
            case FilterOperator::GREATER_THAN_OR_EQUAL:
                return $expr->gte($property, $parameter);
            case FilterOperator::IN:
                return $expr->in($property, $parameter);
            case FilterOperator::NOT_IN:
                return $expr->notIn($property, $parameter);
            case FilterOperator::MEMBER:
                return $expr->isMemberOf($parameter, $property);
            case FilterOperator::NOT_MEMBER:
                return $expr->not($expr->isMemberOf($parameter, $property));
            case FilterOperator::LIKE:
                return $expr->like($property, $parameter);
            case FilterOperator::NOT_LIKE:
                return $expr->notLike($property, $parameter);
            case FilterOperator::START_WITH:
                return $expr->like($property, $parameter);
            case FilterOperator::NOT_START_WITH:
                return $expr->notLike($property, $parameter);
            case FilterOperator::END_WITH:
                return $expr->like($property, $parameter);
            case FilterOperator::NOT_END_WITH:
                return $expr->notLike($property, $parameter);
            case FilterOperator::IS_NULL:
                return $expr->isNull($property);
            case FilterOperator::IS_NOT_NULL:
                return $expr->isNotNull($property);
            default:
                return $expr->eq($property, $parameter);
        }
    }