The scope which not been soft deleted

@param bool $skip Skip
@return bool Result
165473
protected function _addSoftDeletedCondition()
    {
        if ($this->_withoutSoftDeletedScope) {
            // Reset SOFT_DELETED switch
            $this->_withoutSoftDeletedScope = false;
        } 
        elseif (static::SOFT_DELETED && isset($this->softDeletedFalseValue)) {
            // Add condition
            $this->_dbr->where($this->_field(static::SOFT_DELETED), 
            $this->softDeletedFalseValue);
        }
        
        return true;
    }
567269
public function runDirectives(QueryInterface $query, array $skipDirective = [])
    {
        foreach ($this->directives as $key => $value) {
            if (in_array($key, $skipDirective, true)) {
                continue;
            }
            if (!$this->hasDirectiveHandler($key)) {
                continue;
            }
            if (is_callable($this->getDirectiveHandler($key))) {
                call_user_func($this->getDirectiveHandler($key), $query, $value, $this->directives);
            }
        }
    }
104433
public function limit($limit, $skip = null)
    {
        $this->pipeline['$limit'] = $limit;
        if (!empty($skip)) {
            $this->pipeline['$skip'] = $skip;
        }

        return $this;
    }
394088
public function scopeAt($levels, $replace = false)
    {
        $prev = $this->scopedErrors;
        $this->scopedErrors = (int) $levels;
        if (!$replace) {
            $this->scopedErrors |= $prev;
        }

        return $prev;
    }
