Check that the field has one of the specified values

        @param str field_name: Name of the field
        @param str values: The values we wish to query
        @param bool exact: Getting the exact query (ex. case sensitive)
963137
def where_in(self, field_name, values, exact=False):
        
        field_name = Query.escape_if_needed(field_name)
        self._add_operator_if_needed()
        self.negate_if_needed(field_name)

        token = _Token(field_name=field_name, value=self.add_query_parameter(list(Utils.unpack_iterable(values))),
                       token="in", exact=exact)
        token.write = self.rql_where_write(token)
        self._where_tokens.append(token)

        return self
906666
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case VOCAB:
      return isSetVocab();
    case LAYER_SIZE:
      return isSetLayerSize();
    case VECTORS:
      return isSetVectors();
    }
    throw new IllegalStateException();
  }
748548
def field_value(ast, field_name)
      field(ast, field_name).xpath('.//args_add_block//tstring_content
        [count(ancestor::args_add) = 1][count(ancestor::string_add) = 1]
        /@value').map { |a| a.to_s }.last
    end
915035
public static Query withStrings(String field, String[] values, boolean caseInsensitive) {
        if (caseInsensitive) {
            List<Query> regexList = new ArrayList<Query>();
            for (String value : values) {
                regexList.add(withString(field, value, true));
            }
            return Query.or(regexList);
        } else {
            return Query.withValues(field, Query.in, Literal.values(values));
        }
    }
875325
def get_values(self, field_name: str) -> List[object]:
        
        result = list()
        if self.validate_field(field_name):
            for value_key in self._kg.get(field_name):
                result.append(value_key["value"])
        return result
666927
def _check_values(self, value):
        
        key = self.to_field_name or 'pk'
        # deduplicate given values to avoid creating many querysets or
        # requiring the database backend deduplicate efficiently.
        try:
            value = frozenset(value)
        except TypeError:
            # list of lists isn't hashable, for example
            raise ValidationError(
                self.error_messages['list'],
                code='list',
            )
        for pk in value:
            try:
                self.queryset.filter(**{key: pk})
            except (ValueError, TypeError):
                raise ValidationError(
                    self.error_messages['invalid_pk_value'],
                    code='invalid_pk_value',
                    params={'pk': pk},
                )
        qs = EventOccurrence.objects.filter(**{'%s__in' % key: value})
        pks = set(force_text(getattr(o, key)) for o in qs)
        for val in value:
            if force_text(val) not in pks:
                raise ValidationError(
                    self.error_messages['invalid_choice'],
                    code='invalid_choice',
                    params={'value': val},
                )
        return qs
334556
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case IS_EMPTY:
      return isSetIs_empty();
    case BOOL_VAL:
      return isSetBool_val();
    case INT_VAL:
      return isSetInt_val();
    case LONG_VAL:
      return isSetLong_val();
    case FLOAT_VAL:
      return isSetFloat_val();
    case DOUBLE_VAL:
      return isSetDouble_val();
    case BINARY_VAL:
      return isSetBinary_val();
    case TYPE:
      return isSetType();
    }
    throw new IllegalStateException();
  }
1056845
def has_field(self, dotted_name):
        
        parts = dotted_name.split('.')
        cur_layer = self
        for part in parts:
            if part in cur_layer.field_names:
                cur_layer = cur_layer.get_field(part)
            else:
                return False
        return True
1304341
public void text(String str)
    {
        if (fieldNames.isEmpty() || fieldValues.isEmpty())
            return;
        
        String val = (String)fieldValues.pop();
        val += str;
        fieldValues.push(val);
    }
660384
public function isFieldValid(string $field_name) : bool
    {
        if (false === $this->validated) {
            $this->validate();
        }
        return (false === $this->getErrorByFieldName($field_name));
    }
510719
public static Query withMatchingString(String field, String value, boolean caseInsensitive) {
        return caseInsensitive ? regex(field, escapeRegExPattern(value), caseInsensitive, false, false, false) : withValue(field, eq, value);
    }
746302
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case SESSION_HANDLE:
      return isSetSessionHandle();
    case CATALOG_NAME:
      return isSetCatalogName();
    case SCHEMA_NAME:
      return isSetSchemaName();
    case TABLE_NAME:
      return isSetTableName();
    case COLUMN_NAME:
      return isSetColumnName();
    }
    throw new IllegalStateException();
  }
1307196
def set_field(self, name, value):
        
        if not any([isinstance(value, t) for t in {int, float, bool, str}]):
            LOGGER.debug('Invalid field value: %r', value)
            raise ValueError('Value must be a str, bool, integer, or float')
        self.fields[name] = value
267129
def VcardFieldsEqual(field1, field2):
    
    field1_vals = set([ str(f.value) for f in field1 ])
    field2_vals = set([ str(f.value) for f in field2 ])
    if field1_vals == field2_vals:
        return True
    else:
        return False
3173
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME:
      return is_set_name();
    case PARALLEL:
      return is_set_parallel();
    case TYPE:
      return is_set_type();
    case TASK_IDS:
      return is_set_taskIds();
    case ERRORS:
      return is_set_errors();
    }
    throw new IllegalStateException();
  }
1265267
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case START_ROW_OFFSET:
      return isSetStartRowOffset();
    case ROWS:
      return isSetRows();
    case COLUMNS:
      return isSetColumns();
    }
    throw new IllegalStateException();
  }
1246521
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case COL_VALS:
      return isSetColVals();
    }
    throw new IllegalStateException();
  }