Store information about a component. The component could be a
            worker or a commands or a class, or whatever you want, the
            only thing to be aware of is name collisions.
498384
def store_info(self, info_dict, component, type_tag):
        

        # Enforce dictionary input
        if not isinstance(info_dict, dict):
            print 'Critical: info_dict must be a python dictionary, got %s' % type(info_dict)
            return

        # Ensure values are not functions/methods/classes
        info_storage = {key:value for key, value in info_dict.iteritems() if not hasattr(value, '__call__')}

        # Place the type_tag on it and store it
        info_storage['type_tag'] = type_tag
        self._store_work_results(info_storage, 'info', component)
1133035
function collectComponent(component) {
    var name = component.constructor.name;
    (components[name] || (components[name] = [])).push(component);
  }
29048
public void setName(String name)
    {
        super.setName(name);
        for (int i = this.getComponentCount() - 1; i >= 0; i--)
        {
            JComponent component = (JComponent)this.getComponent(i);
            component.setName(name);
        }
    }
474938
function (oComponent) {
			var sComponentName = "";
			if (oComponent) {
				sComponentName = oComponent.getMetadata().getName();
			}
			if (sComponentName.length > 0 && sComponentName.indexOf(".Component") < 0) {
				sComponentName += ".Component";
			}
			return sComponentName;
		}
1106211
protected void gatherComponentInfo (ComponentRepository crepo)
    {
        // get the list of all component classes
        Iterators.addAll(_classes, crepo.enumerateComponentClasses());

        for (int ii = 0; ii < _classes.size(); ii++) {
            // get the list of components available for this class
            ComponentClass cclass = _classes.get(ii);
            Iterator<Integer> iter = crepo.enumerateComponentIds(cclass);

            while (iter.hasNext()) {
                Integer cid = iter.next();
                ArrayList<Integer> clist = _components.get(cclass);
                if (clist == null) {
                    _components.put(cclass, clist = Lists.newArrayList());
                }

                clist.add(cid);
            }
        }
    }
728026
def component(self, extra_params=None):
        
        if self.get('component_id', None):
            components = self.space.components(id=self['component_id'], extra_params=extra_params)
            if components:
                return components[0]
1048835
public function store()
    {
        // Check whether the object has ever been stored.
        if ($this->isNew) {
            Logger::get()->debug('Storing new entity ' . get_class($this) . '...');
            // Create the record. Get an ID back.
            $this->id = $this->getDataSource()->create($this->getFieldsData());
            // Store this object in the appropriate factory for further use.
            $this->getFactory()->registerEntity($this);
        } else {
            Logger::get()->debug('Updating entity ' . get_class($this) . ":{$this->id}...");
            $this->getDataSource()->update($this->id, $this->getFieldsData());
        }

        // Once stored, the entity is no longer new.
        $this->isNew = false;
    }
834978
protected void store(Object obj, Identity oid, ClassDescriptor cld,  boolean insert)
    {
        store(obj, oid, cld, insert, false);
    }
559926
function addComponent(Component, options) {
                var name = options.name,
                    container = options.container;

                if (name === undefined) {
                    throw 'you have to define data.name for component.';
                } else if (container === undefined) {
                    throw 'You have to define container for component.';
                } else if (this.children[name] !== undefined) {
                    throw 'Component using name:' + name + '! already defined.';
                }
                var component = this.setComponent(Component, options),
                    instance = component.run(options.container);
                instance.setContext(this.context);
                this.children[name] = instance;
                return instance;
            }
924057
private function storeCurrentItem() : void
    {
        $key = $this->iterator->key();

        if ($key === null) {
            return;
        }

        $this->items[$key] = $this->iterator->current();
    }
880164
def store(self, record, value):
        """"""
        record._values[self.name][record.id] = value
133798
function registerComponents(elemNames) {
    if (!elemNames) { return; }

    var elemNameDashCase, elemNameCamelCase;
    for (var i = 0; i < elemNames.length; i++) {
        elemNameDashCase = elemNames[i];
        elemNameCamelCase = utils.dashToCamelCase(elemNameDashCase);
        elems[elemNameCamelCase] = makeElem(elemNameDashCase);
    }
}
860834
def add_component(self, component):
        '''
        
        '''
        if component not in self._components:
            self._components.append(component)
        else:  # Replace Component
            self._components[self._components.index(component)] = component
200106
def _store_compound_info(self):
        
        other_name_l = [name for name in self.other_names if name != self.compound_info['name']]
        self.compound_info['other_names'] = ' <#> '.join(other_name_l)

        if not self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['pubchem_id'], 'cid', 0)

        if not self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['smiles'], 'smiles', 0)

        if not self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['name'], 'name', 0)

        if not self.compound_info['inchikey_id']:
            print('WARNING, cant get inchi key for ', self.compound_info)
            print(self.meta_info)
            print('#########################')
            self.compound_info['inchikey_id'] = 'UNKNOWN_' + str(uuid.uuid4())

        if not self.compound_info['pubchem_id'] and self.compound_info['inchikey_id']:
            self._set_inchi_pcc(self.compound_info['inchikey_id'], 'inchikey', 0)

        if not self.compound_info['name']:
            self.compound_info['name'] = 'unknown name'

        if not self.compound_info['inchikey_id'] in self.compound_ids:
            self.compound_info_all.append(tuple(self.compound_info.values()) + (
                str(datetime.datetime.now()),
                str(datetime.datetime.now()),
            ))
            self.compound_ids.append(self.compound_info['inchikey_id'])
691148
private void store() {
		Object parent = stack.peek();
		if (isObject(parent))
			o(parent).put((String) missingKey, current);
		else if (isArray(parent)) {
			int index = ((Number) missingKey).intValue();
			List<Object> lst = a(parent);
			while (lst.size() <= index)
				lst.add(null);
			lst.set(index, current);
		}
	}
135760
def _store_object(self, obj_name, content, etag=None, chunked=False,
            chunk_size=None, headers=None):
        
        head_etag = headers.pop("ETag", "")
        if chunked:
            headers.pop("Content-Length", "")
            headers["Transfer-Encoding"] = "chunked"
        elif etag is None and content is not None:
            etag = utils.get_checksum(content)
        if etag:
            headers["ETag"] = etag
        if not headers.get("Content-Type"):
            headers["Content-Type"] = None
        uri = "/%s/%s" % (self.uri_base, obj_name)
        resp, resp_body = self.api.method_put(uri, data=content,
                headers=headers)
1105445
def store_extra_info(self, key: str, value: Any) -> None:
        
        self.extra_keys[key] = value