Sets path specifics

@param annotations list of method annotations
558728
private void init(Annotation[] annotations) {

		for (Annotation annotation : annotations) {

			if (annotation instanceof RouteOrder) {
				order(((RouteOrder) annotation).value());
			}

			if (annotation instanceof Path) {
				path(((Path) annotation).value());
			}

			if (annotation instanceof Produces) {
				produces(((Produces) annotation).value());
			}

			if (annotation instanceof Consumes) {
				consumes(((Consumes) annotation).value());
			}

			if (annotation instanceof Header) {
				headers = headers(((Header) annotation).value());
			}

			if (annotation instanceof GET ||
			    annotation instanceof POST ||
			    annotation instanceof PUT ||
			    annotation instanceof DELETE ||
			    annotation instanceof HEAD ||
			    annotation instanceof OPTIONS ||
			    annotation instanceof PATCH) {
				method(annotation.annotationType().getSimpleName());
			}

			// Custom rest.vertx method, path, consumes and produces combination
			if (annotation instanceof Get ||
			    annotation instanceof Post ||
			    annotation instanceof Put ||
			    annotation instanceof Delete ||
			    annotation instanceof Head ||
			    annotation instanceof Options ||
			    annotation instanceof Patch ||
			    annotation instanceof Trace ||
			    annotation instanceof Connect) {

				method(annotation.annotationType().getSimpleName());

				// take path, consumes and produces values if given
				// we need to use proxy to get to the underlying methods
				InvocationHandler handler = Proxy.getInvocationHandler(annotation);
				try {
					path((String) handler.invoke(annotation, annotation.getClass().getMethod("value"), null));

					consumes((String[]) handler.invoke(annotation, annotation.getClass().getMethod("consumes"), null));
					produces((String[]) handler.invoke(annotation, annotation.getClass().getMethod("produces"), null));
				}
				catch (Throwable ex) {
					// should not happen ...
					log.warn("Failed to get annotation value via proxy!", ex);
				}
			}

			if (annotation instanceof javax.ws.rs.HttpMethod) {
				method(((javax.ws.rs.HttpMethod) annotation).value());
			}

			// response writer ...
			if (annotation instanceof ResponseWriter) {
				writer = ((ResponseWriter) annotation).value();
			}

			if (annotation instanceof RequestReader) {
				reader = ((RequestReader) annotation).value();
			}

			if (annotation instanceof ContextReader) {
				contextProvider = ((ContextReader)annotation).value();
			}

			if (annotation instanceof RolesAllowed) {
				permitAll = null; // override any previous definition
				roles = ((RolesAllowed) annotation).value();
			}

			if (annotation instanceof DenyAll) {
				roles = null; // override any previous definition
				permitAll = false;
			}

			if (annotation instanceof PermitAll) {
				roles = null; // override any previous definition
				permitAll = true;
			}

			if (annotation instanceof CatchWith) {
				exceptionHandlers =
					ArrayUtils.join(((CatchWith) annotation).value(), exceptionHandlers); // method handler is applied before class handler
			}

			if (annotation instanceof SuppressCheck) {
				suppressCheck = true;
			}

			if (annotation instanceof Blocking) {
				blockingOrdered = ((Blocking) annotation).value();
			}

			if (annotation instanceof Event) {
				Event event = (Event) annotation;
				addEvent(event);
			}

			if (annotation instanceof Events) {
				Events eventArray = (Events) annotation;
				if (eventArray.value().length > 0) {
					for (Event event : eventArray.value()) {
						addEvent(event);
					}
				}
			}
		}
	}
347910
public void setFilePaths(String... filePaths) {
		Path[] paths = new Path[filePaths.length];
		for (int i = 0; i < paths.length; i++) {
			paths[i] = new Path(filePaths[i]);
		}
		setFilePaths(paths);
	}
1228209
@XmlElement(name="annotation")
    public void setAnnotationInfos(final List<AnnotationInfo> annotationInfos) {
        if(annotationInfos == this.annotationInfos) {
            // Java7の場合、getterで取得したインスタンスをそのまま設定するため、スキップする。
            return;
        }
        
        this.annotationInfos.clear();
        for(AnnotationInfo item : annotationInfos) {
            addAnnotationInfo(item);
        }
    }
