adds an assignment clause to this statement
        :param clause: the clause to add
        :type clause: AssignmentClause
968841
def add_assignment_clause(self, clause):
        
        if not isinstance(clause, AssignmentClause):
            raise StatementException("only instances of AssignmentClause can be added to statements")
        clause.set_context_id(self.context_counter)
        self.context_counter += clause.get_context_size()
        self.assignments.append(clause)
540785
private void addClause(final Collection<Literal> literals) {
        for (final Literal lit : literals) {
            Integer index = this.name2idx.get(lit.variable().name());
            if (index == null) {
                index = this.name2idx.size() + 1;
                this.name2idx.put(lit.variable().name(), index);
                this.idx2name.put(index, lit.variable().name());
            }
            this.solver.addlit(lit.phase() ? index : -index);
        }
        this.solver.addlit(CLAUSE_TERMINATOR);
    }
957431
public function addClause(Clause $clause)
    {
        $classname = array_pop(explode('\\', get_class($clause)));
        $this->clauses[$classname] = $clause;

        return $this;
    }
601764
def add_conditional_clause(self, clause):
        
        clause.set_context_id(self.context_counter)
        self.context_counter += clause.get_context_size()
        self.conditionals.append(clause)
673772
public void addQuotation(final QuotationAlchemyEntity quotation) {
    if(quotation != null && !quotations.contains(quotation)) {
      quotations.add(quotation);
    }
  }
1292601
def build_where_clause(mappings, operator='AND'):
        
        where_clause_mappings = {}
        where_clause_mappings.update(mappings)

        where_clause = 'WHERE ' + ' {} '.format(operator).join(
            '{k} = {v}'.format(k=k, v='"{}"'.format(v) if isinstance(v, basestring) else v)
            for k, v in where_clause_mappings.iteritems()
        )
        return where_clause
733051
public SQLInsertClause insertOnDuplicateKeyUpdate(RelationalPath<?> entity, Expression<?> clause) {
        SQLInsertClause insert = insert(entity);
        insert.addFlag(Position.END, ExpressionUtils.template(String.class, " on duplicate key update {0}", clause));
        return insert;
    }
1071729
private void addTypedParameter(Type type, String parameter, FilterClause clause) {
        if (typedParameter == null) {
            typedParameter = new TypedParameter(type);
        }

        if (typedParameter.getType().equals(type)) {
            typedParameter.addParameters(parameter, clause);
        } else {
            logger.warn("Invalid type provided, it can either be name or indexes!");
        }
    }
886256
def add_clause(self, clause, no_return=True):
        

        if self.glucose:
            res = pysolvers.glucose3_add_cl(self.glucose, clause)

            if res == False:
                self.status = False

            if not no_return:
                return res
458462
def assign_candidate(self, verse: Verse, candidate: str) -> Verse:
        
        verse.scansion = candidate
        verse.valid = True
        verse.accented = self.formatter.merge_line_scansion(
            verse.original, verse.scansion)
        return verse
372926
public static <T> List<T> listFromClause(Class<T> clazz, String clause, Object... args)
    {
       return SqlClosure.sqlExecute(c -> OrmElf.listFromClause(c, clazz, clause, args));
    }
1069079
public function add($part, $clause = null)
    {
        if(!$clause) {
            throw new \InvalidArgumentException('Clause has to be specified to add.');
        }

        if(!$this->getStatement()->hasClause($clause)) {
            switch($clause) {
            case 'condition':
                $this->getStatement()->setClause($clause, new Expr\ConditionalClause());
                break;
            case 'order':
                $this->getStatement()->setClause($clause, new Expr\OrderClause());
                break;
            default:
                throw new \InvalidArgumentException(sprintf('Clasue "%s" is unknown type of Clause. Please init clause with setClause first.', $clause));
                break;
            }
        }
            
        $clause = $this->getStatement()->getClause($clause);
        $clause->add($part);
        return $this;
    }
1056948
def add(self, rule: 'functions.ReplacementRule') -> None:
        
        self.matcher.add(rule.pattern, rule.replacement)
1272912
public void setRule(String v) {
    if (Clause_Type.featOkTst && ((Clause_Type)jcasType).casFeat_rule == null)
      jcasType.jcas.throwFeatMissing("rule", "com.digitalpebble.rasp.Clause");
    jcasType.ll_cas.ll_setStringValue(addr, ((Clause_Type)jcasType).casFeatCode_rule, v);}
1080517
public void put(
    Conjunction selector,
    MatchTarget object,
    InternTable subExpr)
    throws MatchingException
  {

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.entry(this,cclass, "put", new Object[] { selector, object, subExpr });

    // The subscription should go into Matcher if there are no SimpleTests in the
    // Conjunction whose ordinal positions are greater in magnitude (lower in the tree)
    // than that of this DifficultMatcher.

    if (selector == null || noEligibleTests(selector))
    {
      Selector expr = (selector == null) ? null : selector.getResidual();
      MatchTargetTypeList mttl;

      if (expr == null)
      {
        mttl = alwaysMatch;
      }
      else
      {
        expr = expr.intern(subExpr);
        totalDifficultEntries = subExpr.size();

        int pos = roots.indexOf(expr);

        // If this expression hasn't been put in the tree previously,
        // then add it in.
        if (pos == -1)
        {
          MatchTargetTypeList tlist = new MatchTargetTypeList();
          mttl = tlist;
          //Add new type list with corresponding expression.
          objs.add(tlist);
          roots.add(expr);
        }
        else
        {
          // Type list for this expression.
          mttl = (MatchTargetTypeList) objs.get(pos);
        }
      }

      // Add element
      mttl.addTarget(object);
    }
    else
      // Continue through this DifficultMatcher onto the rest of the tree.
      super.put(selector, object, subExpr);

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      tc.exit(this,cclass, "put");

  }
1368997
def tag_clause_annotations(self):
        
        if not self.is_tagged(ANALYSIS):
            self.tag_analysis()
        if self.__clause_segmenter is None:
            self.__clause_segmenter = load_default_clausesegmenter()
        return self.__clause_segmenter.tag(self)
33044
@SafeVarargs
    public static <T, R> Function<T, Optional<R>> maybeFirstMatch(Clause<T, R>... clauses) {
        return new MaybeFirstMatchStrategy<>(Arrays.asList(clauses));
    }