Set the entity abstract.

@param boolean $abstract Flag if the entity is abstract or not.
2298
public function setAbstract($abstract)
    {
        if ($abstract === true) {
            $this->addModifier(Modifiers::MODIFIER_ABSTRACT);
        } else {
            $this->removeModifier(Modifiers::MODIFIER_ABSTRACT);
        }
    }
678476
public function setEntities(array $entities)
    {
        foreach ($entities as $entity) {
            if (! $entity instanceof AbstractEntity) {
                $message = sprintf(
                    'Expected an array of entities. Array contains element of type %s.',
                    gettype($entity)
                );

                throw new InvalidArgumentException($message);
            }
        }

        $this->entities = $entities;
    }
317006
public function unique(bool $unique = true): AbstractIndex
    {
        $this->type = $unique ? self::UNIQUE : self::NORMAL;

        return $this;
    }
480904
public function setInstance($object, $abstract = null)
    {
        if (!is_object($object)) {
            throw new \InvalidArgumentException('$object must be an object');
        }
        if ($abstract === null) {
            //If $abstract is not specified, use $objects class
            $abstract = get_class($object);
        } elseif ($abstract[0] === '\\') {
            //Strip all leading backslashes
            $abstract = substr($abstract, 1);
        }
        $concrete = $this->findMostConcreteDefinition($abstract);
        if (isset($this->objects[$concrete])) {
            //If this class already has an instance, we'll return the old object
            $old = $this->objects[$concrete];
        } else {
            $old = false;
        }
        //Store the object
        $this->objects[$concrete] = $object;

        return $old;
    }
267013
public function bindIf($abstract, $concrete, $shared = false)
    {
        if ( ! isset($this->bindings[$abstract]) && ! isset($this->instances[$abstract])) {
            $this->bind($abstract, $concrete, $shared);
        }
    }
1088789
public function setActive($isActive)
    {
        $this->isActive = (bool) $isActive;
        
        if ($this->parent !== null) {
            $this->parent->setActive($isActive);
        }
    }
1107529
public function noReset($bool = false)
	{
		if (is_bool($bool)) {
			$this->noReset = $bool;
		} else {
			throw new RuntimeException('Invalid parameter type setted, expected boolean, got ' . gettype($bool));
		}
	}
1209864
public function setEntityType(string $entityType): void {
		if (!class_exists($entityType)) {
			throw new EntityFactoryException("Unknown entity: $entityType.", EntityFactoryException::UNKNOWN_ENTITY);
		}
		
		// now that we know a class with the name of entityType exists, we need
		// to see if it is an implementation of our EntityInterface object.  the
		// use of the Aura DI container to inject dependencies seems to prevent
		// the use of the PHP is_a() and is_subclass_of() functions.  instead,
		// we'll try to instantiate it like it's an EntityInterface and then we
		// can use the instanceof operator to be sure.
		
		$this->entityType = $entityType;
		$temp = $this->newEntity([]);
		
		if (!($temp instanceof EntityInterface)) {
			
			// if that didn't work, then not only do we want to throw an
			// exception, but we also want to be sure that we set the
			// entityType property back to null so that it doesn't accidentally
			// get used elsewhere after the exception is caught.
			
			$this->entityType = null;
			throw new EntityFactoryException("Not an entity: $entityType.", EntityFactoryException::NOT_AN_ENTITY);
		}
	}
80155
public function bind($abstract, $concrete = null, $singleton = false)
    {
        if (is_array($abstract)) {
            list($abstract, $alias) = [key($abstract), current($abstract)];
            $this->alias($abstract, $alias);
        }

        $abstract = $this->filter($abstract);
        $concrete = $this->filter($concrete);

        if (is_null($concrete)) {
            $concrete = $abstract;
        }

        $this->binds[$abstract] = compact('concrete', 'singleton');
        return $this;
    }
735522
public function setAuth(Google_Auth_Abstract $auth)
  {
    $this->config->setAuthClass(get_class($auth));
    $this->auth = $auth;
  }
1220454
public function bind(string $abstract, $concrete = null, array $arguments = []): self
    {
        $this->data->bind($abstract, $concrete, $arguments);

        return $this;
    }
815617
public function setQuiet($bool)
    {
        $this->quiet = $bool;
        if ($this->quiet) {
            $this->failonerror = false;
        }
    }
909043
public static int setAbstract(int modifier, boolean b) {
        if (b) {
            return (modifier | ABSTRACT) & 
                (~FINAL & ~VOLATILE & ~TRANSIENT & ~NATIVE &
                 ~SYNCHRONIZED & ~STRICT);
        }
        else {
            return modifier & ~ABSTRACT & ~INTERFACE;
        }
    }
1142207
protected function setValue($value)
    {
        if (! is_bool($value)) {
            throw InvalidTypeException::fromMessageAndPrototype("Value must be a boolean", static::prototype());
        }

        $this->value = $value;
    }
672375
public function ifTrue($bool)
    {
        if (null !== $this->apply) {
            throw new \RuntimeException('Cannot nest ifTrue or ifFalse call');
        }

        $this->apply = (true === $bool);

        return $this;
    }
763521
public function setModelType($modelType)
    {
        if ($modelType < self::MODELTYPE_ENTITY || $modelType > self::MODELTYPE_VALUEOBJECT) {
            throw new \InvalidArgumentException('"' . $modelType . '" is an invalid model type.', 1212519195);
        }
        $this->modelType = $modelType;
    }
1305773
public function setKeepalive($bool)
    {
        $this->keepalive = (bool)$bool;
        $this->setOption(\EventUtil::SOL_SOCKET, \EventUtil::SO_KEEPALIVE, $this->keepalive ? true : false);
    }