Updates the associationing map between subcontent and uid.
496086
private function updateSubcontentMap()
    {
        $this->subcontentmap = array();

        $index = 0;
        foreach ($this->_subcontent as $subcontent) {
            $this->subcontentmap[$subcontent->getUid()] = $index++;
        }
    }
518572
public void updateRelationshipIndex(EntityMetadata entityMetadata, GraphDatabaseService graphDb,
            Relationship relationship, MetamodelImpl metaModel)
    {
        if (!isRelationshipAutoIndexingEnabled(graphDb) && entityMetadata.isIndexable())
        {
            Index<Relationship> relationshipIndex = graphDb.index().forRelationships(entityMetadata.getIndexName());

            // Remove all existing relationship entries from Index
            relationshipIndex.remove(relationship);

            // Recreate fresh index on this relationship
            addRelationshipIndex(entityMetadata, relationship, relationshipIndex, metaModel);
        }
    }
57596
function updateExistingItems(groupUi) {
    let itemUi = groupUi.firstElementChild
    while (itemUi) {
      updateItem(itemUi)
      itemUi = itemUi.nextElementSibling
    }
  }
977023
def update_mapping(self, mapping: Dict[ops.Qid, LogicalIndex],
                       keys: Sequence[ops.Qid]
                       ) -> None:
        
        permutation = self.permutation()
        indices = tuple(permutation.keys())
        new_keys = [keys[permutation[i]] for i in indices]
        old_elements = [mapping[keys[i]] for i in indices]
        mapping.update(zip(new_keys, old_elements))
1191441
function onAddChild(e) {
        var self = this;
        if (e.target === self) {
            updateSubTreeStatus(self, e.component, self.get('depth'), e.index);
        }
    }
580743
public void updateAssociations(JMFType type) {
    super.updateAssociations(type);
    itemType.updateAssociations(((JSRepeated)type).getItemType());
  }
618684
def update_cnt(uid, post_data):
        '''
        
        '''
        entry = TabPostHist.update(
            user_name=post_data['user_name'],
            cnt_md=tornado.escape.xhtml_escape(post_data['cnt_md']),
            time_update=tools.timestamp(),
        ).where(TabPostHist.uid == uid)
        entry.execute()
1020250
def update_without_overwrite(d, *args, **kwds):
    
    if args:
        assert len(args) == 1, \
            'At most one positional parameter is allowed: {0!r}'.format(args)

        (other,) = args
        if isinstance(other, Mapping):
            for key in other:
                setitem_without_overwrite(d, key, other[key])
        elif hasattr(other, "keys"):
            for key in other.keys():
                setitem_without_overwrite(d, key, other[key])
        else:
            for key, value in other:
                setitem_without_overwrite(d, key, value)

    for key, value in kwds.items():
        setitem_without_overwrite(d, key, value)
1363538
def update(self, other):
        """"""
        Cluster.update(self, other)
        self.rules.extend(other.rules)
705152
public void updateAssociations(JMFType type) {
    super.updateAssociations(type);
    if (getCaseCount() != ((JSVariant)type).getCaseCount())
      throw new IllegalStateException();
    if (cases != null)
      for (int i = 0; i < cases.length; i++)
         cases[i].updateAssociations(((JSVariant)type).getCase(i));
  }
336722
protected void updateSubjectWithSharedStateContents() {
        subject.getPrincipals().add((WSPrincipal) sharedState.get(Constants.WSPRINCIPAL_KEY));
        subject.getPublicCredentials().add(sharedState.get(Constants.WSCREDENTIAL_KEY));
        if (sharedState.get(Constants.WSSSOTOKEN_KEY) != null)
            subject.getPrivateCredentials().add(sharedState.get(Constants.WSSSOTOKEN_KEY));
    }
354594
function updateAggregations(response) {
  if(response.hasOwnProperty('aggregations')) {
    aggregationsBox.textContent = JSON.stringify(response.aggregations,
                                                 null, 2);
    show(aggregationsCard);
  }
  else {
    hide(aggregationsCard);
  }
}
1266176
protected void updateSubjectWithTemporarySubjectContents() {
        subject.getPrincipals().addAll(temporarySubject.getPrincipals());
        subject.getPublicCredentials().addAll(temporarySubject.getPublicCredentials());
        subject.getPrivateCredentials().addAll(temporarySubject.getPrivateCredentials());
    }
