value: CONFIDENTIAL, INTEGRAL or REST. In case of REST, returns unchecked methods.
974495
public ActionString getUserDataString(String value) {
        if (value == null) {
            return null;
        }
        ActionString output = null;
        if (mapAllMethods != null) {
            // handle all methods case.
            output = getUserDataStringFromAllMap(mapAllMethods, value);
        } else {
            output = getUserDataStringFromMethodsMap(value);
        }
        if (tc.isDebugEnabled())
            Tr.debug(tc, "getUserDataString output: " + output);
        return output;
    }
797330
def getmethattr(obj, meth):
  
  if hasmethod(obj, meth):
    return getattr(obj, meth)()
  elif hasvar(obj, meth):
    return getattr(obj, meth)
  return None
982804
def select(self, pyliste):
        """"""
        if self.isClosed or self.isEncrypted:
            raise ValueError("operation illegal for closed / encrypted doc")

        val = _fitz.Document_select(self, pyliste)

        self._reset_page_refs()
        self.initData()

        return val
513368
function unbox(value){
  if (value instanceof ResType) return when(value, unbox)
  if (value && typeof value == 'object') return unboxAll(value)
  return value
}
65035
def _get_value(self):
        """"""

        # This is going to be true (possibly) only for derived classes. It is here to make the code cleaner
        # and also to avoid infinite recursion

        if self._aux_variable:

            return self._aux_variable['law'](self._aux_variable['variable'].value)

        if self._transformation is None:

            return self._internal_value

        else:

            # A transformation is set. Transform back from internal value to true value
            #
            # print("Interval value is %s" % self._internal_value)
            # print("Returning %s" % self._transformation.backward(self._internal_value))

            return self._transformation.backward(self._internal_value)
720778
private static int getBugPriority(String methodName, MethodInfo mi) {
		if (Values.STATIC_INITIALIZER.equals(methodName)) {
			return LOW_PRIORITY;
		}

		if ((mi.getNumBytes() >= highByteCountLimit) || (mi.getNumMethodCalls() >= highMethodCallLimit)) {
			return HIGH_PRIORITY;
		}

		if ((mi.getNumBytes() >= normalByteCountLimit) || (mi.getNumMethodCalls() >= normalMethodCallLimit)) {
			return NORMAL_PRIORITY;
		}

		if ((mi.getNumBytes() >= lowByteCountLimit) || (mi.getNumMethodCalls() >= lowMethodCallLimit)) {
			return LOW_PRIORITY;
		}

		return EXP_PRIORITY;
	}
1195033
def needs_values(func):
    """"""

    @wraps(func)
    def assure_data_present(self, *args, **kwargs):
        self.read()
        return func(self, *args, **kwargs)
    # END wrapper method
    return assure_data_present
1180545
def unlocked(func_or_obj):
    
    if ismethod(func_or_obj) or isfunction(func_or_obj):
        return _unlocked_method(func_or_obj)
    else:
        return _UnlockedAttribute(func_or_obj)
1315143
def get_input(*args, secret=False, required=False, blank=False, **kwargs):
    

    while True:
        if secret:
            value = getpass.getpass(*args, **kwargs)
        else:
            value = input(*args, **kwargs)

        if blank:
            value = value if value else None

        if not required or value:
            break

    return value
69752
@Nullable
    public T getValue() {
        Object data = mData;
        if (data != NOT_SET) {
            //noinspection unchecked
            return (T) data;
        }
        return null;
    }
1317239
static Method[] getMethodList(Class<?> clazz) {
        Method[] methods = null;
        try {
            // getDeclaredMethods may be rejected by the security manager
            // but getMethods is more expensive
            if (!sawSecurityException)
                methods = clazz.getDeclaredMethods();
        } catch (SecurityException e) {
            // If we get an exception once, give up on getDeclaredMethods
            sawSecurityException = true;
        }
        if (methods == null) {
            methods = clazz.getMethods();
        }
        int count = 0;
        for (int i=0; i < methods.length; i++) {
            if (sawSecurityException
                ? methods[i].getDeclaringClass() != clazz
                : !Modifier.isPublic(methods[i].getModifiers()))
            {
                methods[i] = null;
            } else {
                count++;
            }
        }
        Method[] result = new Method[count];
        int j=0;
        for (int i=0; i < methods.length; i++) {
            if (methods[i] != null)
                result[j++] = methods[i];
        }
        return result;
    }
374230
def method_missing(meth, value)
      meth = sanitize_setter_method(meth)

      if defaults.key?(meth)
        @options[meth] = value
      else
        super
      end
    end
367658
def allowed_methods(self, path_info=None):
        
        try:
            self.match(path_info, method="--")
        except MethodNotAllowed as e:
            return e.valid_methods
        except HTTPException:
            pass
        return []
671355
def no_empty_value(func):
    """"""
    @wraps(func)
    def wrapper(value):
        if not value:
            raise Exception("Empty value not allowed")
        return func(value)
    return wrapper
390782
def get_value(self):
        """"""
        if self.value is not_computed:
            self.value = self.value_provider()
            if self.value is not_computed:
                return None
        return self.value
895970
private int getIntValue(String str, int defaultValue) {

        try {
            int intValue = Integer.parseInt(str);
            return (intValue > 0) ? intValue : defaultValue;
        } catch (NumberFormatException e) {
            // intentionally left blank
        }
        return defaultValue;
    }
554807
def method_missing(m, *args, &block)
      return nil if @is_empty
      if m =~ /\?$/
        # query if a value exists, e.g., r.info.dp? or s.dp?
        v = values[fetch(m.to_s.upcase.chop)]
        return (not VcfValue::empty?(v))
      else
        v = values[fetch(m.to_s.upcase)]
        return nil if VcfValue::empty?(v)
        v = v.to_i if v =~ /^\d+$/
        v = v.to_f if v =~ /^\d+\.\d+$/
        v
      end
    end