Add a new feature to the bag.

        Parameters
        ----------
        feature : :obj:`Feature`
            feature to add
192689
def add(self, feature):
        
        self.features_.append(feature)
        self.num_features_ = len(self.features_)
1267596
def add_object(self, name, obj):
        
        if iskeyword(name):
            name = '_' + name
        setattr(self, name, APIObject(self, **obj))
        self._objects[name] = getattr(self, name)
682391
def add_row(self, obj):
        
        row = {}
        for column in self.headers:

            value = ''

            if '__col__' in column:
                if isinstance(column['__col__'], ColumnProperty):
                    value = self._get_column_cell_val(obj, column)

                elif isinstance(column['__col__'], RelationshipProperty):
                    value = self._get_relationship_cell_val(obj, column)

            row[column['name']] = value

        self._datas.append(self.format_row(row))
150204
def add_identifier(self, name, obj):
        

        name = str(name)
        self._known_identifiers[name] = obj
428597
def add_property(self, pred, obj):
        
        pred = Uri(pred)
        try:
            self[pred].append(obj)
        # except AttributeError:
        #     new_list = [self[pred]]
        #     new_list.append(obj)
        #     self[pred] = new_list
        except KeyError:
            try:
                new_prop = self.properties[pred]
            except AttributeError:
                self.properties = {}
                self.add_property(pred, obj)
                return
            except KeyError:
                try:
                    new_prop = MODULE.rdfclass.properties[pred]
                except KeyError:
                    new_prop = MODULE.rdfclass.make_property({},
                                                      pred, self.class_names)
                try:
                    self.properties[pred] = new_prop
                except AttributeError:
                    self.properties = {pred: new_prop}
            init_prop = new_prop(self, get_attr(self, "dataset"))
            setattr(self,
                    pred,
                    init_prop)
            self[pred] = init_prop
            self[pred].append(obj)
        if self.dataset:
            self.dataset.add_rmap_item(self, pred, obj)
184896
def add_content(obj, language, slot, content):
    
    placeholder = obj.placeholders.get(slot=slot)
    add_plugin(placeholder, TextPlugin, language, body=content)
968534
def add_opinion(self,opinion_obj):
        
        if self.opinion_layer is None:
            self.opinion_layer = Copinions()
            self.root.append(self.opinion_layer.get_node())
        self.opinion_layer.add_opinion(opinion_obj)
1232170
def add_concept(self, concept_obj):
        '''  '''
        if concept_obj is None:
            raise Exception("Concept object cannot be None")
        elif concept_obj in self.__concepts:
            raise Exception("Concept object is already inside")
        elif concept_obj.cidx in self.__concept_map:
            raise Exception("Duplicated concept ID ({})".format(concept_obj.cidx))
        self.__concepts.append(concept_obj)
        self.__concept_map[concept_obj.cidx] = concept_obj
        concept_obj.sent = self
        return concept_obj
26339
def add(self, name, obj=None):
        """"""
        if obj:
            text = '\n::\n\n' + indent(str(obj))
        else:
            text = views.view(name, self.dstore)
        if text:
            title = self.title[name]
            line = '-' * len(title)
            self.text += '\n'.join(['\n\n' + title, line, text])
929728
def add_object(o)
      if !@objects.include?(o)
        index = @objects.index do |object|
          object.z > o.z
        end
        if index
          @objects.insert(index, o)
        else
          @objects.push(o)
        end
        true
      else
        false
      end
    end
337481
def add_statement(self,statement_obj):
        
        if self.attribution_layer is None:
            self.attribution_layer = Cattribution()
            self.root.append(self.attribution_layer.get_node())
        self.attribution_layer.add_statement(statement_obj)
761221
public void addFeature(String feature) {
        if (feature == null) {
            throw new IllegalArgumentException("Invalid null argument passed for addFeature");
        }
        feature = feature.trim();
        if (!feature.isEmpty()) { 
            Feature newFeature = new Feature();
            newFeature.addText(feature);
            featureList.add(newFeature);
        }
    }
1012810
def add_object(self, obj):
        ''''''
        state = self.state
        if not obj.layer in state.layers:
            # its a new layer
            state.layers[obj.layer] = {}
        state.layers[obj.layer][obj.key] = obj
        state.need_redraw = True
1315060
def add(options = {})
      self.options = options

      raise(ArgumentError, 'Mandatory param :name missing') unless options[:name]

      if options[:feature]
        features << options
        SafetyCone::ViewHelpers.add_method(options[:feature])
      else
        paths[make_key] = options
      end
    end
1289562
@Override
	public boolean add(FeatureI feature) {
		if (mLocation == null) {
			mLocation = feature.location().plus();
		} else if (null != feature.location()) {
			mLocation = mLocation.union(feature.location().plus());
		}
		for (Entry<String, String> entry : feature.getAttributes().entrySet()){
			if (featindex.containsKey(entry.getKey())){
				Map<String,List<FeatureI>> feat = featindex.get(entry.getKey());
				if (feat==null){
					feat= new HashMap<String,List<FeatureI>>();
				}
				List<FeatureI> features = feat.get(entry.getValue());
				if (features==null){
					features = new ArrayList<FeatureI>();
				}
				features.add(feature);
				feat.put(entry.getValue(), features);
				featindex.put(entry.getKey(), feat);
				//featindex.put(key, value)
			}
		}

		return super.add(feature);
	}
468379
protected static void addFeature(String feature, FeatureMap featureMap, List<Integer> featureList)
    {
        int featureId = featureMap.idOf(feature);
        if (featureId != -1)
            featureList.add(featureId);
    }
900402
def register_features(with_features)
      Thread.new do
        features = []
        features = with_features.each do | feature |
          features.push(key: feature[:key],
                          variants: feature[:variants],
                          failoverVariant: feature[:failover_variant])
        end
        send_event 'Register Features', :put, '/api/sdk/v1/register', features
      end
    end