675528
public void setRepositories( List<String> urls ) throws ProjectException {
        List<Repository> repositories = new ArrayList<Repository>();
        for ( String url : urls  ) {
            try {
                Repository repository = RepoBuilder.repositoryFromUrl( url );
                repositories.add( repository );
            } catch (MalformedURLException e) {
                throw new ProjectException( e );
            }
        }
        getMavenModel().setRepositories( repositories);
    }
947872
private static String findPattern(Method method, Set<Annotation> methodAnnotations) {
        String pattern = findFirst(method, Path.class).map(Path::value)
                                                      .orElse(null);
        for (Annotation a : methodAnnotations) {
            final String p = (String) invokeValueMethod(a);
            if (DefaultValues.isUnspecified(p)) {
                continue;
            }
            checkArgument(pattern == null,
                          "Only one path can be specified. (" + pattern + ", " + p + ')');
            pattern = p;
        }
        if (pattern == null || pattern.isEmpty()) {
            throw new IllegalArgumentException(
                    "A path pattern should be specified by @Path or HTTP method annotations.");
        }
        return pattern;
    }
261261
private void addAnnotation(final Class<? extends Annotation> clazz) {
        final List<? extends Annotation> annotations = ReflectionUtils.getAnnotations(getClazz(), clazz);
        for (final Annotation ann : annotations) {
            addAnnotation(clazz, ann);
        }
    }
240152
public void setServerCustomizers(
			Collection<? extends JettyServerCustomizer> customizers) {
		Assert.notNull(customizers, "Customizers must not be null");
		this.jettyServerCustomizers = new ArrayList<>(customizers);
	}
982151
public function setPaths($paths)
    {
        $this->paths = $paths;
        self::$pathsMap[$this->namespace] = $this->paths;
    }
305258
public void setLocation(final String fileNames) {
        List<String> list = new ArrayList<String>();
        list.add(fileNames);
        setLocations(list);
    }
124004
private static Set<Annotation> getAnnotations(final Annotation[] annotations, final Class<? extends Annotation> neededAnnotationType) {
        final Set<Annotation> ret = new HashSet<>();

        for (final Annotation annotation : annotations) {
            annotation.annotationType().getAnnotations();
            final Annotation[] metaAnnotations = annotation.annotationType().getAnnotations();
            for (final Annotation metaAnnotation : metaAnnotations) {
                if (metaAnnotation.annotationType().equals(neededAnnotationType)) {
                    ret.add(annotation);
                }
            }
        }

        return ret;
    }
242895
public void setPath(String path) {
        this.path = path;

        List<Token> tokens = Tokenizer.tokenize(path, true);
        int tokenCount = 0;
        for (Token t : tokens) {
            if (t.getType() != TokenType.TEXT) {
                tokenCount++;
            }
        }
        if (tokenCount > 0) {
            this.pathTokens = tokens.toArray(new Token[0]);
        } else {
            this.pathTokens = null;
        }
    }
21307
public void setNetworkAclIds(java.util.Collection<String> networkAclIds) {
        if (networkAclIds == null) {
            this.networkAclIds = null;
            return;
        }

        this.networkAclIds = new com.amazonaws.internal.SdkInternalList<String>(networkAclIds);
    }
135785
public void setItems(java.util.Collection<BasePathMapping> items) {
        if (items == null) {
            this.items = null;
            return;
        }

        this.items = new java.util.ArrayList<BasePathMapping>(items);
    }
602446
public final void addAnnotations(final List<SgAnnotation> annotations) {
        if (annotations == null) {
            throw new IllegalArgumentException("The argument 'annotations' cannot be NULL!");
        }
        this.annotations.addAll(annotations);
    }
696772
public void setMethods(Set<String> methods) {
        this.methods = new HashSet<>();
        for (String method : methods) {
            this.methods.add(method.toUpperCase());
        }
    }
981809
@Override
	protected void addPaths(Set<String> paths, Collection<Map<String, Object>> commits) {
		paths.add("application.yml");
	}
309541
public void setRoutes(java.util.Collection<OriginationRoute> routes) {
        if (routes == null) {
            this.routes = null;
            return;
        }

        this.routes = new java.util.ArrayList<OriginationRoute>(routes);
    }