パスからリストのインデックス([1])やマップのキー([key])を除去したものを構成する。
<p>SpringFrameworkの「PropertyEditorRegistrySupport#addStrippedPropertyPaths(...)」の処理</p>
@param strippedPaths 除去したパス
@param nestedPath 現在のネストしたパス
@param propertyPath 処理対象のパス
173367
public void addStrippedPropertyPaths(List<String> strippedPaths, String nestedPath, String propertyPath) {
        
        final int startIndex = propertyPath.indexOf('[');
        if (startIndex != -1) {
            final int endIndex = propertyPath.indexOf(']');
            if (endIndex != -1) {
                final String prefix = propertyPath.substring(0, startIndex);
                final String key = propertyPath.substring(startIndex, endIndex + 1);
                final String suffix = propertyPath.substring(endIndex + 1, propertyPath.length());
                
                // Strip the first key.
                strippedPaths.add(nestedPath + prefix + suffix);
                
                // Search for further keys to strip, with the first key stripped.
                addStrippedPropertyPaths(strippedPaths, nestedPath + prefix, suffix);
                
                // Search for further keys to strip, with the first key not stripped.
                addStrippedPropertyPaths(strippedPaths, nestedPath + prefix + key, suffix);
            }
        }
    }
541374
public Binding createBinding(String propertyPath, String binderId, Map context)
    {
        Assert.notNull(context, "Context must not be null");
        Binder binder = ((SwingBinderSelectionStrategy)getBinderSelectionStrategy()).getIdBoundBinder(binderId);
        Binding binding = binder.bind(getFormModel(), propertyPath, context);
        interceptBinding(binding);
        return binding;
    }
952419
void configureFiles(String path) {

        // If the property is set, reload from a local directory:
        if (StringUtils.isNotBlank(path)) {
            configureFilesReloadable(path);
        } else {
            configureFilesResource();
        }
        filesReloadable = filesUrl != null;

        // Communicate:
        showFilesConfiguration();
    }
432668
private static void warn(Object scope, String propertyPath)
  {
    if(scope == null) {
      log.warn("Null object scope while searching for property |%s|.", propertyPath);
    }
    else {
      log.warn("Null value for |%s#%s|.", scope.getClass(), propertyPath);
    }
  }
1177479
private void init(final SecurityContext securityContext, final Class type, final Field field, final String path) throws FrameworkException {

		final QueryConfig config = getConfig(path);

		config.handleTypeArguments(securityContext, type, field.getArguments());

		final SelectionSet selectionSet = field.getSelectionSet();
		if (selectionSet != null) {

			for (final Selection selection : selectionSet.getSelections()) {

				if (selection instanceof Field) {

					final Field childField      = (Field)selection;
					final SelectionSet childSet = childField.getSelectionSet();
					final PropertyKey key       = StructrApp.key(type, childField.getName());
					final Class relatedType     = key.relatedType() != null ? key.relatedType() : type;

					// add field to property set
					config.addPropertyKey(key);
					config.handleFieldArguments(securityContext, relatedType, field, childField);

					// recurse
					if (childSet != null) {

						init(securityContext, relatedType, childField, path + "/" + childField.getName());
					}
				}
			}
		}
	}