1236105
public function updateIdxContent(AbstractClassContent $content)
    {
        $query = 'INSERT INTO idx_content_content (content_uid, subcontent_uid) '.
                '(SELECT :child, content_uid FROM content_has_subcontent WHERE parent_uid = :child) '.
                'UNION DISTINCT (SELECT parent_uid, :child FROM content_has_subcontent WHERE content_uid = :child) '.
                'UNION DISTINCT (SELECT i.content_uid, :child FROM idx_content_content i WHERE i.subcontent_uid IN (SELECT parent_uid FROM content_has_subcontent WHERE content_uid = :child)) '.
                'UNION DISTINCT (SELECT :child, i.subcontent_uid FROM idx_content_content i WHERE i.content_uid IN (SELECT content_uid FROM content_has_subcontent WHERE parent_uid = :child)) '.
                'UNION DISTINCT (SELECT :child, :child)';

        $params = array(
            'child' => $content->getUid(),
        );

        return $this->removeIdxContentContent($content)
                        ->executeUpdate($query, $params)
                        ->updateIdxPage($content->getMainNode(), $content);
    }
1368321
def update(self, *args, **kwargs):
        """"""
        super(TAG_Compound, self).update(*args, **kwargs)
        for key, item in self.items():
            if item.name is None:
                item.name = key
751999
def update(self, other_dict):
        """"""
        for key, value in iter_multi_items(other_dict):
            MultiDict.add(self, key, value)
