To update class max LLOC value if new one is bigger then older one

@param string $sClassName class name
@param int    $iLLOC      value of LLOC
168166
public function updateClassMaxLLOC($sClassName, $iLLOC)
    {
        if (!isset($this->_aStats[$sClassName]['max']['locExecutable'])
            || $this->_aStats[$sClassName]['max']['locExecutable'] < $iLLOC
        ) {
            $this->_aStats[$sClassName]['max']['locExecutable'] = $iLLOC;
        }
    }
967281
public function updateClassMaxNPath($sClassName, $iNPath)
    {
        if (!isset($this->_aStats[$sClassName]['max']['npath'])
            || $this->_aStats[$sClassName]['max']['npath'] < $iNPath
        ) {
            $this->_aStats[$sClassName]['max']['npath'] = $iNPath;
        }
    }
158516
private void updateGlobalNameDeclarationAtClassNode(Name n, boolean canCollapseChildNames) {
    if (!canCollapseChildNames || !canCollapse(n)) {
      return;
    }

    Ref ref = n.getDeclaration();
    String className = ref.getNode().getString();
    addStubsForUndeclaredProperties(
        n, className, ref.getNode().getAncestor(2), ref.getNode().getParent());
  }
834186
protected function setView($sCtrlName, $sActionName)
    {
        $this->view = ViewFactory::createView($sCtrlName, $sActionName);
        if (!is_null($this->layout)) {
            $this->layout->view = $this->view;
        }
    }
1165972
public function clearIndices($className)
    {
        $this->checkImplementsSearchableInterface($className);
        /** @var SearchableInterface $activeRecord */
        $activeRecord = $this->activeRecordFactory->make($className);
        $indices = $indices = $this->initIndices($activeRecord);

        return $this->processIndices($indices, function (Index $index) {
            return $index->clearIndex();
        });
    }
637087
public function update_form_data(stdClass $data) : stdClass {
        $answercount = count($this->get_answers());
        // Check for other answer entry.
        $lastanswer = $data->{'answer_editor[' . ($answercount - 1) . ']'};
        if (strpos($lastanswer, LESSON_OTHER_ANSWERS) !== false) {
            $data->{'answer_editor[' . ($this->lesson->maxanswers + 1) . ']'} =
                    $data->{'answer_editor[' . ($answercount - 1) . ']'};
            $data->{'response_editor[' . ($this->lesson->maxanswers + 1) . ']'} =
                    $data->{'response_editor[' . ($answercount - 1) . ']'};
            $data->{'jumpto[' . ($this->lesson->maxanswers + 1) . ']'} = $data->{'jumpto[' . ($answercount - 1) . ']'};
            $data->{'score[' . ($this->lesson->maxanswers + 1) . ']'} = $data->{'score[' . ($answercount - 1) . ']'};
            $data->enableotheranswers = true;
            // Unset the old values.
            unset($data->{'answer_editor[' . ($answercount - 1) . ']'});
            unset($data->{'response_editor[' . ($answercount - 1) . ']'});
            unset($data->{'jumpto[' . ($answercount - 1) . ']'});
            unset($data->{'score[' . ($answercount - 1) . ']'});
        }
        return $data;
    }
494266
public static function clear($sClassName, $iElementID)
    {
        $sKey = self::getKey($sClassName, $iElementID);
        if (!isset(self::$arItemStore[$sKey])) {
            return;
        }

        unset(self::$arItemStore[$sKey]);
    }
1271537
public function pushClassNameToDtoClassNameReplaceFragments(array $classNameToDtoClassNameReplaceFragments, $mergeWithExistingFragments = TRUE) {
		array_push($this->classNameToDtoClassNameReplaceFragmentsStack, $this->classNameToDtoClassNameReplaceFragments);
		array_push($this->classMappingConfigurationStack, $this->classMappingConfiguration);
		$this->classNameToDtoClassNameReplaceFragments = \Netlogix\Crud\Utility\ArrayUtility::arrayMergeRecursiveOverrule(
			$mergeWithExistingFragments ? $this->classNameToDtoClassNameReplaceFragments : array(),
			$classNameToDtoClassNameReplaceFragments
		);
	}
714390
public static function addType($name, $className)
    {
        if (isset(self::$_typesMap[$name])) {
            throw OXMException::typeExists($name);
        }

        self::$_typesMap[$name] = $className;
    }
909874
public void updateCacheSizes(long max, long current) {

        final String methodName = "updateCacheSizes()";

        if (tc.isDebugEnabled() && null != _maxInMemoryCacheEntryCount && null != _inMemoryCacheEntryCount) {
            if (max != _maxInMemoryCacheEntryCount.getCount() && _inMemoryCacheEntryCount.getCount() != current)
                Tr.debug(tc, methodName + " cacheName=" + _sCacheName + " max=" + max + " current=" + current + " enable=" + this._enable, this);
        }

        if (_enable) {
            if (_maxInMemoryCacheEntryCount != null)
                _maxInMemoryCacheEntryCount.setCount(max);

            if (_inMemoryCacheEntryCount != null)
                _inMemoryCacheEntryCount.setCount(current);
        }
    }
