---------- oo-verbs
968413
public SVCPollCq poll(IbvWC[] wcList, int ne) throws IOException {
		return verbs.pollCQ(this, wcList, ne);
	}
226251
public static long getTimeout(MessagingService.Verb verb)
    {
        switch (verb)
        {
            case READ:
                return getReadRpcTimeout();
            case RANGE_SLICE:
                return getRangeRpcTimeout();
            case TRUNCATE:
                return getTruncateRpcTimeout();
            case READ_REPAIR:
            case MUTATION:
            case PAXOS_COMMIT:
            case PAXOS_PREPARE:
            case PAXOS_PROPOSE:
                return getWriteRpcTimeout();
            case COUNTER_MUTATION:
                return getCounterWriteRpcTimeout();
            default:
                return getRpcTimeout();
        }
    }
1109563
def verb_chain_ends(self):
        """"""
        if not self.is_tagged(VERB_CHAINS):
            self.tag_verb_chains()
        return self.ends(VERB_CHAINS)
1166891
function(verb) {
                        var matches = verb.value.match(/^VB[^P\s]+ (\S+)$/);
                        if (matches) {
                            var index = s.indexOf(matches[1]);

                            this._log('Use imperative present tense, eg. "Fix bug" not ' +
                            '"Fixed bug" or "Fixes bug". To get it right ask yourself: "If applied, ' +
                            'this patch will <YOUR-COMMIT-MESSAGE-HERE>"',
                            cfg.imperativeVerbsInSubject.type, [1, index+1+this._colOffset]);

                            hasError = true;
                            return false; // stop loop
                        }
                        return true;
                    }
213599
function (o) {
      var pattern, state;
      /** @type {string[]} */
      var stateArray;
      var i;
      //
      // 1. Collect all states
      //
      /** @type {Transitions} */
      var transitions = {};
      for (pattern in o) {
        for (state in o[pattern]) {
          stateArray = state.split("|");
          o[pattern][state].stateArray = stateArray;
          for (i=0; i<stateArray.length; i++) {
            transitions[stateArray[i]] = [];
          }
        }
      }
      //
      // 2. Fill states
      //
      for (pattern in o) {
        for (state in o[pattern]) {
          stateArray = o[pattern][state].stateArray || [];
          for (i=0; i<stateArray.length; i++) {
            //
            // 2a. Normalize actions into array:  'text=' ==> [{type_:'text='}]
            // (Note to myself: Resolving the function here would be problematic. It would need .bind (for *this*) and currying (for *option*).)
            //
            /** @type {any} */
            var p = o[pattern][state];
            if (p.action_) {
              p.action_ = [].concat(p.action_);
              for (var k=0; k<p.action_.length; k++) {
                if (typeof p.action_[k] === "string") {
                  p.action_[k] = { type_: p.action_[k] };
                }
              }
            } else {
              p.action_ = [];
            }
            //
            // 2.b Multi-insert
            //
            var patternArray = pattern.split("|");
            for (var j=0; j<patternArray.length; j++) {
              if (stateArray[i] === '*') {  // insert into all
                for (var t in transitions) {
                  transitions[t].push({ pattern: patternArray[j], task: p });
                }
              } else {
                transitions[stateArray[i]].push({ pattern: patternArray[j], task: p });
              }
            }
          }
        }
      }
      return transitions;
    }
1169884
function Words(superwords, classwords) {
	this.classwords = getwords(classwords, ['extend', 'mixin']);
	this.superwords = getwords(superwords, ['this._super']).map(function dot(
		word
	) {
		return word + '.';
	});
}
660387
function extend(o) {
  if (typeOf(o) !== 'object') { return {}; }
  var args = arguments;
  var len = args.length - 1;

  for (var i = 0; i < len; i++) {
    var obj = args[i + 1];

    if (typeOf(obj) === 'object' && typeOf(obj) !== 'regexp') {
      for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
          o[key] = obj[key];
        }
      }
    }
  }
  return o;
}
1293257
function AndOrPredicate(op, preds) {
      this.op = this._resolveOp(op);
      if (preds.length == 1 && Array.isArray(preds[0])) {
        preds = preds[0];
      }
      this.preds = preds.filter(function (pred) {
        return pred != null;
      }).map(function (pred) {
        return Predicate(pred);
      });
      if (this.preds.length == 0) {
        // marker for an empty predicate
        this.op = null;
      }
      if (this.preds.length == 1) {
        return this.preds[0];
      }
    }
