Returns the {@link FieldTypes} object for the given message field name.

@param fieldName name of the field to get the type for
@return field type object
192819
@Override
    public Optional<FieldTypes> get(final String fieldName) {
        return Optional.ofNullable(get(ImmutableSet.of(fieldName)).get(fieldName));
    }
188331
public int getFieldSeq(String fieldName)
    {
        for (int i = 0; i < this.getFieldCount(); i++)
        {
            if (fieldName.equals(this.getField(i).getFieldName()))
                return i;
        }
        return -1;
    }
28253
public ArrayList getFields(String fieldNames) throws NoSuchFieldException
    {
        ArrayList          result    = new ArrayList();
        FieldDescriptorDef fieldDef;
        String             name;

        for (CommaListIterator it = new CommaListIterator(fieldNames); it.hasNext();)
        {
            name = it.getNext();
            fieldDef = getField(name);
            if (fieldDef == null)
            {
                throw new NoSuchFieldException(name);
            }
            result.add(fieldDef);
        }
        return result;
    }
1343748
public <T> Optional<T> getFieldOptional(String fieldName, Class<T> clazz) {
        return DPathUtils.getValueOptional(fieldData, fieldName, clazz);
    }
1029784
public static Field getField(Class<?> type,String fieldName)
    {
        Field field=null;
        try
        {
            //get field
            field=type.getDeclaredField(fieldName);
        }
        catch(Exception exception)
        {
            throw new FaxException("Unable to extract field: "+fieldName+" from type: "+type,exception);
        }

        //set accessible
        field.setAccessible(true);

        return field;
    }
223103
public static Method getClassFieldReadMethod(Class<?> clazz, String fieldName) {
		return getClassReadMethods(clazz).get(fieldName);
	}
717083
public static Descriptors.FieldDescriptor getFieldDescriptor(final MessageOrBuilder builder, final int fieldNumber) {
        return builder.getDescriptorForType().findFieldByNumber(fieldNumber);
    }
552919
public DOField getFieldByName(String fieldName) {
		int idx = this.getIndexOfField(fieldName);
		if (idx != -1)
			return this.getFieldByIndex(idx);
		return null;
	}
1100907
public FieldType getField()
   {
      FieldType result = null;
      if (m_index < m_fields.length)
      {
         result = m_fields[m_index++];
      }

      return result;
   }
692333
public Field getField(String fieldName) {
		final PropDesc desc = this.propMap.get(fieldName);
		return null == desc ? null : desc.getField();
	}
326942
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public static int getType(Cursor cursor, String columnName) {
        if (cursor == null) {
            return Cursor.FIELD_TYPE_NULL;
        }

        return cursor.getType(cursor.getColumnIndex(columnName));
    }
483184
private function getField($fieldName)
    {
        if (array_key_exists($fieldName, $this->snsMessage)) {
            return $this->snsMessage[$fieldName];
        } else {
            return null;
        }
    }
1019127
protected String getMappedFieldName(String fieldName, @Nullable Class<?> domainType) {

		if (domainType == null || mappingContext == null) {
			return fieldName;
		}

		SolrPersistentEntity entity = mappingContext.getPersistentEntity(domainType);
		if (entity == null) {
			return fieldName;
		}

		SolrPersistentProperty property = entity.getPersistentProperty(fieldName);
		return property != null ? property.getFieldName() : fieldName;
	}
823773
@Nullable
  public static Descriptor getMapValueMessageType(FieldDescriptor mapField) {
    FieldDescriptor valueDesc = mapField.getMessageType().findFieldByName("value");
    if (valueDesc.getType() == FieldDescriptor.Type.MESSAGE) {
      return valueDesc.getMessageType();
    } else {
      return null;
    }
  }
823373
@Override public final String getHeaderField(String fieldName) {
    try {
      return fieldName == null
          ? StatusLine.get(getResponse().getResponse()).toString()
          : getHeaders().get(fieldName);
    } catch (IOException e) {
      return null;
    }
  }
1301075
public static final <T> Field getField(Class<T> cls, String fieldName) {
        try {
            Field f = cls.getDeclaredField(fieldName);
            f.setAccessible(true);
            return f;
        } catch (SecurityException e) {
            throw new RuntimeException(e);
        } catch (NoSuchFieldException e) {
            if (cls.getSuperclass() != null) {
                return getField(cls.getSuperclass(), fieldName);
            }
            throw new RuntimeException(e);
        }
    }
651783
public FieldType getFieldTypeByColumnName(String columnName) {
		if (fieldNameMap == null) {
			// build our alias map if we need it
			Map<String, FieldType> map = new HashMap<String, FieldType>();
			for (FieldType fieldType : fieldTypes) {
				map.put(databaseType.downCaseString(fieldType.getColumnName(), true), fieldType);
			}
			fieldNameMap = map;
		}
		FieldType fieldType = fieldNameMap.get(databaseType.downCaseString(columnName, true));
		// if column name is found, return it
		if (fieldType != null) {
			return fieldType;
		}
		// look to see if someone is using the field-name instead of column-name
		for (FieldType fieldType2 : fieldTypes) {
			if (fieldType2.getFieldName().equals(columnName)) {
				throw new IllegalArgumentException("You should use columnName '" + fieldType2.getColumnName()
						+ "' for table " + tableName + " instead of fieldName '" + fieldType2.getFieldName() + "'");
			}
		}
		throw new IllegalArgumentException("Unknown column name '" + columnName + "' in table " + tableName);
	}