{@inheritdoc}

@throws \Rexlabs\ArrayObject\Exceptions\InvalidOffsetException
765610
public function offsetUnset($offset)
    {
        if (!$this->isCollection()) {
            $this->forceCollection();
        }
        if (!isset($this->data[$offset])) {
            throw new InvalidOffsetException('Cannot unset value of collection at index '.$offset);
        }
        unset($this->data[$offset]);

        // Fix indexes
        $this->data = array_values($this->data);
    }
1088461
public function offsetUnset($offset) {
		if($this->isCollection)
		{
			unset($this->data[$offset]);
		}
		else
		{
			unset($this->data->{$offset});
		}
	}
156163
public function offsetSet($offset, $value)
    {
        Argument::i()
            //argument 1 must be scalar, null or bool
            ->test(1, 'scalar', 'null', 'bool')
            //argument 2 must be an array or Eden\Collection\Model
            ->test(2, 'array', $this->model);

        if (is_array($value)) {
            //make it a model
            $model = $this->model;
            $value = $this->$model($value);
        }

        if (is_null($offset)) {
            $this->list[] = $value;
        } else {
            $this->list[$offset] = $value;
        }
    }
484611
public function offsetSet($offset, $value)
    {
        if ($offset === '' || $offset === null) {
            throw new \InvalidArgumentException('The key of a collection must always be set');
        }

        $this->items[$offset] = $value;
    }
1115149
public function offsetUnset($object)
    {
        if (!$object instanceof KObjectHandlable) {
            throw new InvalidArgumentException('Object needs to implement KObjectHandlable');
        }

        unset($this->_data[$object->getHandle()]);
        return $this;
    }
455443
function offsetSet($offset, $value)
    {
        if (!$value instanceof Attribute) {
            throw new InvalidArgumentException(
                "Value is not an instance of \\Sirel\\Attribute"
            );
        }
        $this->attributes[$offset] = $value;
    }
751508
public function offsetSet($offset, $value)
    {
        $offset = is_string($offset) ? trim($offset) : null;
        if (empty($offset)) throw new \InvalidArgumentException('Offset must be a non empty string.');

        $this->data[$offset] = $value;
    }
436787
public function offsetSet($offset, $value)
    {
        if (is_null($offset)) {
            $this->_args[count($this->_args)] = $value;
        } else {
            if (is_int($offset)) {
                $this->_args[$offset] = $value;
            } else {
                throw new \Exception('Cannot set offset \''.$offset.'\' of IndexedArray.');
            }
        }
    }
1207027
public function offsetSet($offset, $value)
    {
        if (is_array($this->object)) {
            $this->object[$offset] = $value;

            return;
        }

        $this->object->$offset = $value;
    }
1244463
public function offsetGet($offset)
    {
        if (isset($this->storage[$offset])) {
            return $this->storage[$offset];
        }
        if (!isset($this->storageDefs[$offset])) {
            if (empty($this->allowsUndefinedKey)) {
                throw new InvalidArgumentException(
                    sprintf("Key '%s' does not exists", $offset)
                );
            }
            return;
        }
        if (is_array($def = $this->storageDefs[$offset])) {
            if (isset($def['getter'])) {
                return $this->{$def['getter']}();
            }
            if (isset($def['default'])) {
                if (   is_int($def['default'])
                    && isset($def['enum'][$def['default']])
                ) {
                    return $this->storage[$offset] = $def['enum'][$def['default']];
                }
                return $this->storage[$offset] = $def['default'];
            }
        }
    }
244525
public function setOffset($offset) {
        if (!is_numeric($offset) || $offset < 0) {
            throw new \InvalidArgumentException("Invalid offset '$offset.'", 500);
        }

        $this->offset = (int)$offset;
        return $this;
    }
284246
public function offsetUnset( $offset ) {
        $temp = $this->values();

        if ( isset( $temp[ $offset ] ) ) {
            unset( $temp[ $offset ] );
        }

        $this->exchangeArray( array_values( $temp ) );

        $this->size = $this->count();
    }
399501
public function bind($values)
    {
        if ( ! is_array($values) ) {
            throw new InvalidException('Values assigned to a block must be an array');
        }

        // only one value
        if ( ! $this->isArrayMulti($values) ) {
            $this->bindings[] = $values;
            return $this;
        }

        // multiple values
        foreach ( $values as $line ) {
            $this->bind($line);
        }

        return $this;
    }
275809
public function offsetSet($offset, $value)
    {
        /**
         * @var UniqueIdentity $value
         */
        $this->elements->offsetSet($value->uId()->id(), $value);
    }
854716
public function offsetSet($offset, $value): void
    {
        if (false === $this->checkType($this->getKeyType(), $offset)) {
            throw new InvalidArgumentException(
                'Key must be of type ' . $this->getKeyType() . '; key is '
                . $this->toolValueToString($offset)
            );
        }

        if (false === $this->checkType($this->getValueType(), $value)) {
            throw new InvalidArgumentException(
                'Value must be of type ' . $this->getValueType() . '; value is '
                . $this->toolValueToString($value)
            );
        }

        parent::offsetSet($offset, $value);
    }
624810
public function offsetSet($offset, $value)
    {
        if(is_array($this->obj)){
            $this->obj[$offset] = $value;
        }elseif(self::hasProperty($this->obj, $offset)){
            $this->obj->{$offset} = $value;
        }elseif(method_exists($this->obj, 'set')){
            $this->obj->set($offset, $value);
        }elseif(method_exists($this->obj, $method = 'set'.ucfirst($offset))){
            $this->obj->{$method}($value);
        }else{
            throw new \BadMethodCallException("can not set $offset");
        }
    }
1010664
public final function setFetchObject(string $fetchObject): void
    {
        if (!class_exists($fetchObject)) {
            throw new InvalidValueException("Fetch object class '{$fetchObject}' not found!");
        }

        $this->fetchObject = $fetchObject;
    }