==================
516284
protected boolean mightBeValidatorAnnotated() {
        for (ActionFormProperty property : propertyMap.values()) {
            final Field field = property.getPropertyDesc().getField();
            if (field == null) { // not field property
                continue;
            }
            for (Annotation anno : field.getAnnotations()) {
                if (isValidatorAnnotation(anno.annotationType())) {
                    return true; // first level only
                }
            }
        }
        return false;
    }
807856
public function init()
    {
        parent::init();

        $this->configs = array_replace_recursive($this->configs, ['dataProvider' => $this->dataProvider]);
        $this->configs = array_replace_recursive($this->configs, ['columns' => $this->columns]);
        $this->configs = array_replace_recursive($this->configs, ['dataProvider' => $this->dataProvider]);
        $this->configs = array_replace_recursive($this->configs, ['filterModel' => $this->filterModel]);
        $this->configs = array_replace_recursive($this->configs, ['filterModel' => $this->pjax]);

        if ('' != $this->id) {
            $this->configs = array_replace_recursive($this->configs, ['id' => $this->id]);
        }

        GridViewAsset::register($this->getView());
    }
1123840
public function init()
    {
        parent::init();
        $this->db = Instance::ensure($this->db, Connection::className());
        if ($this->cache !== null) {
            $this->cache = Instance::ensure($this->cache, Cache::className());
        }
    }
536938
public function initialize()
    {

        $this->length = null;
        $this->life = null;
        $this->autoApprove = false;
        $this->expires = null;

    }
152362
public function update()
    {
        if (!$this->exists()) {
            throw new \RuntimeException('Cannot update a table that doesn\'t exist!');
        }

        // update table
        foreach ($this->getPendingColumns() as $column) {
            $this->getAdapter()->addColumn($this, $column);
        }

        foreach ($this->getIndexes() as $index) {
            $this->getAdapter()->addIndex($this, $index);
        }

        foreach ($this->getForeignKeys() as $foreignKey) {
            $this->getAdapter()->addForeignKey($this, $foreignKey);
        }

        $this->saveData();
        $this->reset(); // reset pending changes
    }
159786
public function commit() : void
    {
        if (null === $this->is_valid) {
            $this->validate();
        }
        if ($this->is_valid && $this->user_value != null) {
            $this->default_value = $this->user_value;
        }
        $this->user_value = null;
        $this->is_valid = null;
        $this->is_changed = false;
    }
1155837
public function init(): void
    {
        if ($this->sourcePath !== null) {
            $this->sourcePath = $this->findPath($this->sourcePath);
        }
        if ($this->basePath !== null) {
            $this->basePath = $this->findPath($this->basePath);
        }
        if ($this->baseUrl !== null) {
            $this->baseUrl = rtrim(Yii::getAlias($this->baseUrl), '/');
        }
    }
1362420
public void init(final Connection connection, final String devname) throws DevFailed {
		 connection.url = new TangoUrl(devname);
		 connection.setDevice_is_dbase(false);
		 connection.devname = connection.url.devname;

		 // Check if connection is possible
		 if (connection.url.protocol == TANGO && connection.url.use_db) {
	    	 connection.ior = get_exported_ior(connection);
		 }
    }
1033482
public function process()
    {
        parent::process();

        if ($this->value === null) {
            return;
        }

        try {
            $integer_value = $this->getNumericValue($this->value);

            if ($integer_value === null) {
                $this->addMessage($this->getValidationMessage('integer'));
            } else {
                $this->value = $integer_value;
            }
        } catch (SwatIntegerOverflowException $e) {
            if ($e->getSign() > 0) {
                $this->addMessage(
                    $this->getValidationMessage('integer-maximum')
                );
            } else {
                $this->addMessage(
                    $this->getValidationMessage('integer-minimum')
                );
            }

            $integer_value = null;
        }
    }
