Update component identifier
490258
def _fix_callback_item(self, item):
        ''
        item.component_id = self._fix_id(item.component_id)
        return item
540732
def _on_prop_changed(self, instance, meth_name, res, args, kwargs):
        """"""
        if  not self._itsme and meth_name == "__setitem__": self.update_widget(args[0])
        return
1256301
public synchronized void registerComponent(Class<?> _clazz, String _version) {
        componentVersions.put(_clazz.getName(), _version);
    }
647411
function updateStructure(targetObject, object) {
  for (const componentName in object) {
    if (object.hasOwnProperty(componentName)) {
      for (const styleName in object[componentName]) {
        if (object[componentName].hasOwnProperty(styleName)) {
          targetObject[componentName][styleName] = object[componentName][styleName]; // eslint-disable-line no-param-reassign
        }
      }
    }
  }
}
1078573
function (node, styles, component) {
	    if (false) {
	      ReactInstrumentation.debugTool.onHostOperation({
	        instanceID: component._debugID,
	        type: 'update styles',
	        payload: styles
	      });
	    }
	
	    var style = node.style;
	    for (var styleName in styles) {
	      if (!styles.hasOwnProperty(styleName)) {
	        continue;
	      }
	      if (false) {
	        warnValidStyle(styleName, styles[styleName], component);
	      }
	      var styleValue = dangerousStyleValue(styleName, styles[styleName], component);
	      if (styleName === 'float' || styleName === 'cssFloat') {
	        styleName = styleFloatAccessor;
	      }
	      if (styleValue) {
	        style[styleName] = styleValue;
	      } else {
	        var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];
	        if (expansion) {
	          // Shorthand property that IE8 won't like unsetting, so unset each
	          // component to placate it
	          for (var individualStyleName in expansion) {
	            style[individualStyleName] = '';
	          }
	        } else {
	          style[styleName] = '';
	        }
	      }
	    }
	  }
956645
public function updateChildId()
    {
        $allchild = $this->getChildComponents(true);
        foreach ($allchild as $component) {
            $_id = $component->id;
            $id = "_" . $this->number;
            $component->id .= $id;
            $attrid = $component->getAttribute("id");

            if ($attrid != null) {
                $component->setAttribute("id", $attrid . $id);
            }
            $attrid = $component->getAttribute("name");
            if ($attrid != null && $component instanceof RadioButton == false) {
                $component->setAttribute("name", $attrid . $id);
            }
            unset($component->owner->components[$_id]);
            $component->owner->components[$component->id] = $component;

            if ($component instanceof AbstractList) {
                $component->Refresh();
            }
        }
    }
173033
private void updateComponents() {
        updatingComponents = true;

        Font font = getFont();

        fontList.setSelectedValue(font.getName(), true);
        sizeList.setSelectedValue(font.getSize(), true);
        boldCheckBox.setSelected(font.isBold());
        italicCheckBox.setSelected(font.isItalic());

        if (previewText == null) {
            previewLabel.setText(font.getName());
        }

        // set the font and fire a property change
        Font oldValue = previewLabel.getFont();
        previewLabel.setFont(font);
        firePropertyChange("font", oldValue, font);

        updatingComponents = false;
    }
1204774
def updateFromInspectorRegItem(self, inspectorRegItem):
        
        library, name = inspectorRegItem.splitName()
        label = "{} ({})".format(name, library) if library else name
        #self.label.setText(label)
        self.menuButton.setText(label)
740019
public void updateAllComponents(final AbstractField<?> component) {

        allComponents.add(component);
        component.addValueChangeListener(new ChangeListener(component));
    }
613119
function generateId(_ComponentStyle: Function, _displayName: string, parentComponentId: string) {
  const displayName = typeof _displayName !== 'string' ? 'sc' : escape(_displayName);

  /**
   * This ensures uniqueness if two components happen to share
   * the same displayName.
   */
  const nr = (identifiers[displayName] || 0) + 1;
  identifiers[displayName] = nr;

  const componentId = `${displayName}-${_ComponentStyle.generateName(displayName + nr)}`;

  return parentComponentId ? `${parentComponentId}-${componentId}` : componentId;
}
811579
def editcomponent(self, data):
        
        data = data.copy()
        self._component_data_convert(data, update=True)
        return self._proxy.Component.update(data)