1097157
private static function _skipFormating()
    {
        return false;

        if(null !== self::$_isAjaxOrCli) {
            return self::$_isAjaxOrCli;
        }

        self::$_isAjaxOrCli =
            (isset($_SERVER['HTTP_X_REQUESTED_WITH']) && $_SERVER['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest')
            || (php_sapi_name() == 'cli' && empty($_SERVER['REMOTE_ADDR']));

        return self::$_isAjaxOrCli;
    }
1269068
public function flatArray($array = array(), $skip = array())
    {
        if (count($array) == 0) {
            $this->errorMessage[] = 'FLAT_ARRAY: array for flatArray is empty';
            return array();
        }
        $return = array();
        foreach ($array as $name => $item) {
            if (!in_array($name, $skip)) {
                if (is_array($item)) {
                    foreach ($item as $subItem) {
                        $return[] = $subItem;
                    }
                } elseif (!is_array($item)) {
                    $return[] = $item;
                }
            }
        }
        return $return;
    }
279434
public function hasScope(Scope $scope)
    {
        foreach ($scope->toArray() as $scopeToken) {
            if (!$this->hasScopeToken($scopeToken)) {
                return false;
            }
        }

        return true;
    }
750429
public function isStripped($isStripped = null)
        {
            if (null === $isStripped) {
                return $this->_stripped;
            }

            $this->_stripped = (bool) $isStripped;

            return $this;
        }
1065537
public function isValid($scope = null, $options = null)
    {
        if (!$this->isSubmitted()) {
            return false;
        }

        // Check for internal errors & validator errors
        if ((isset($this->validator) && $this->validator->isValid($scope, $options) && empty($this->errors)) || (!isset($this->validator) && empty($this->errors))) {
            if (isset($this->restoreDataHandler)) {
                $this->restoreDataHandler->setValid($this);
            }

            return true;
        }
        else {
            // There were errors, save them for the next request
            if (isset($this->restoreDataHandler)) {
                $this->restoreDataHandler->setRestorableErrors($this, $this->getValidationErrors());
            }

            if (isset($this->restoreDataHandler)) {
                $this->restoreDataHandler->setInvalid($this);
            }

            return false;
        }
    }
115729
final public function isDeleted()
    {
        $column = static::SOFT_DELETE;
        if ($column) {
            $value = $this->__get($column);
            switch (static::SOFT_DELETE_MODE) {
                case 'deleted':
                    $result = (int) $value === 1;
                    break;

                case 'active':
                    $result = (int) $value === 0;
                    break;

                case 'stamp':
                    $result = $value !== null;
                    break;

                default:
                    throw new \LogicException(sprintf(
                        "%s has invalid SOFT_DELETE_MODE mode: '%s'",
                        static::class,
                        static::SOFT_DELETE_MODE
                    ));
                    break;
            }
            return $result;
        }
        return false;
    }
815693
public function add($value, $skipconverter=false)
    {
        $foo = null;
        $tempvalue = $value;

        $insert = true;
        if($skipconverter===false && $this->__converter !== null)
        {
            if($this->__converter instanceof IListConverter && $this->__converter->isItemConverterExist())
            {
                $insert = $this->__converter->getItemConverter()->deserializeAll($tempvalue, $foo);
            }
            else if($this->__converter instanceof IItemConverter)
            {
                $insert = $this->__converter->deserializeAll($tempvalue, $foo);
            }
        }

        if($insert===true)
        {
            $this->__data[] = $tempvalue;
            $this->invalidateKeycache();
        }

        return $this;
    }
803310
public function limit($skip, $limit)
    {
        $this->limit = $limit;
        $this->skip = $skip;
        return $this;
    }
1211952
public function checkForUpdates($quick = false)
    {

        if (!$this->subModuleUpdater) {
            $this->site->getVariables()->setValue("last_checked", time());
        }
        if ($this->canBeUpdated === null) {
            $this->canBeUpdated = $this->site->getVariables()->getValue("can_be_updated") == 1;
        }
        if ($this->canBeUpdated) {
            return true;
        }

        if($quick){
            return false;
        }

        $this->exec("git fetch");

        $updateAvailable = ($this->getRevision('HEAD') != $this->getRevision("origin/" . $this->currentBranch()) || array_reduce($this->subUpdaters, function ($result, Updater $input) {
                return $result || $input->checkForUpdates();
            }, false));
        if ($this->canBeUpdated != $updateAvailable) {
            $this->site->getVariables()->setValue("can_be_updated", $updateAvailable ? 1 : 0);
        }

        return $this->canBeUpdated = $updateAvailable;
    }
108013
function skip($ofs=1) {
		$this->document=($out=parent::skip($ofs))?$out->document:[];
		if ($this->document && isset($this->trigger['load']))
			\Base::instance()->call($this->trigger['load'],$this);
		return $out;
	}
98758
function erase($filter=NULL,$quick=TRUE) {
		if ($filter) {
			if (!$quick) {
				foreach ($this->find($filter) as $mapper)
					if (!$mapper->erase())
						return FALSE;
				return TRUE;
			}
			return $this->legacy?
				$this->collection->remove($filter):
				$this->collection->deletemany($filter);
		}
		$pkey=['_id'=>$this->document['_id']];
		if (isset($this->trigger['beforeerase']) &&
			\Base::instance()->call($this->trigger['beforeerase'],
				[$this,$pkey])===FALSE)
			return FALSE;
		$result=$this->legacy?
			$this->collection->remove(['_id'=>$this->document['_id']]):
			$this->collection->deleteone(['_id'=>$this->document['_id']]);
		parent::erase();
		if (isset($this->trigger['aftererase']))
			\Base::instance()->call($this->trigger['aftererase'],
				[$this,$pkey]);
		return $result;
	}
979786
private function skip(ContextInterface $context)
    {
        $dataStack = $context->getDataStack();
        $metadataStack = $context->getMetadataStack();
        $references = [];
        $depth = 0;

        for ($index = count($metadataStack) - 1; $index >= 0; --$index) {
            $metadata = $metadataStack[$index];
            $data = $dataStack[$index];

            if ($metadata instanceof ClassMetadataInterface) {
                $hash = spl_object_hash($data);

                if (!isset($references[$hash])) {
                    $references[$hash] = 0;
                }

                if (++$references[$hash] > $this->circularReferenceLimit) {
                    return true;
                }
            }

            if ($metadata instanceof TypeMetadataInterface) {
                ++$depth;
            }

            if (!$metadata instanceof PropertyMetadataInterface) {
                continue;
            }

            ++$depth;

            if (!$metadata->hasMaxDepth()) {
                continue;
            }

            if ($depth > $metadata->getMaxDepth()) {
                return true;
            }
        }

        return false;
    }
221378
protected function hasListifyScopeChanged()
    {
        $scope = $this->normalizeListifyScope($this->getScopeName(), true);

        if ($scope instanceof BelongsTo) {
            // for BelongsTo scopes, use a cleaner way to check for differences
            $foreignKey = $scope->getForeignKeyName();
            return (Arr::get($this->getOriginal(), $foreignKey) != $this->getAttribute($foreignKey));
        }

        if (null === $this->stringScopeValue && ! $this->stringScopeNullExplicitlySet) {

            // if the known previous scope is null, make sure this isn't the result of a
            // variable scope that returned null - if that is the case, the scope has changed
            if (null !== $scope && $this->hasVariableListifyScope()) {
                
                $this->swapChangedAttributes();
                $previousScope = $this->normalizeListifyScope($this->getScopeName());
                $this->swapChangedAttributes();
                
                if (null === $previousScope) return true;
            }

            $this->stringScopeValue = $scope;
            $this->stringScopeNullExplicitlySet = (null === $scope);
            return false;
        }

        return ($scope != $this->stringScopeValue);
    }