647781
public function init()
    {
        $valid = null;

        if ($this->cache->has(self::CACHE_KEY)) {
            $cached = $this->cache->get(self::CACHE_KEY);
            $valid  = $cached && isset($cached['hosts']) && count($cached['hosts']);
        }


        if ($valid) {
            $this->map = $cached;
        } else {
            $this->build();
        }
    }
257868
public function process()
    {
        parent::process();

        if ($this->value === null) {
            $this->path = array();
        } else {
            $this->path = $this->value;
            $this->value = end($this->path);
        }
    }
490995
public function run()
    {
        Model::unguard();

        if(!OrderStatus::find(OrderStatus::PENDING_PAYMENT))
            OrderStatus::create([
                'id' => OrderStatus::PENDING_PAYMENT,
                'code' => 'pending_payment',
                'name' => 'Pending Payment',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::PENDING_PAYMENT_APPROVAL))
            OrderStatus::create([
                'id' => OrderStatus::PENDING_PAYMENT_APPROVAL,
                'code' => 'pending_approval',
                'name' => 'Pending Payment Approval',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::PENDING))
            OrderStatus::create([
                'id' => OrderStatus::PENDING,
                'code' => 'pending',
                'name' => 'Pending',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::PROCESSING))
            OrderStatus::create([
                'id' => OrderStatus::PROCESSING,
                'code' => 'processing',
                'name' => 'Processing',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::SHIPPING))
            OrderStatus::create([
                'id' => OrderStatus::SHIPPING,
                'code' => 'shipping',
                'name' => 'Shipping',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::SHIPPED))
            OrderStatus::create([
                'id' => OrderStatus::SHIPPED,
                'code' => 'shipped',
                'name' => 'Shipped',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::COMPLETED))
            OrderStatus::create([
                'id' => OrderStatus::COMPLETED,
                'code' => 'completed',
                'name' => 'Completed',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::CANCELED))
            OrderStatus::create([
                'id' => OrderStatus::CANCELED,
                'code' => 'canceled',
                'name' => 'Canceled',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::PARTIALLY_CANCELED))
            OrderStatus::create([
                'id' => OrderStatus::PARTIALLY_CANCELED,
                'code' => 'partially_canceled',
                'name' => 'Partially Canceled',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::REFUNDED))
            OrderStatus::create([
                'id' => OrderStatus::REFUNDED,
                'code' => 'refunded',
                'name' => 'Refunded',
                'is_system' => true,
            ]);
        if(!OrderStatus::find(OrderStatus::PARTIALLY_REFUNDED))
            OrderStatus::create([
                'id' => OrderStatus::PARTIALLY_REFUNDED,
                'code' => 'partially_refunded',
                'name' => 'Partially Refunded',
                'is_system' => true,
            ]);

        $this->call(SentinelGroupSeedTableSeeder::class);
    }
395675
public function init()
    {
        if ($this->widget !== null) {
            $this->widget->init();
        }

        // ensure the widget has an id
        if ($this->widget->id === null) {
            $this->widget->id = $this->widget->getUniqueId();
        }
    }
885885
public function validateResolved()
    {
        $this->prepareForValidation();

        if (! $this->passesAuthorization()) {
            $this->failedAuthorization();
        }

        $instance = $this->getValidatorInstance();

        if ($instance->fails()) {
            $this->failedValidation($instance);
        }
    }
803308
public function validate() {
		parent::validate();

		if ($this->getId() === null) {
			throw new ValidationException("'id' can't be null", 'id', $this);
		}
		if ($this->getVersion() === null) {
			throw new ValidationException("'version' can't be null", 'version', $this);
		}
	}
1341358
public function init() {

		parent::init();

		$this->countryService	= Yii::$app->factory->get( 'countryService' );
		$this->provinceService 	= Yii::$app->factory->get( 'provinceService' );
		$this->regionService 	= Yii::$app->factory->get( 'regionService' );
		$this->addressService	= Yii::$app->factory->get( 'addressService' );
	}
3823
public function init()
    {
        $this->_init();

        if ($this->id_field) {
            $this->addField($this->id_field, [
                'system'    => true,
            ]);
        }
    }