Return prefix of apply pattern or pattern if not apply-pattern.
@param property
@return
14810
public static final String applyPrefix(String property)
    {
        int addIdx = property.lastIndexOf(Add);
        if (addIdx != -1)
        {
            return property.substring(0, addIdx);
        }
        else
        {
            int assignIdx = property.lastIndexOf(Assign);
            if (assignIdx != -1)
            {
                return property.substring(0, assignIdx);
            }
            else
            {
                if (property.endsWith(Remove))
                {
                    return property.substring(0, property.length()-1);
                }
                else
                {
                    return property;
                }
            }
        }
    }
965049
public Object getProperty(String property) {
        try {
            Object key = lookupKeyIgnoringCase(property);
            if (key != null) {
                return result.get(key);
            }
            throw new MissingPropertyException(property, GroovyRowResult.class);
        }
        catch (Exception e) {
            throw new MissingPropertyException(property, GroovyRowResult.class, e);
        }
    }
883130
public Object getAsRaw(String property) {
		if (super.has(property)) {
			return get(property).getAsRaw();
		}
		return null;
	}
705497
public final int getWriteIndex(String property) {
    MethodInfo method = propertyWriteMethods.get(property);
    return (null == method) ? -1 : method.index;
  }
28834
public static String propertyName(Method method) {
        if (!is(method)) {
            throw new IllegalArgumentException("Method: " + method + " is not a real getter.");
        }
        String name = method.getName();

        if (name.startsWith(GET_PREFIX)) {
            return name.substring(GET_PREFIX.length());
        } else if (name.startsWith(IS_PREFIX)) {
            return name.substring(IS_PREFIX.length());
        } else if (name.startsWith(SHOULD_PREFIX)) {
            name = name.substring(SHOULD_PREFIX.length());
        } else {
            throw new IllegalStateException("Method: " + method + " is a getter but couldn't find a valid prefix.");
        }

        if (name.length() == 1) {
            return name.toUpperCase();
        }
        return name.substring(0, 1).toUpperCase() + name.substring(1);
    }
582643
public FessMessages addErrorsSuffix(String property) {
        assertPropertyNotNull(property);
        add(property, new UserMessage(ERRORS_SUFFIX));
        return this;
    }
1338503
function findInternalPrefixes(property, noAutofill) {
		var result = [];
		var prefixes = findVendorPrefixes(property);
		
		if (prefixes) {
			var prefixMap = {};
			Object.keys(vendorPrefixes).forEach(function(key) {
				prefixMap[vendorPrefixes[key].prefix] = key;
			});

			result = prefixes.map(function(prefix) {
				return prefixMap[prefix];
			});
		}
		
		if (!result.length && !noAutofill) {
			// add all non-obsolete prefixes
			Object.keys(vendorPrefixes).forEach(function(prefix) {
				if (!vendorPrefixes[prefix].obsolete) {
					result.push(prefix);
				}
			});
		}
		
		return result;
	}
70624
public static PrefsTransform lookup(PrefsProperty property) {
		TypeMirror typeMirror = property.getElement().asType();

		TypeName typeName = typeName(typeMirror);
		return lookup(typeName);
	}
62166
public Object getProperty(String property) {
        /** @todo we should check if we have the property with the metaClass instead of try/catch  */
        try {
            return super.getProperty(property);
        }
        catch (MissingPropertyException e) {
            return getVariable(property);
        }
    }
1253798
public String getProperty(final String property) {
        if (System.getSecurityManager() == null)
            return System.getProperty(property);
        return AccessController.doPrivileged(new PrivilegedAction<String>() {
            @Override
            public String run() {
                return System.getProperty(property);
            }
        }, controlContext);
    }
985184
public String value(String property) {

		Xpp3Dom propNode = get(property);

		if (propNode == null) {
			// not found
			return null;
		}

		return propNode.getValue();
	}
