Return the value from the field in the object that is defined by this FieldType.
960541
public <FV> FV extractRawJavaFieldValue(Object object) throws SQLException {
		Object val;
		if (fieldGetMethod == null) {
			try {
				// field object may not be a T yet
				val = field.get(object);
			} catch (Exception e) {
				throw SqlExceptionUtil.create("Could not get field value for " + this, e);
			}
		} else {
			try {
				val = fieldGetMethod.invoke(object);
			} catch (Exception e) {
				throw SqlExceptionUtil.create("Could not call " + fieldGetMethod + " for " + this, e);
			}
		}

		@SuppressWarnings("unchecked")
		FV converted = (FV) val;
		return converted;
	}
838387
public static Object getFieldValue(Object obj, Field field) throws UtilException {
		if (null == obj || null == field) {
			return null;
		}
		field.setAccessible(true);
		Object result = null;
		try {
			result = field.get(obj);
		} catch (IllegalAccessException e) {
			throw new UtilException(e, "IllegalAccess for {}.{}", obj.getClass(), field.getName());
		}
		return result;
	}
200021
function() {
	   var obj = {
	      value: this.subField.getValue(),
	      childValues: inputEx.TreeField.superclass.getValue.call(this)
	   };
	   return obj;
	}
966228
public static Object getValueOfField(Field field, Object ref) {
		field.setAccessible(true);
		Object value = null;
		try {
			value = field.get(ref);
		} catch (IllegalArgumentException e) {
			log.warning(e.getClass().getSimpleName() + ": " + e.getMessage());
		} catch (IllegalAccessException e) {
			log.warning(e.getClass().getSimpleName() + ": " + e.getMessage());
		}
		return value;
	}
634590
def _fields_to_object(descriptor, fields):
    ''
    # pylint: disable=protected-access
    obj = descriptor._concrete_class()

    for name, value in fields:
        if isinstance(value, tuple):
            subtype = descriptor.fields_by_name[name].message_type
            value = _fields_to_object(subtype, value)
        _assign_to_field(obj, name, value)

    return obj
115446
@SuppressWarnings("unchecked")
    public static <T> T getValue(Field field, Object self) {
        try {
            return (T) field.get(self);
        } catch (IllegalAccessException e) {
            throw ShedException.wrap(e, ShedErrorCode.UNABLE_TO_GET_FIELD)
                    .put("field", field.toGenericString());
        }
    }
592137
public static Object getValueOfField(Field field, Object ref) {
		field.setAccessible(true);
		Object value = null;
		try {
			value = field.get(ref);
		} catch (IllegalArgumentException e) {
		} catch (IllegalAccessException e) {
		}
		return value;
	}
1205668
def get_field_value(self, field, context):
        
        name = field.getName()
        value = context.getField(name).get(context)
        logger.info("get_field_value: context={} field={} value={}".format(
            context, name, value))
        return value
1246726
private static Field getDeclaredField(Object object, String fieldName) throws NoSuchFieldException {
        Assert.notNull(object);
        return getDeclaredField(object.getClass(), fieldName);
    }
642799
def get_field_type(info):
    """"""

    type_ = info.get_type()

    cls = get_field_class(type_)

    field = cls(info, type_, None)
    field.setup()
    return field.py_type
192269
def get_by(cls, field, value):
        '''  '''
        redis = cls.get_redis()
        key = cls.cls_key()+':index_'+field

        id = redis.hget(key, value)

        if id:
            return cls.get(debyte_string(id))

        return None
1178177
private Object getFieldValue(final Field field) {
        Object field_value = AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                try {
                    Object value = field.get(_member);

                    // Don't dump sensitive data
                    boolean sensitive = _member.getClass().isAnnotationPresent(Sensitive.class) || field.isAnnotationPresent(Sensitive.class);
                    if (value != null && sensitive) {
                        value = DataFormatHelper.sensitiveToString(value);
                    }

                    return value;
                } catch (IllegalAccessException e) {
                    // No FFDC code needed - we're in the middle of FFDC'ing!
                    // Should not happen - if it does return a string :-)
                    return "/* Could not access " + field.getName() + " */";
                }
            }
        });
        return field_value;
    }
205318
public static Object getFieldValue(Object obj, Field field) {
        Object value = null;
        boolean accessible = field.isAccessible();
        //hack accessibility
        if (!accessible) {
            field.setAccessible(true);
        }
        try {
            value = field.get(obj);
        } catch (IllegalAccessException e) {
            //ignore should not happen as accessibility has been updated to suit assignment
            e.printStackTrace(); // $COVERAGE-IGNORE$
        }
        //restore accessibility
        field.setAccessible(accessible);
        return value;
    }
125644
Object getValue(int fieldNum)
    {
        String attributeName = getAttributeName(fieldNum);
        ClassDescriptor cld = broker.getClassDescriptor(pc.getClass());
        
        // field could be a primitive typed attribute...
        AttributeDescriptorBase fld = cld.getFieldDescriptorByName(attributeName);
        // field could be a reference attribute...
        if (fld == null) 
        {
			fld = cld.getObjectReferenceDescriptorByName(attributeName);
		}
		// or it could be a collection attribute:
        if (fld == null) 
        {
			fld = cld.getCollectionDescriptorByName(attributeName);
		}        
        Object value = fld.getPersistentField().get(pc);
        return value;
    }
1168900
public Object extractFieldValue(final Object instance, final Field field) {
    JBBPUtils.assertNotNull(field, "Field must not be null");
    try {
      return ReflectUtils.makeAccessible(field).get(instance);
    } catch (Exception ex) {
      throw new JBBPException("Can't extract value from field for exception", ex);
    }
  }
1018910
def fetch(self):
        
        params = values.of({})

        payload = self._version.fetch(
            'GET',
            self._uri,
            params=params,
        )

        return FieldValueInstance(
            self._version,
            payload,
            assistant_sid=self._solution['assistant_sid'],
            field_type_sid=self._solution['field_type_sid'],
            sid=self._solution['sid'],
        )
681297
def value(self, x):
        
        return x if isinstance(x, FiniteField.Value) and x.field == self else FiniteField.Value(self, x)