1245722
private boolean isThereReflexivePronoun(
      final AnalyzedTokenReadings[] tokens, int i) {
    Pattern pPronomBuscat = null;
    // 1) es queixa, se li queixa, se li'n queixa
    if (matchPostagRegexp(tokens[i], VERB_INDSUBJ)) {
      pPronomBuscat = pronomPattern(tokens[i]);
      if (pPronomBuscat != null) {
        int j = 1;
        boolean keepCounting = true;
        while (i - j > 0 && j < 4 && keepCounting) {
          if (matchPostagRegexp(tokens[i - j], pPronomBuscat)
              && matchRegexp(tokens[i -j].getToken(), REFLEXIU_ANTEPOSAT))
            return true;
          keepCounting = matchPostagRegexp(tokens[i - j],
              PRONOM_FEBLE);
          j++;
        }
      }
    }
    // 2) queixa't, queixeu-vos-hi
    if (matchPostagRegexp(tokens[i], VERB_IMP)) {
      pPronomBuscat = pronomPattern(tokens[i]);
      if (pPronomBuscat != null) {
        if (i+1<tokens.length
            && matchPostagRegexp(tokens[i + 1], pPronomBuscat)
            && matchRegexp(tokens[i + 1].getToken(), REFLEXIU_POSPOSAT))
          return true; 
      }
    }
    // 3) s'ha queixat, se li ha queixat, se li n'ha queixat.
    if (matchPostagRegexp(tokens[i], VERB_PARTICIPI)) {
      if (tokens[i - 1].hasLemma("haver")) {
        if (matchPostagRegexp(tokens[i - 1], VERB_INDSUBJ)) {
          pPronomBuscat = pronomPattern(tokens[i - 1]);
          if (pPronomBuscat != null) {
            int j = 2;
            boolean keepCounting = true;
            while (i - j > 0 && j < 5 && keepCounting) {
              if (matchPostagRegexp(tokens[i - j], pPronomBuscat)
                  && matchRegexp(tokens[i - j].getToken(), REFLEXIU_ANTEPOSAT))
                return true;
              keepCounting = matchPostagRegexp(tokens[i - j], PRONOM_FEBLE);
              j++;
            }
          }
        }
        // es podria haver endut
        else if (matchPostagRegexp(tokens[i - 1], VERB_INF)
            && matchPostagRegexp(tokens[i - 2], VERB_INDSUBJ)) {
          pPronomBuscat = pronomPattern(tokens[i - 2]);
          if (pPronomBuscat != null) {
            int j = 3;
            boolean keepCounting = true;
            while (i - j > 0 && j < 5 && keepCounting) {
              if (matchPostagRegexp(tokens[i - j], pPronomBuscat)
                  && matchRegexp(tokens[i - j].getToken(), REFLEXIU_ANTEPOSAT))
                return true;
              keepCounting = matchPostagRegexp(tokens[i - j], PRONOM_FEBLE);
              j++;
            }
          }
        }
      }
      // *havent queixat, *haver queixat
//      else if (!(matchLemmaRegexp(tokens[i - 1], VERB_HAVER) && matchPostagRegexp(
//          tokens[i - 1], VERB_INFGER)))
//        return true;
    }
    // 4) em vaig queixar, se li va queixar, se li'n va queixar, vas
    // queixar-te'n,
    // em puc queixar, ens en podem queixar, podeu queixar-vos,
    // es va queixant, va queixant-se, comences queixant-te
    // 5) no t'has de queixar, no has de queixar-te, pareu de queixar-vos,
    // comenceu a queixar-vos
    // corre a queixar-se, corre a queixar-te, vés a queixar-te
    // no hauria pogut burlar-me
    // 6) no podeu deixar de queixar-vos, no us podeu deixar de queixar
    // en teniu prou amb queixar-vos, comenceu lentament a queixar-vos
    // 7) no es va poder emportar, va decidir suïcidar-se,
    // 8) Queixar-se, queixant-vos, podent abstenir-se
    if (matchPostagRegexp(tokens[i], VERB_INFGER)) {
      int k = 1;
      boolean keepCounting = true;
      boolean foundVerb = false;
      while (i - k > 0 && keepCounting && !foundVerb) {
        foundVerb = matchPostagRegexp(tokens[i - k], VERB_INDSUBJIMP);
        keepCounting = matchPostagRegexp(tokens[i - k],
            PREP_VERB_PRONOM);
        if (matchPostagRegexp(tokens[i-k],VERB_INDSUBJ)
            && matchPostagRegexp(tokens[i-k+1],VERB_INFGER))
          keepCounting=false;
        if (matchPostagRegexp(tokens[i - k], VERB_INFGER) //pertanyen a grups verbals diferents
            && matchPostagRegexp(tokens[i - k + 1], PRONOM_FEBLE)
            && !matchRegexp(tokens[i - k + 1].getToken(), PRONOMFEBLE_POSPOSAT)) {
          keepCounting=false;
        }
        k++;
      }
      if (foundVerb) {
        k--;
        pPronomBuscat = pronomPattern(tokens[i - k]);
        if (pPronomBuscat != null) {
          if (i+1< tokens.length
              && matchPostagRegexp(tokens[i + 1], pPronomBuscat)
              && matchRegexp(tokens[i + 1].getToken(), REFLEXIU_POSPOSAT))
            return true;
          int j = 1;
          keepCounting = true;
          while (i - j > 0 && keepCounting) {
            if (j==1 && matchPostagRegexp(tokens[i - j], pPronomBuscat))
              return true;
            if (j>1 && matchPostagRegexp(tokens[i - j], pPronomBuscat)
                && !(matchRegexp(tokens[i - j].getToken(), REFLEXIU_POSPOSAT) && j>k))
              return true;
            keepCounting = matchPostagRegexp(tokens[i - j], PREP_VERB_PRONOM)
                && !(j>k-1 && matchPostagRegexp(tokens[i - j], VERB_PARTICIPI))
                && !matchPostagRegexp(tokens[i - j], TRENCA_COMPTE2);
            if (tokens[i-j].getToken().equalsIgnoreCase("per")
                && tokens[i-j+1].getToken().equalsIgnoreCase("a")) {
              keepCounting=false;
            }
            if (matchPostagRegexp(tokens[i - j], VERB_INFGER) //pertanyen a grups verbals diferents
                && matchPostagRegexp(tokens[i - j + 1], PRONOM_FEBLE)
                && !matchRegexp(tokens[i - j + 1].getToken(), PRONOMFEBLE_POSPOSAT)) {
              keepCounting=false;
            }
            j++;
          }
        }
      } else {
        if (i+1<tokens.length
            && matchPostagRegexp(tokens[i + 1], PRONOM_REFLEXIU)
            && matchRegexp(tokens[i + 1].getToken(), REFLEXIU_POSPOSAT))
          return true;
        int j = 1;
        keepCounting = true;
        while (i - j > 0 && keepCounting) {
          if (matchPostagRegexp(tokens[i - j], PRONOM_REFLEXIU))
            return true;
          keepCounting = matchPostagRegexp(tokens[i - j],
              PREP_VERB_PRONOM);
          if (tokens[i-j].getToken().equalsIgnoreCase("per")
              && tokens[i-j+1].getToken().equalsIgnoreCase("a")) {
            keepCounting=false;
          }
          if (matchPostagRegexp(tokens[i - j], VERB_INFGER) //pertanyen a grups verbals diferents
              && matchPostagRegexp(tokens[i - j + 1], PRONOM_FEBLE)
              && !matchRegexp(tokens[i - j + 1].getToken(), PRONOMFEBLE_POSPOSAT)) {
            keepCounting=false;
          }
          j++;
        }
      }
    }
    return false;
  }
