This adds a new connective.
182727
@Override
    public void addNewConnective() {

        String factType = getExpressionLeftSide().getPreviousGenericType();
        if ( factType == null ) {
            factType = getExpressionLeftSide().getGenericType();
        }
        String fieldName = getExpressionLeftSide().getFieldName();
        String fieldType = getExpressionLeftSide().getGenericType();

        if ( this.getConnectives() == null ) {
            this.setConnectives( new ConnectiveConstraint[]{ new ConnectiveConstraint( factType,
                                                                                       fieldName,
                                                                                       fieldType ) } );
        } else {
            final ConnectiveConstraint[] newList = new ConnectiveConstraint[ this.getConnectives().length + 1 ];
            for ( int i = 0; i < this.getConnectives().length; i++ ) {
                newList[ i ] = this.getConnectives()[ i ];
            }
            newList[ this.getConnectives().length ] = new ConnectiveConstraint( factType,
                                                                                fieldName,
                                                                                fieldType );
            this.setConnectives( newList );
        }
    }
808300
def addRelation(self, link):
        '''
        
        '''
        if isinstance(link, Relation):
            self.internalLinks.append(link)
        else:
            raise TypeError(
                'link Type should be InternalLink, not %s' % type(link))
449211
def add(self, relation):
        
        r = Relation(relation)
        key = r.relation_key[0]
        if key not in self.relations:
            self.relations[key] = r
            self.relations[r.relation_key[1]]= r
1185415
def add_atom(self, key, atom):
        """"""
        self.graph.add_node(key, atom=atom)
160808
function add() {
    var modifier = new Modifier({
        size: [200, 80],
        align: [0, 0],
        origin: [0, 0],
        transform: Transform.translate(100, 210)
    });

    var layout = new ({
        direction: Utility.Direction.X
    });

    var item1 = new ImageSurface({
        size: [80, 80],
        content: './images/famous_logo.png'
    });

    var item2 = new Surface({
        size: [120, 80],
        content: 'Example',
        properties: {
            textAlign: 'center',
            lineHeight: '80px',
            backgroundColor: '#eaeaea'
        }
    });

    layout.sequenceFrom([item1, item2]);
    ctx.add(modifier).add(layout);
}
127868
def ExtendAnomalies(self, other):
    """"""
    for o in other:
      if o is not None:
        self.anomaly.Extend(list(o.anomaly))
148999
def add_tlink(self,my_tlink):
        
        if self.temporalRelations_layer is None:
            self.temporalRelations_layer = CtemporalRelations()
            self.root.append(self.temporalRelations_layer.get_node())
        self.temporalRelations_layer.add_tlink(my_tlink)
1208880
def add(self, effect):
        
        effect.instance = self.instance_index
        self.instance_index += 1

        self.connection.send(ProtocolParser.add(effect))
110811
public void addEdge(V from, V to) {
        addVertex(from);
        addVertex(to);
        neighbors.get(from).add(to);
    }
805178
def add_edge(self, p_from, p_to, p_id=None):
        
        if not self.has_edge(p_from, p_to):
            if not self.has_node(p_from):
                self.add_node(p_from)

            if not self.has_node(p_to):
                self.add_node(p_to)

            self._edges[p_from].add(p_to)
            self._edge_numbers[(p_from, p_to)] = p_id
86677
def _nested_add(nested_a, nested_b):
  """"""
  return nest.map(lambda a, b: a + b, nested_a, nested_b)
619822
def merge(self, other):
        
        Stats.merge(self, other)
        self.changes += other.changes
528388
def update(self, other, inplace=True):
        
        return self.append(other, inplace=inplace, resize=False)
46326
def add_line(self, line, source, *lineno):
        """"""
        self.result.append(line, source, *lineno)
681035
def add(self, *l):
        '''
        '''
        for a in flatten(l):
            self._add([self.Inner(a)], self.l)
871328
def _add_edge(self, s_a, s_b, **edge_labels):
        
        # Is that edge already in the graph ?
        # If at least one is new, then we are not redoing the same path again
        if (s_a, s_b) not in self.graph.edges():
            self.graph.add_edge(s_a, s_b, **edge_labels)
            self._new = True
            l.info("New edge: %s --> %s", s_a, s_b)
1100357
def new_graph(self, graph, typ):
        """"""
        graph = self.pack(graph)
        return self.sql('new_graph', graph, typ)