Given the name of a dynamic field, and a dynamic part, return the
        name of the final dynamic field to use. It will then be used with
        get_field.
199584
def get_field_name_for(cls, field_name, dynamic_part):
        
        field = cls.get_field(field_name)
        return field.get_name_for(dynamic_part)
234376
protected void extractDynamicName(Tag tag, CharSequence name, OutParameter<String> dynamicName) {
		if (tag.hasDynamicName()) {
			final Pattern pattern = Pattern.compile(getDynamicNameExtractionPattern());
			final Matcher matcher = pattern.matcher(name);
			if (matcher.matches()) {
				dynamicName.set(Strings.nullToEmpty(matcher.group(1)));
				return;
			}
		}
		dynamicName.set(name.toString());
	}
1196129
def get_field(name)
      @fields ||= {}
      field = fields[name]
      raise Tripod::Errors::FieldNotPresent.new unless field
      field
    end
1084633
def get_field(self, name):
        """"""
        # We only make the wrappers here (lazily) to avoid creating a ton of objects needlessly.
        field = self._wrapped_fields.get(name)
        if field is None:
            is_fake = False
            field = self._get_internal_field_by_name(name)
            if field is None:
                # Might be a "fake" field in JSON
                is_fake = self._is_fake_field(name)
                if not is_fake:
                    raise AttributeError("No such field %s" % name)
            field = self._make_wrapped_field(name, field, is_fake=is_fake)
            self._wrapped_fields[name] = field
        return field
859237
def key_field_name(self):
        
        name = 'resource_id'
        if self.resource:
            key_field = getmeta(self.resource).key_field
            if key_field:
                name = key_field.attname
        return name
355371
def dynamic_fields
      fields = []
      variant_combinations.each do |field_variants|
        FIELD_TYPES.each do |type|
          fields << DynamicField.new(type, field_variants)
        end
      end
      fields
    end
628125
public String getFieldName() throws IOException {
    if (jsonParser.getCurrentToken() != JsonToken.FIELD_NAME) {
      throw new IOException("Expected a field of type " + JsonToken.FIELD_NAME +
                            ", but found a field of type " +
                            jsonParser.getCurrentToken());
    }
    return jsonParser.getCurrentName();
  }
852187
def _build_fields(self):
        
        declared_fields = self.solr._send_request('get', ADMIN_URL)
        result = decoder.decode(declared_fields)
        self.field_list = self._parse_fields(result, 'fields')

        # Build regular expressions to match dynamic fields.
        # dynamic field names may have exactly one wildcard, either at
        # the beginning or the end of the name
        self._dynamic_field_regexes = []
        for wc_pattern in self._parse_fields(result, 'dynamicFields'):
            if wc_pattern[0] == "*":
                self._dynamic_field_regexes.append(
                    re.compile(".*%s\Z" % wc_pattern[1:]))
            elif wc_pattern[-1] == "*":
                self._dynamic_field_regexes.append(
                    re.compile("\A%s.*" % wc_pattern[:-1]))
980548
private int getDynamicFieldSize(Object obj, Charset charset)
            throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        int size = 0;
        for (FieldMetaData field : dynamicFieldList) {
            size = size + field.getDynamicFieldByteSize(obj, charset);
        }
        return size;
    }
454994
def derive_field_name(self, field_name):
        
        cls = type(self)
        # We use ordinals to avoid thunk materialization.
        return cls(
            self[0],
            self[1],
            self[2],
            field_name,
            self[4],
            self[5]
        )
205000
def __get_value(self, field_name):
        
        value = request.values.get(field_name)
        if value is None:
            if self.json_form_data is None:
                value = None
            elif field_name in self.json_form_data:
                value = self.json_form_data[field_name]
        return value
1118881
def get_method_returning_field_value(self, field_name):
        
        method = getattr(self, field_name, None)
        return method if method and callable(method) else None
1222438
def get_field_model(name, model=None):
    
    if '.' in name:
        m, name = name.split('.')
        model = get_model(m)

    if model:
        return getattr(model, name, None), model
    else:
        return None, None
1367866
def get_name(component):
    
    if six.callable(component):
        name = getattr(component, "__qualname__", component.__name__)
        return '.'.join([component.__module__, name])
    return str(component)
1365706
public String getName() {
        return mBodyMap.containsKey(BoxItem.FIELD_NAME) ?
                (String) mBodyMap.get(BoxItem.FIELD_NAME) :
                null;
    }
241082
def __GetRequestField(self, method_description, body_type):
        """"""
        body_field_name = self.__BodyFieldName(body_type)
        if body_field_name in method_description.get('parameters', {}):
            body_field_name = self.__names.FieldName(
                '%s_resource' % body_field_name)
        # It's exceedingly unlikely that we'd get two name collisions, which
        # means it's bound to happen at some point.
        while body_field_name in method_description.get('parameters', {}):
            body_field_name = self.__names.FieldName(
                '%s_body' % body_field_name)
        return body_field_name
591119
String getterNameFor(Element field) {
        String methodNamePrefix = "get";
        if (field.asType().getKind() == TypeKind.BOOLEAN) {
            methodNamePrefix = "is";
        }
        return methodNamePrefix + NameUtils.capitalize(field.getSimpleName().toString());
    }