Creates an OR NOT IN clause
@param mixed $item  Subject of comparison
@param array $list  A list of values
@param string $cond OR|AND
@param boolean $not
328636
public function orNotIn($item, array $list, $cond = 'or', $not = true)
    {
        return $this->in($item, $list, $cond, $not);
    }
924319
public function isCanRefill(Item $item, $field)
    {
        return in_array($field, $this->supported_fields) && $this->getSourceForFill($item);
    }
676561
public function isOwnedBy($item, $user = [])
    {
        if (!is_array($item)) {
            $item = $item->toArray();
        }

        if (empty($user)) {
            return false;
        }

        $itemUserId = $item[$this->config('column')];
        $userId = $user['id'];

        if ($itemUserId === $userId) {
            return true;
        }

        return false;
    }
420925
function is( $column, $value, $not = false ) {

        $bang = $not ? "!" : "";
        $or = $not ? " AND " : " OR ";
        $novalue = $not ? "1=1" : "0=1";
        $not = $not ? " NOT" : "";

        // always treat value as array
        if ( !is_array( $value ) ) {

            $value = array( $value );

        }

        // always quote column identifier
        $column = $this->quoteIdentifier( $column );

        if ( count( $value ) === 1 ) {

            // use single column comparison if count is 1

            $value = $value[ 0 ];

            if ( $value === null ) {

                return $column . " IS" . $not . " NULL";

            } else {

                return $column . " " . $bang . "= " . $this->quote( $value );
            }

        } else if ( count( $value ) > 1 ) {

            // if we have multiple values, use IN clause

            $values = array();
            $null = false;

            foreach ( $value as $v ) {

                if ( $v === null ) {

                    $null = true;

                } else {

                    $values[] = $this->quote( $v );

                }

            }

            $clauses = array();

            if ( !empty( $values ) ) {

                $clauses[] = $column . $not . " IN ( " . implode( ", ", $values ) . " )";

            }

            if ( $null ) {

                $clauses[] = $column . " IS" . $not . " NULL";

            }

            return implode( $or, $clauses );

        }

        return $novalue;

    }
1334229
public function whereNotIn(string $column, array $values, string $connector = self::LOGICAL_AND): self
    {
        if (!empty($values)) {
            $this->criteria($this->where, $column, $values, self::NOT_IN, $connector);
        }

        return $this;
    }
784327
private function makeArrayQueryIn(Builder $query, stdClass $rule, $operator, array $value, $condition)
    {
        if ($operator == 'NOT IN') {
            return $query->whereNotIn($rule->field, $value, $condition);
        }

        return $query->whereIn($rule->field, $value, $condition);
    }
130193
private boolean remove(List<String> list, String item) {
        if (null != list) {
            if (list.remove(item)) {
                this.num_items--;
                return true;
            }
        }
        return false;
    }
512780
public function orIn($item, array $list, $cond = 'or', $not = false)
    {
        return $this->in($item, $list, $cond, $not);
    }
869797
public static function exist(string $list, string $item, string $separator, string $tag = ''): bool
    {
        $items = self::explode($separator, $list);
        return in_array($tag . $item . $tag, $items);
    }
1075503
public static function notIn($field, $value, $dqlAlias = null)
    {
        return new Not(new In($field, $value, $dqlAlias));
    }
172856
public function or_where_in($field, array $values, $not=FALSE){
        if($this->where != ''){$this->where.='OR ';}
        $this->in($field, $values, $not);
    }
1193190
function _in_list(in_item, list, comparator){

	var retval = false;
	for(var li = 0; li < list.length; li++ ){
	    var list_item = list[li];

	    if( comparator ){
		var comp_op = comparator(in_item, list_item);
		if( comp_op && comp_op == true ){
		    retval = true;
		}
	    }else{
		if( in_item == list_item ){
		    retval = true;
		}
	    }
	}

	return retval;
    }
830863
public function whereNotIn($field, $condition, $logic = 'AND')
    {
        $this->parseWhereExp($logic, $field, 'not in', $condition);
        return $this;
    }
754981
protected function checkList($item)
	{
		$inList = in_array($item, $this->list);
		
		$allow = null;
		
		if ($this->mode == self::MODE_BLACKLIST) {
			$allow = ! $inList;
		} else {
			$allow = $inList;
		}
		
		return $allow;
	}
1243000
public static Node createInCondition(Variable var, Node cond) {
		checkNode(cond, MEMBER);
		// make sure the member is part of the variable
		Member member;
		switch (cond.getNodeType()) {

			case MEMBER:
				member = cond.cast();
				break;

			default:
				throw new FuzzerException(cond + ": unexpected IN condition");
		}
		if (!var.haveMember(member.getName())) {
			throw new FuzzerException(member.getName() + ": not a member of " + var.getName());
		}
		return new Condition(Node.Type.IN, var, cond);
	}
877812
protected function _createCombineExpression( $operator, array $list )
	{
		$results = array();
		$operators = $this->getOperators();

		foreach( $list as $entry )
		{
			$entry = (array) $entry;

			if( ( list( $op, $value ) = each( $entry ) ) === false ) {
				throw new MW_Common_Exception( sprintf( 'Invalid combine condition array "%1$s"', json_encode( $entry ) ) );
			}

			if( in_array( $op, $operators['combine'] ) ) {
				$results[] = $this->_createCombineExpression( $op, (array) $entry[$op] );
			}
			else if( in_array( $op, $operators['compare'] ) ) {
				$results[] = $this->_createCompareExpression( $op, (array) $entry[$op] );
			}
			else {
				throw new MW_Common_Exception( sprintf( 'Invalid operator "%1$s"', $op ) );
			}
		}

		return $this->combine( $operator, $results );
	}
644440
public function whereNotIn($column, array $values, $connector = self::LOGICAL_AND, $quote = null)
    {
        return $this->criteriaNotIn($this->where, $column, $values, $connector, $quote);
    }