1118572
def likes
      verbs_of_interest = %w[like unlike]

      query = Activity.joins(:verb)
                      .with_actor_id(id: guid)
                      .with_target_id(id: nil)
                      .merge(Verb.with_display_name(name: verbs_of_interest))

      @likes ||= query.group(:activity_object_id).having("COUNT(1) % 2 == 1")
    end
907713
public SVCPostSend postSend(List<IbvSendWR> wrList, List<IbvSendWR> badwrList) throws IOException {
		return verbs.postSend(this, wrList, badwrList);
	}
983186
public void setIsModal(boolean v) {
    if (Verb_Type.featOkTst && ((Verb_Type)jcasType).casFeat_isModal == null)
      jcasType.jcas.throwFeatMissing("isModal", "ch.epfl.bbp.uima.types.Verb");
    jcasType.ll_cas.ll_setBooleanValue(addr, ((Verb_Type)jcasType).casFeatCode_isModal, v);}
223988
def find_lemma(self, verb):
        
        v = verb.lower()
        # Common prefixes: be-finden and emp-finden probably inflect like finden.
        if not (v.startswith("ge") and v.endswith("t")): # Probably gerund.
            for prefix in prefixes:
                if v.startswith(prefix) and v[len(prefix):] in self.inflections:
                    return prefix + self.inflections[v[len(prefix):]]
        # Common sufixes: setze nieder => niedersetzen.
        b, suffix = " " in v and v.split()[:2] or  (v, "")
        # Infinitive -ln: trommeln.
        if b.endswith(("ln", "rn")):
            return b
        # Lemmatize regular inflections.
        for x in ("test", "est", "end", "ten", "tet", "en", "et", "te", "st", "e", "t"):
            if b.endswith(x): b = b[:-len(x)]; break
        # Subjunctive: hielte => halten, schnitte => schneiden.
        for x, y in (
          ("ieb",  "eib"), ( "ied", "eid"), ( "ief",  "auf" ), ( "ieg", "eig" ), ("iel", "alt"), 
          ("ien",  "ein"), ("iess", "ass"), (u"ieß", u"aß"  ), ( "iff", "eif" ), ("iss", "eiss"), 
          (u"iß", u"eiß"), (  "it", "eid"), ( "oss",  "iess"), (u"öss", "iess")):
            if b.endswith(x): b = b[:-len(x)] + y; break
        b = b.replace("eeiss", "eiss")
        b = b.replace("eeid", "eit")
        # Subjunctive: wechselte => wechseln
        if not b.endswith(("e", "l")) and not (b.endswith("er") and len(b) >= 3 and not b[-3] in VOWELS):
            b = b + "e"
        # abknallst != abknalln => abknallen
        if b.endswith(("hl", "ll", "ul", "eil")):
            b = b + "e"
        # Strip ge- from (likely) gerund:
        if b.startswith("ge") and v.endswith("t"):
            b = b[2:]
        # Corrections (these add about 1.5% accuracy):
        if b.endswith(("lnde", "rnde")):
            b = b[:-3]
        if b.endswith(("ae", "al", u"öe", u"üe")):
            b = b.rstrip("e") + "te"
        if b.endswith(u"äl"):
            b = b + "e"
        return suffix + b + "n"
1001685
function(rules) {
      return _.some(rules, function(rule) {
        return _.some(rule.resources, function(resource) {
          return checkResource(resource) && !_.isEmpty(_.intersection(rule.verbs ,(["*", "create", "update"])));
        });
      });
    }
1193055
function generateOperationParameters(isInstance, verb) {
    var parameters = [];
    if (isInstance) {
        addOperationSingularParameters(verb, parameters);
    } else {
        addOperationCollectionParameters(verb, parameters);
    }
    return parameters;
}
545774
public function fromString($verb) {
      $verb_class = "Catapult\\BaMLVerb" . $verb;
      if (!(in_array($verb, self::$valid)))
        Throw new \CatapultApiException($verb . " is not a valid verb in baML v" . BAML_SETTINGS::BAML_VERSION);
      return new $verb_class;
    }
594338
public ApiResponse postGroupActivity(String groupId, String verb, String title,
            String content, String category, User user, Entity object,
            String objectType, String objectName, String objectContent) {
        Activity activity = Activity.newActivity(verb, title, content,
                category, user, object, objectType, objectName, objectContent);
        return postGroupActivity(groupId, activity);
    }