734715
public function setLastName($lname)
    {
        if (!is_string($lname)) {
            $lname = strval($lname);
        }

        $this->lname = $lname;
    }
667400
private void checkMaxOccurs(List<Element> elements, int maxOccurs, String typeName) {

        if (elements.size() > maxOccurs) {
            if (typeName.equals(CmsXmlCategoryValue.TYPE_NAME)) {
                if (maxOccurs == 1) {
                    Element category = elements.get(0);
                    List<Element> categories = new ArrayList<Element>();
                    for (Element value : elements) {
                        Iterator<Element> itLink = value.elementIterator();
                        while (itLink.hasNext()) {
                            Element link = itLink.next();
                            categories.add((Element)link.clone());
                        }
                    }
                    category.clearContent();
                    for (Element value : categories) {
                        category.add(value);
                    }
                }
            }

            // too many nodes of this type appear according to the current schema definition
            for (int lo = (elements.size() - 1); lo >= maxOccurs; lo--) {
                elements.remove(lo);
            }
        }
    }
604396
public function updateNamedFormulas(PHPExcel $pPhpExcel, $oldName = '', $newName = '')
    {
        if ($oldName == '') {
            return;
        }

        foreach ($pPhpExcel->getWorksheetIterator() as $sheet) {
            foreach ($sheet->getCellCollection(false) as $cellID) {
                $cell = $sheet->getCell($cellID);
                if (($cell !== null) && ($cell->getDataType() == PHPExcel_Cell_DataType::TYPE_FORMULA)) {
                    $formula = $cell->getValue();
                    if (strpos($formula, $oldName) !== false) {
                        $formula = str_replace("'" . $oldName . "'!", "'" . $newName . "'!", $formula);
                        $formula = str_replace($oldName . "!", $newName . "!", $formula);
                        $cell->setValueExplicit($formula, PHPExcel_Cell_DataType::TYPE_FORMULA);
                    }
                }
            }
        }
    }
1300901
public static function updateMorphMap($classNames = null)
    {
        if (is_null($classNames)) {
            $classNames = [
                static::classname(Role::class),
                static::classname(Ability::class),
            ];
        }

        Relation::morphMap($classNames);
    }
241057
public function updateDocumentIndexes(string $documentName, ?int $maxTimeMs = null, ?WriteConcern $writeConcern = null) : void
    {
        $class = $this->dm->getClassMetadata($documentName);

        if ($class->isMappedSuperclass || $class->isEmbeddedDocument || $class->isQueryResultDocument) {
            throw new InvalidArgumentException('Cannot update document indexes for mapped super classes, embedded documents or aggregation result documents.');
        }

        $documentIndexes = $this->getDocumentIndexes($documentName);
        $collection      = $this->dm->getDocumentCollection($documentName);
        $mongoIndexes    = iterator_to_array($collection->listIndexes());

        /* Determine which Mongo indexes should be deleted. Exclude the ID index
         * and those that are equivalent to any in the class metadata.
         */
        $self         = $this;
        $mongoIndexes = array_filter($mongoIndexes, static function (IndexInfo $mongoIndex) use ($documentIndexes, $self) {
            if ($mongoIndex['name'] === '_id_') {
                return false;
            }

            foreach ($documentIndexes as $documentIndex) {
                if ($self->isMongoIndexEquivalentToDocumentIndex($mongoIndex, $documentIndex)) {
                    return false;
                }
            }

            return true;
        });

        // Delete indexes that do not exist in class metadata
        foreach ($mongoIndexes as $mongoIndex) {
            if (! isset($mongoIndex['name'])) {
                continue;
            }

            $collection->dropIndex($mongoIndex['name'], $this->getWriteOptions($maxTimeMs, $writeConcern));
        }

        $this->ensureDocumentIndexes($documentName, $maxTimeMs, $writeConcern);
    }
713785
protected function _readFunctionMetrics($sClass, $oFunction)
    {
        $iCcn = (int)$oFunction['ccn'];
        $iCrap = (int)$oFunction['ccn2'];
        $iNPath = (int)$oFunction['npath'];
        $iLoc = (int)$oFunction['lloc'];

        // Sums
        $this->appendClassTotalCNN($sClass, (int)$iCcn * $iLoc);
        $this->appendClassTotalCrapIndex($sClass, (int)$iCrap * $iLoc);
        $this->appendClassTotalNPath($sClass, (int)$iNPath * $iLoc);
        $this->appendClassTotalLLOC($sClass, $iLoc);

        // Max
        $this->updateClassMaxCCN($sClass, $iCcn);
        $this->updateClassMaxCrapIndex($sClass, $iCrap);
        $this->updateClassMaxNPath($sClass, $iNPath);
        $this->updateClassMaxLLOC($sClass, $iLoc);

        $this->setGlobalValues($iCcn, $iCrap, $iNPath, $iLoc);
    }
540327
public function HasNewMethod($ClassName, $MethodName) {
      $Key = strtolower($ClassName.'_'.$MethodName.'_Create');
      if (array_key_exists($Key, $this->_NewMethodCollection)) {
         $Result = explode('.', $this->_NewMethodCollection[$Key]);
         return $Result[0];
      } else {
         return FALSE;
      }
   }