Puts an objects into the data pipeline. The object may be transformed into a new type for insertion if necessary.

        Args:
            item: The object to be inserted into the data pipeline.
181605
def put(self, type: Type[T], item: T) -> None:
        
        LOGGER.info("Getting SinkHandlers for \"{type}\"".format(type=type.__name__))
        try:
            handlers = self._put_types[type]
        except KeyError:
            try:
                LOGGER.info("Building new SinkHandlers for \"{type}\"".format(type=type.__name__))
                handlers = self._put_handlers(type)
            except NoConversionError:
                handlers = None
            self._get_types[type] = handlers

        LOGGER.info("Creating new PipelineContext")
        context = self._new_context()

        LOGGER.info("Sending item \"{item}\" to SourceHandlers".format(item=item))
        if handlers is not None:
            for handler in handlers:
                handler.put(item, context)
538833
def insert(self, key, item):
        
        return lib.zhashx_insert(self._as_parameter_, key, item)
92028
def append(self, item):
        
        if not is_any(item):
            raise MemberTypeError(self, item, member=len(self))
        self._data.append(item)
388802
def append_item(self, item):
        """"""
        if not isinstance(item, LR0Item):
            raise TypeError
        self.itemlist.append(item)
1096545
def update(self, item):
        
        if item.matrix not in self.data:
            self.data[item.matrix] = []

        result = Select(self.data[item.matrix]).where(
            lambda entry: entry.stage == item.stage).build()

        if len(result) > 0:
            stage = result[0]
            stage.status = item.status
            stage.add(item.timestamp, item.information)
        else:
            stage = CollectorStage(stage=item.stage, status=item.status)
            stage.add(item.timestamp, item.information)
            self.data[item.matrix].append(stage)
78651
def append(self, item):
        
        self.real_list.append(item)
        self.observer(UpdateType.CREATED, item, len(self.real_list) - 1)
545224
def update(self, item):
        
        self.model.set(self._iter_for(item), 0, item)
1358437
def addItem( self, item ):
        
        result = super(XNodeScene, self).addItem(item)
        self.setModified()
        self._cache.add(item)
        
        return result
163197
public void addItem(T item) {
        mListItems.add(item);
        notifyItemInserted(mListItems.indexOf(item));
    }
448559
def insert(self, index, item):
        
        if not is_any(item):
            raise MemberTypeError(self, item, member=len(self))
        self._data.insert(index, item)
651397
def add(self, item):
        
        with self.lock:
            if item in self.set:
                return False
            self.set.add(item)
            return True
179069
def add(self, item):
        
        check_not_none(item, "item can't be none")
        return self._encode_invoke(transactional_list_add_codec, item=self._to_data(item))
320310
def put(self, item):
        '''
        
        '''
        if self.isfini:
            return False

        self.fifo.append(item)

        if len(self.fifo) == 1:
            self.event.set()

        return True
1109023
def __add_item(self, item, keys=None):
        
        if(not keys or not len(keys)):
            raise Exception('Error in %s.__add_item(%s, keys=tuple/list of items): need to specify a tuple/list containing at least one key!'
                            % (self.__class__.__name__, str(item)))
        direct_key = tuple(keys) # put all keys in a tuple, and use it as a key
        for key in keys:
            key_type = str(type(key))

            # store direct key as a value in an intermediate dictionary
            if(not key_type in self.__dict__):
                self.__setattr__(key_type, dict())
            self.__dict__[key_type][key] = direct_key

            # store the value in the actual dictionary
            if(not 'items_dict' in self.__dict__):
                self.items_dict = dict()
            self.items_dict[direct_key] = item
1048681
public void insert( Envelope itemEnv, Object item ) {
        if (itemEnv.isNull()) {
            return;
        }
        super.insert(itemEnv, item);
    }
400786
def addItem(self, item):
        """"""
        try:
            self.tree.addItem(item)
        except AttributeError, e:
            raise VersionError('Saved versions are immutable')
355823
def add_item(self, item):
        
        self.items.append(item)
        self.last_updated = datetime.datetime.now()