351075
private function update_component( ValueComponentInterface $component )
    {
        $component->value = $this->final_instance[$component->name];
        
        // Skip if this field is disabled
        if( $this->is_disabled($component) )
        {
            return;
        }

        // Apply user-defined filter
        $this->filter( $component );
        
        // Validate value
        $this->validate( $component );
    }
183901
public void refreshUserInfoDropDown() {

        Component oldVersion = m_userDropDown;
        m_userDropDown = createUserInfoDropDown();
        m_itemsRight.replaceComponent(oldVersion, m_userDropDown);
    }
480364
public void updateIcon(long identifier, ImageHolder image) {
        IDrawerItem drawerItem = getDrawerItem(identifier);
        if (drawerItem instanceof Iconable) {
            Iconable pdi = (Iconable) drawerItem;
            pdi.withIcon(image);
            updateItem((IDrawerItem) pdi);
        }
    }
288003
function _updateRenderedComponent(transaction, context) {
    // console.log('_updateRenderedComponent 123');
    var prevComponentInstance = this._renderedComponent;
    var prevRenderedElement = prevComponentInstance._currentElement;
    var nextRenderedElement = this._renderValidatedComponent();
    if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {

        console.log('if!!!', this);
        ReactReconciler.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context));
        // console.log(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context));
    } else {
        console.log('else!!!!');
        // var oldNativeNode = ReactReconciler.getNativeNode(prevComponentInstance);
        // ReactReconciler.unmountComponent(prevComponentInstance, false);

        // this._renderedNodeType = ReactNodeTypes.getType(nextRenderedElement);
        // this._renderedComponent = this._instantiateReactComponent(nextRenderedElement);
        // var nextMarkup = ReactReconciler.mountComponent(this._renderedComponent, transaction, this._nativeParent, this._nativeContainerInfo, this._processChildContext(context));
        // this._replaceNodeWithMarkup(oldNativeNode, nextMarkup);
    }
}
1184539
function updateVirtualComponent (vnode) {
  var vm = this;
  var componentId = vm.$options.componentId;
  if (vm._isMounted) {
    callHook(vm, 'beforeUpdate');
  }
  vm._vnode = vnode;
  if (vm._isMounted && componentId) {
    // TODO: data should be filtered and without bindings
    var data = Object.assign({}, vm._data);
    updateComponentData(componentId, data, function () {
      callHook(vm, 'updated');
    });
  }
}
458497
function updateComponentsJS(newFileName) {

  console.log(" 🔰  updating: ".cyan + "components.js".white);

  if (process.cwd().includes('client/app/components') === false) {
    process.chdir(`./client/app/components`);
  }

  componentsArray = [];
  genArr = [];


  // sync app.component with updates
  fs.readdir(process.cwd(), function (err, items) {
    genArr = items;
    generateDirectArray(genArr);
  });


  function generateDirectArray(items) {
    for (var i = 0; i < items.length; i++) {
      if (isDirectory(items[i])) {
      } else {
        componentsArray.push(items[i]);
      }
    }
    importStringGenerator();
  }

  function isDirectory(inputString) {
    var str = inputString;
    var patt = new RegExp("[.]");
    var res = patt.test(str);
    return res;
  }

  String.prototype.capitalizeFirstLetter = function () {
    return this.charAt(0).toUpperCase() + this.slice(1);
  }

  function importStringGenerator() {
    if (typeof newFileName != 'undefined') {
      componentsArray.push(`${newFileName}`);
    }

    genString = "";
    for (var i = 0; i < componentsArray.length; i++) {
      genString = genString + `    import ${componentsArray[i].capitalizeFirstLetter()}Module from './${componentsArray[i]}/${componentsArray[i]}.module';\r`
    }
    listString = "";
    for (var i = 0; i < componentsArray.length; i++) {

      // check if last in list in order to not include comma
      if (i === (componentsArray.length - 1)) {
        listString = listString + `     ${componentsArray[i].capitalizeFirstLetter()}Module` + `.name \r`
      } else {
        listString = listString + `     ${componentsArray[i].capitalizeFirstLetter()}Module` + '.name, \r'
      }

    }


    fs.writeFile("components.js", `import angular from 'angular';
${genString}

const ComponentsModule = angular.module('app.components',[
  ${listString}
]);

export default ComponentsModule;

  `, function (err) {
      if (err) {
        return console.log(` ❌  failed to update due to error:  ${err}`);
      }
      console.log(" 🔰  updated: ".cyan + "components.js".white);
    });
  }
}