<pre>
{ $set : { field: l } }
</pre>
352793
public static Set set(String field, SetLiteral l) {
        return new Set().more(field, l);
    }
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();
  }
456249
public void set(String fieldName, Object value) throws IOException {
    getValueMarshaller(fieldName).setWritableObject(struct, value);
    LOG.debug("Set {}={}", fieldName, value);
  }
599625
function(set) {
            if (!set || !set.length) return;
            var i = 1,
                l = set.length,
                current,
                master = set[0],
                tmp;
            master = [
                master._x,
                master._y,
                master._x + master._w,
                master._y + master._h
            ];
            while (i < l) {
                current = set[i];
                tmp = [
                    current._x,
                    current._y,
                    current._x + current._w,
                    current._y + current._h
                ];
                if (tmp[0] < master[0]) master[0] = tmp[0];
                if (tmp[1] < master[1]) master[1] = tmp[1];
                if (tmp[2] > master[2]) master[2] = tmp[2];
                if (tmp[3] > master[3]) master[3] = tmp[3];
                i++;
            }
            tmp = master;
            master = {
                _x: tmp[0],
                _y: tmp[1],
                _w: tmp[2] - tmp[0],
                _h: tmp[3] - tmp[1]
            };

            return master;
        }
1055874
def _all(field, value, document):
    
    try:
        a = set(value)
    except TypeError:
        raise MalformedQueryException("'$all' must accept an iterable")

    try:
        b = set(document.get(field, []))
    except TypeError:
        return False
    else:
        return a.intersection(b) == a
296243
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case SPOUTS:
      return is_set_spouts();
    case BOLTS:
      return is_set_bolts();
    case STATE_SPOUTS:
      return is_set_state_spouts();
    }
    throw new IllegalStateException();
  }
1142256
@Override
	public Entity set(String field, Object value) {
		return (Entity) super.set(field, value);
	}
329448
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case SERIALIZED_PARTS:
      return is_set_serialized_parts();
    }
    throw new IllegalStateException();
  }
783950
public function hset($collection, $key, $field, $value) {

        $set = $this->getKey($collection, $key, []);

        $set[$field] = $value;
        $this->setKey($collection, $key, $set);
    }
1250035
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case HANDLE:
      return isSetHandle();
    }
    throw new IllegalStateException();
  }
723559
function (field) {
            var schemaDefinition = this.schema[field];
            if (!schemaDefinition) {
                throw "Couldn't find '" + field + "' in schema";
            }
            var collection = this.get(field);
            if (!collection) {
                var context = this.getContextForChild(schemaDefinition.type);
                if (context) {
                    collection = context.createCollection(schemaDefinition.type, null);
                    collection.$parent = this;
                    this.set(field, collection);
                } else {
                    throw "Couldn't determine context for " + field;
                }
            }
            return collection;


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

    switch (field) {
    case EXECUTION_COMMAND:
      return is_set_execution_command();
    case SCRIPT:
      return is_set_script();
    }
    throw new IllegalStateException();
  }
543755
function hmset(key /* field-1, value-1, field-N, value-N, req */) {
  var args = slice.call(arguments, 1)
    , req = typeof args[args.length - 1] === 'object'
        ? args.pop() : null
    , val = this.getKey(key, req)
    , i;

  if(!val) {
    val = new HashMap();
    this.setKey(key, val, undefined, undefined, undefined, req);
  }
  for(i = 0;i < args.length;i+=2) {
    val.setKey(args[i], args[i + 1]);
  }
  return OK;
}
809801
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case STATUS:
      return isSetStatus();
    case HAS_RESULT_SET:
      return isSetHasResultSet();
    case QUERY_DATA_SET:
      return isSetQueryDataSet();
    }
    throw new IllegalStateException();
  }
901014
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case NAME_TYPES:
      return isSetName_types();
    case VALUE_TYPES:
      return isSetValue_types();
    case DEFAULT_NAME_TYPE:
      return isSetDefault_name_type();
    case DEFAULT_VALUE_TYPE:
      return isSetDefault_value_type();
    }
    throw new IllegalStateException();
  }
881901
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case START_KEY:
      return isSetStart_key();
    case END_KEY:
      return isSetEnd_key();
    case START_TOKEN:
      return isSetStart_token();
    case END_TOKEN:
      return isSetEnd_token();
    case ROW_FILTER:
      return isSetRow_filter();
    case COUNT:
      return isSetCount();
    }
    throw new IllegalStateException();
  }
1201409
public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case EXPRESSIONS:
      return isSetExpressions();
    case START_KEY:
      return isSetStart_key();
    case COUNT:
      return isSetCount();
    }
    throw new IllegalStateException();
  }