999578
public String getStringValue(String property) {

		final List<JawrConfigManagerMBean> mBeans = getInitializedConfigurationManagers();
		try {

			if (mBeans.size() == 3) {

				if (areEquals(getProperty(jsMBean, property), getProperty(cssMBean, property),
						getProperty(binaryMBean, property))) {

					return getProperty(jsMBean, property);
				} else {
					return NOT_IDENTICAL_VALUES;
				}
			}

			if (mBeans.size() == 2) {
				JawrConfigManagerMBean mBean1 = mBeans.get(0);
				JawrConfigManagerMBean mBean2 = mBeans.get(1);

				if (areEquals(getProperty(mBean1, property), getProperty(mBean2, property))) {
					return getProperty(mBean1, property);
				} else {
					return NOT_IDENTICAL_VALUES;
				}
			}

			JawrConfigManagerMBean mBean1 = mBeans.get(0);

			return getProperty(mBean1, property);

		} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
			return ERROR_VALUE;
		}

	}
446844
public Map<String, V> prefix(@NonNull String prefix) {
      final TrieNode<V> match = root.find(prefix);
      if (match == null) {
         return Collections.emptyMap();
      }
      return new AbstractMap<String, V>() {
         @Override
         public Set<Entry<String, V>> entrySet() {
            return new AbstractSet<Entry<String, V>>() {
               @Override
               public Iterator<Entry<String, V>> iterator() {
                  return Iterators.unmodifiableIterator(new EntryIterator<>(match));
               }

               @Override
               public int size() {
                  return match.size;
               }
            };
         }
      };
   }
888740
protected Collection<String> getPropertyValues(final Property property) {
        final ExtendedIterator<Triple> iterator = graph.find(Node.ANY,
                                                             property.asNode(),
                                                             Node.ANY);
        final Set<String> set = new HashSet<>();
        while (iterator.hasNext()) {
            final Node object = iterator.next().getObject();
            if (object.isLiteral()) {
                set.add(object.getLiteralValue().toString());
            } else if (object.isURI()) {
                set.add(object.getURI().toString());
            } else {
                set.add(object.toString());
            }
        }
        return set;
    }
31849
public String queryAttribute(String property) {
        try {
            Object oldValue = null;
            if (property.charAt(0) == RpcConstants.HIDE_KEY_PREFIX) {
                // 方法级配置 例如.echoStr.timeout
                String methodAndP = property.substring(1);
                int index = methodAndP.indexOf(RpcConstants.HIDE_KEY_PREFIX);
                if (index <= 0) {
                    throw ExceptionUtils.buildRuntime(property, "", "Unknown query attribute key!");
                }
                String methodName = methodAndP.substring(0, index);
                String methodProperty = methodAndP.substring(index + 1);
                MethodConfig methodConfig = getMethodConfig(methodName);
                if (methodConfig != null) {
                    Method getMethod = ReflectUtils.getPropertyGetterMethod(MethodConfig.class, methodProperty);
                    Class propertyClazz = getMethod.getReturnType(); // 旧值的类型
                    oldValue = BeanUtils.getProperty(methodConfig, methodProperty, propertyClazz);
                }
            } else { // 接口级配置 例如timeout
                // 先通过get方法找到类型
                Method getMethod = ReflectUtils.getPropertyGetterMethod(getClass(), property);
                Class propertyClazz = getMethod.getReturnType(); // 旧值的类型
                // 拿到旧的值
                oldValue = BeanUtils.getProperty(this, property, propertyClazz);
            }
            return oldValue == null ? null : oldValue.toString();
        } catch (Exception e) {
            throw new SofaRpcRuntimeException("Exception when query attribute, The key is " + property, e);
        }
    }
354559
public static String removePropertyPrefix(String propertyValue) {

        if (propertyValue == null) {
            return null;
        }
        if (propertyValue.startsWith(DYNAMIC_TEMPLATE_PREFIX)) {
            return propertyValue.substring(DYNAMIC_TEMPLATE_PREFIX.length());
        }
        if (propertyValue.startsWith(DYNAMIC_TEMPLATE_LEGACY_PREFIX)) {
            return propertyValue.substring(DYNAMIC_TEMPLATE_LEGACY_PREFIX.length());
        }
        return propertyValue;
    }
645303
public void getSubProperties (String prefix, Properties target)
    {
        // slap a trailing dot on if necessary
        if (!prefix.endsWith(".")) {
            prefix = prefix + ".";
        }

        // build the sub-properties
        for (Iterator<String> iter = keys(); iter.hasNext(); ) {
            String key = iter.next();
            if (!key.startsWith(prefix)) {
                continue;
            }
            String value = getValue(key, (String)null);
            if (value == null) {
                continue;
            }
            target.put(key.substring(prefix.length()), value);
        }
    }