236046
static void deletePath(String path) {
        try {
            ZkConnection.client.delete().guaranteed().deletingChildrenIfNeeded().forPath(path);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
944770
private void setWebAppRfsPath(String webInfRfsPath) {

        m_webAppRfsPath = webInfRfsPath;
        if ("".equals(webInfRfsPath)) {
            // required for test cases
            m_configRfsPath = "";
            return;
        }
        if (!m_webAppRfsPath.endsWith(File.separator)) {
            // make sure that Path always ends with a separator, not always the case in different
            // environments since getServletContext().getRealPath("/") does not end with a "/" in
            // all servlet runtimes
            m_webAppRfsPath += File.separator;
        }

        if (CmsStringUtil.isNotEmpty(System.getProperty(CmsSystemInfo.CONFIG_FOLDER_PROPERTY))) {
            m_configRfsPath = System.getProperty(CmsSystemInfo.CONFIG_FOLDER_PROPERTY);
        } else {
            m_configRfsPath = m_webAppRfsPath + CmsSystemInfo.FOLDER_WEBINF + CmsSystemInfo.FOLDER_CONFIG_DEFAULT;
        }
    }
873597
public void addPath(String path, Mode mode)
    {
        PathHolder pathHolder = new PathHolder(path, mode, 0);
        activePaths.put(path, pathHolder);
        schedule(pathHolder, reapingThresholdMs);
    }
1117105
public Hashtable getPropertiesByPaths(String[] propPaths)
        throws InvalidProperty, RuntimeFault, RemoteException {
        Hashtable[] pht = PropertyCollectorUtil.retrieveProperties(
            new ManagedObject[]{this}, getMOR().getType(), propPaths);
        if (pht.length != 0) {
            return pht[0];
        }
        else {
            return null;
        }
    }
953006
protected void addRequiredPath(String requiredPath) {
        if(requiredPath == null) {
            throw new IllegalArgumentException("Required path can't be null.");
        }
        DefaultOperationRequestAddress requiredAddress = new DefaultOperationRequestAddress();
        CommandLineParser.CallbackHandler handler = new DefaultCallbackHandler(requiredAddress);
        try {
            ParserUtil.parseOperationRequest(requiredPath, handler);
        } catch (CommandFormatException e) {
            throw new IllegalArgumentException("Failed to parse nodeType: " + e.getMessage());
        }
        addRequiredPath(requiredAddress);
    }
323132
public static String getParentPropertyPath(String propertyPath) {
       int propertySeparatorIndex = getLastNestedPropertySeparatorIndex(propertyPath);
       return propertySeparatorIndex == -1? "": propertyPath.substring(0, propertySeparatorIndex);
   }
1364681
private Path<?> buildPropertyPathForAnyType(Root<T> root, String stringPath) {
		
		// Si la racine est nulle
		if(root == null) return null;
		
		// Si la chaine est vide
		if(stringPath == null || stringPath.trim().length() == 0) return null;
		
		// Le Path à retournet
		Path<?> path = null;
		
		// On splitte sur le séparateur de champs
		String[] hierarchicalPaths = stringPath.trim().split("\\.");
		
		// Obtention du premier chemin
		path = root.get(hierarchicalPaths[0]);
		
		// Si la taille est > 1
		if(hierarchicalPaths.length > 1) {

			// Parcours
			for (int i = 1; i < hierarchicalPaths.length; i++) {
				
				// Le chemin
				String unitPath = hierarchicalPaths[i];
				
				// Si le path est vide ou est une suite d'espace
				if(unitPath == null || unitPath.trim().length() == 0) continue;
				
				// Acces à la ppt
				path = path.get(unitPath.trim());
			}
		}
		
		// On retourne le Path
		return path;
	}
643378
public void addToPath(String path, String property) {
        Props props = pathMap.computeIfAbsent(path, k -> new Props(this, null, path));
        props.getProperties().add(property);
    }
518410
public <T> FieldFormatter<T> findFormatter(final String fieldPath, final Class<T> requiredType) {
        
        // 完全なパスで比較
        FieldFormatter<T> formatter = getFormatter(fieldPath, requiredType);
        if(formatter != null) {
            return formatter;
        }
        
        // インデックスを除去した形式で比較
        final List<String> strippedPaths = new ArrayList<>();
        addStrippedPropertyPaths(strippedPaths, "", fieldPath);
        
        for(String strippedPath : strippedPaths) {
            formatter = getFormatter(strippedPath, requiredType);
            if(formatter != null) {
                return formatter;
            }
            
        }
        
        // 見つからない場合は、タイプのみで比較した物を取得する
        return getFormatter(requiredType);
        
        
    }
794155
public void addPath(MultiPath src, int srcPathIndex, boolean bForward) {
		m_impl.addPath((MultiPathImpl) src._getImpl(), srcPathIndex, bForward);
	}
1363442
public static Properties getProperties(final String propertiesPath) throws PropertiesException {

        Properties properties;
        String propertiesFilePath = getPropertiesFilePath(propertiesPath);
        if (propertiesFilePath == null) {
            throw new PropertiesException(String.format(
                    "Loading '%s' properties failed, no such properties.", propertiesPath));
        }
        FileInputStream fileInputStream = null;
        try {
            properties = new Properties();
            fileInputStream = new FileInputStream(propertiesFilePath);
            properties.load(fileInputStream);
            fileInputStream.close();
            return properties;
        } catch (Exception e) {
            try {
                if (fileInputStream != null)
                    fileInputStream.close();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            throw new PropertiesException(String.format("Loading '%s' properties failed.",
                    propertiesPath), e);
        }
    }
107124
public void includeGroovy(String templatePath) throws IOException, ClassNotFoundException {
        URL resource = engine.resolveTemplate(templatePath);
        engine.createTypeCheckedModelTemplate(resource, modelTypes).make(model).writeTo(out);
    }