707834
public void updateArchive(S indiv) {

    // find the location of 'indiv'
    setLocation(indiv, idealPoint.getValues(), nadirPoint.getValues());
    int location = (int) indiv.getAttribute("region");

    numRanks = nondominated_sorting_add(indiv);

    if (numRanks == 1) {
      deleteRankOne(indiv, location);
    } else {
      ArrayList<S> lastFront = new ArrayList<>(populationSize);
      int frontSize = countRankOnes(numRanks - 1);
      if (frontSize == 0) {  // the last non-domination level only contains 'indiv'
        frontSize++;
        lastFront.add(indiv);
      } else {
        for (int i = 0; i < populationSize; i++) {
          if (rankIdx[numRanks - 1][i] == 1) {
            lastFront.add((S) population.get(i));
          }
        }
        if (((int) indiv.getAttribute(ranking.getAttributeIdentifier())) == (numRanks - 1)) {
//        if (rankSolution.getOrDefault(indiv, 0) == (numRanks - 1)) {
          frontSize++;
          lastFront.add(indiv);
        }
      }

      if (frontSize == 1 && lastFront.get(0).equals(indiv)) {  // the last non-domination level only has 'indiv'
        int curNC = countOnes(location);
        if (curNC > 0) {  // if the subregion of 'indiv' has other solution, drop 'indiv'
          nondominated_sorting_delete(indiv);
        } else {  // if the subregion of 'indiv' has no solution, keep 'indiv'
          deleteCrowdRegion1(indiv, location);
        }
      } else if (frontSize == 1 && !lastFront.get(0).equals(indiv)) { // the last non-domination level only has one solution, but not 'indiv'
        int targetIdx = findPosition(lastFront.get(0));
        int parentLocation = findRegion(targetIdx);
        int curNC = countOnes(parentLocation);
        if (parentLocation == location) {
          curNC++;
        }

        if (curNC == 1) {  // the subregion only has the solution 'targetIdx', keep solution 'targetIdx'
          deleteCrowdRegion2(indiv, location);
        } else {  // the subregion contains some other solutions, drop solution 'targetIdx'
          int indivRank = (int) indiv.getAttribute(ranking.getAttributeIdentifier());
          int targetRank = (int) population.get(targetIdx).getAttribute(ranking.getAttributeIdentifier());
          rankIdx[targetRank][targetIdx] = 0;
          rankIdx[indivRank][targetIdx] = 1;

          S targetSol = population.get(targetIdx);

          replace(targetIdx, indiv);
          subregionIdx[parentLocation][targetIdx] = 0;
          subregionIdx[location][targetIdx] = 1;

          // update the non-domination level structure
          nondominated_sorting_delete(targetSol);
        }
      } else {

        double indivFitness = fitnessFunction(indiv, lambda[location]);

        // find the index of the solution in the last non-domination level, and its corresponding subregion
        int[] idxArray = new int[frontSize];
        int[] regionArray = new int[frontSize];

        for (int i = 0; i < frontSize; i++) {
          idxArray[i] = findPosition(lastFront.get(i));
          if (idxArray[i] == -1) {
            regionArray[i] = location;
          } else {
            regionArray[i] = findRegion(idxArray[i]);
          }
        }

        // find the most crowded subregion, if more than one exist, keep them in 'crowdList'
        ArrayList<Integer> crowdList = new ArrayList<>();
        int crowdIdx;
        int nicheCount = countOnes(regionArray[0]);
        if (regionArray[0] == location) {
          nicheCount++;
        }
        crowdList.add(regionArray[0]);
        for (int i = 1; i < frontSize; i++) {
          int curSize = countOnes(regionArray[i]);
          if (regionArray[i] == location) {
            curSize++;
          }
          if (curSize > nicheCount) {
            crowdList.clear();
            nicheCount = curSize;
            crowdList.add(regionArray[i]);
          } else if (curSize == nicheCount) {
            crowdList.add(regionArray[i]);
          }
        }
        // find the index of the most crowded subregion
        if (crowdList.size() == 1) {
          crowdIdx = crowdList.get(0);
        } else {
          int listLength = crowdList.size();
          crowdIdx = crowdList.get(0);
          double sumFitness = sumFitness(crowdIdx);
          if (crowdIdx == location) {
            sumFitness = sumFitness + indivFitness;
          }
          for (int i = 1; i < listLength; i++) {
            int curIdx = crowdList.get(i);
            double curFitness = sumFitness(curIdx);
            if (curIdx == location) {
              curFitness = curFitness + indivFitness;
            }
            if (curFitness > sumFitness) {
              crowdIdx = curIdx;
              sumFitness = curFitness;
            }
          }
        }

        switch (nicheCount) {
          case 0:
            System.out.println("Impossible empty subregion!!!");
            break;
          case 1:
            // if the subregion of each solution in the last non-domination level only has one solution, keep them all
            deleteCrowdRegion2(indiv, location);
            break;
          default:
            // delete the worst solution from the most crowded subregion in the last non-domination level
            ArrayList<Integer> list = new ArrayList<>();
            for (int i = 0; i < frontSize; i++) {
              if (regionArray[i] == crowdIdx) {
                list.add(i);
              }
            }
            if (list.isEmpty()) {
              System.out.println("Cannot happen!!!");
            } else {
              double maxFitness, curFitness;
              int targetIdx = list.get(0);
              if (idxArray[targetIdx] == -1) {
                maxFitness = indivFitness;
              } else {
                maxFitness = fitnessFunction(population.get(idxArray[targetIdx]), lambda[crowdIdx]);
              }
              for (int i = 1; i < list.size(); i++) {
                int curIdx = list.get(i);
                if (idxArray[curIdx] == -1) {
                  curFitness = indivFitness;
                } else {
                  curFitness = fitnessFunction(population.get(idxArray[curIdx]), lambda[crowdIdx]);
                }
                if (curFitness > maxFitness) {
                  targetIdx = curIdx;
                  maxFitness = curFitness;
                }
              }
              if (idxArray[targetIdx] == -1) {
                nondominated_sorting_delete(indiv);
              } else {
                //indiv.getRank();
                int indivRank = (int) indiv.getAttribute(ranking.getAttributeIdentifier());

                //int targetRank = ((DoubleSolution) population.get(idxArray[targetIdx])).getRank();
                int targetRank = (int) population.get(idxArray[targetIdx]).getAttribute(ranking.getAttributeIdentifier());

                rankIdx[targetRank][idxArray[targetIdx]] = 0;
                rankIdx[indivRank][idxArray[targetIdx]] = 1;

                S targetSol = population.get(idxArray[targetIdx]);

                replace(idxArray[targetIdx], indiv);
                subregionIdx[crowdIdx][idxArray[targetIdx]] = 0;
                subregionIdx[location][idxArray[targetIdx]] = 1;

                // update the non-domination level structure
                nondominated_sorting_delete(targetSol);
              }
            }
            break;
        }
      }
    }
  }