Add a new slot to the multi-frame containing the string.
        :param string: a string to insert
        :return: None
167344
def add(self, string: (str, list)):
        
        slot = _SlotFrame(self,
                          remove_callback=self._redraw,
                          entries=self._slot_columns)
        slot.add(string)

        self._slots.append(slot)

        self._redraw()
662900
public static String add( String str, String str2 ) {
        return FastStringUtils.noCopyStringFromChars(
                Chr.add(
                 FastStringUtils.toCharArray(str),
                 FastStringUtils.toCharArray(str2) )
        );
    }
1095727
def add_net32string(self, string):
		
		if len(string) >= (1 << 32):
			raise ValueError("string too long")
		return self.add_net32int(len(string)).add(string)
1096928
def add_str(self,oid,value,label=None):
		""""""
		self.add_oid_entry(oid,'STRING',value,label=label)
170347
def indent_string(string, *args)
      string = string.dup
      indent_string!(string, *args)
      string
    end
939396
def insert(self, context):
	
		
		
		self.write([
			"box",
			"add",
			"--name", context.resolve(self.__name),
			self.__path(context)
		])
1184166
def add_slot(name, value)
      slot = Slot.new(name, value)
      @slots[:name] = slot
      slot
    end
861857
def write(self, *string):
        
        self._output.write(' '.join([six.text_type(s) for s in string]))
        return self
774790
def add_symbol(self, name, string=None):
        
        if not string: string = name
        self.symbols[name] = sympy.Symbol(string)
1178927
def InsertArg(self, string="", **_):
    """"""
    if self.state == "LIST_ARG":
      self.list_args.append(string)
    elif self.current_expression.AddArg(string):
      # This expression is complete
      self.stack.append(self.current_expression)
      self.current_expression = self.expression_cls()
      # We go to the BINARY state, to find if there's an AND or OR operator
      return "BINARY"
551672
def add_from_string(self, buffer, length=-1):
        

        return Gtk.Builder.add_from_string(self, buffer, length)
803507
def add_string_widget(self, ref, text="Text", x=1, y=1):
        

        if ref not in self.widgets:
            widget = widgets.StringWidget(screen=self, ref=ref, text=text, x=x, y=y)
            self.widgets[ref] = widget
            return self.widgets[ref]
1245455
private void addStringInternal(String str)
    {
        String prefixString = determineLongestPrefixInMDAG(str);
        String suffixString = str.substring(prefixString.length());

        //Retrive the data related to the first confluence node (a node with two or more incoming transitions)
        //in the _transition path from sourceNode corresponding to prefixString.
        HashMap<String, Object> firstConfluenceNodeDataHashMap = getTransitionPathFirstConfluenceNodeData(sourceNode, prefixString);
        MDAGNode firstConfluenceNodeInPrefix = (MDAGNode) firstConfluenceNodeDataHashMap.get("confluenceNode");
        Integer toFirstConfluenceNodeTransitionCharIndex = (Integer) firstConfluenceNodeDataHashMap.get("toConfluenceNodeTransitionCharIndex");
        /////

        //Remove the register entries of all the nodes in the prefixString _transition path up to the first confluence node
        //(those past the confluence node will not need to be removed since they will be cloned and unaffected by the 
        //addition of suffixString). If there is no confluence node in prefixString, then remove the register entries in prefixString's entire _transition path
        removeTransitionPathRegisterEntries((toFirstConfluenceNodeTransitionCharIndex == null ? prefixString : prefixString.substring(0, toFirstConfluenceNodeTransitionCharIndex)));

        //If there is a confluence node in the prefix, we must duplicate the _transition path
        //of the prefix starting from that node, before we add suffixString (to the duplicate path).
        //This ensures that we do not disturb the other _transition paths containing this node.
        if (firstConfluenceNodeInPrefix != null)
        {
            String transitionStringOfPathToFirstConfluenceNode = prefixString.substring(0, toFirstConfluenceNodeTransitionCharIndex + 1);
            String transitionStringOfToBeDuplicatedPath = prefixString.substring(toFirstConfluenceNodeTransitionCharIndex + 1);
            cloneTransitionPath(firstConfluenceNodeInPrefix, transitionStringOfPathToFirstConfluenceNode, transitionStringOfToBeDuplicatedPath);
        }
        /////

        //Add the _transition based on suffixString to the end of the (possibly duplicated) _transition path corresponding to prefixString
        addTransitionPath(sourceNode.transition(prefixString), suffixString);
    }
1227427
void tos_into_slot( int idx, String id ) {
    subRef(_ary[idx], _key[idx]);
    subRef(_fcn[idx]);
    Frame fr =                   _ary[_sp-1];
    _ary[idx] = fr==null ? null : addRef(new Frame(fr));
    _d  [idx] =                  _d  [_sp-1] ;
    _fcn[idx] =           addRef(_fcn[_sp-1]);
    _str[idx] =                  _str[_sp-1] ;
    _key[idx] = fr!=null ? id : null;
    assert _ary[0]== null || check_refcnt(_ary[0].anyVec());
  }
1046411
public StringGrabber insertIntoHead(String str) {

		if (str != null) {
			try {
				sb.insert(0, str);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		return StringGrabber.this;
	}
1262951
def add(self, type, orig, replace):
        
        ret = libxml2mod.xmlACatalogAdd(self._o, type, orig, replace)
        return ret
686235
def insert_in_next_line(tokens, index, string):
    
    tokenized_string = token_utils.listified_tokenizer(string)
    for i, tok in list(enumerate(tokens[index:])):
        token_type = tok[0]
        if token_type in [tokenize.NL, tokenize.NEWLINE]:
            for count, item in enumerate(tokenized_string):
                tokens.insert(index+count+i+1, item)
            break