import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
protected void addResourcePath( String name,
                                Class<? extends HasIdentity> type,
                                String basePath,
                                boolean createLink,
                                boolean rootRoute
                              )
{
    if( createLink )
    {
        router.attach( basePath + name + "/create", newPolygeneRestlet( CreationResource.class, type ) );
    }
    TemplateRoute route = router.attach( basePath + name + "/", newPolygeneRestlet( EntityListResource.class, type ) );
    if( rootRoute )
    {
        route.setName( name );
    }
    router.attach( basePath + name + "/{id}/", newPolygeneRestlet( EntityResource.class, type ) );
    router.attach( basePath + name + "/{id}/{invoke}", newPolygeneRestlet( EntityResource.class, type ) );
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    component = PowerMockito.mock(Component.class, RETURNS_DEEP_STUBS);

    ServerList list = PowerMockito.mock(ServerList.class);
    PowerMockito.doReturn(list).when(component).getServers();
    PowerMockito.doReturn(mock(Server.class)).when(list).add(any(Protocol.class), anyInt());

    VirtualHost host = PowerMockito.mock(VirtualHost.class);
    PowerMockito.doReturn(host).when(component).getDefaultHost();
    PowerMockito.doReturn(mock(TemplateRoute.class))
            .when(host).attach(anyString(), any(RMrouterApplication.class));

    PowerMockito.doNothing().when(component).start();

    PowerMockito.whenNew(Component.class).withNoArguments().thenReturn(component);

    OdenOsPropertyLoader loader = PowerMockito.spy(OdenOsPropertyLoader.getInstance());
    Whitebox.setInternalState(OcnRMServ.class, "loader", loader);

    dummyLogger = mock(Logger.class);
    Whitebox.setInternalState(OcnRMServ.class, "logger", dummyLogger);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
/**
 * Redirects a URI to a new URI. You can use template variables in the URIs.
 * <p>
 * Enforces matching mode {@link Template#MODE_EQUALS}.
 * <p>
 * This is handled via a {@link NormalizingRedirector}.
 * 
 * @param uriTemplate
 *        The URI path template that must match the relative part of the
 *        resource URI
 * @param targetUriTemplate
 *        The target URI template
 * @param statusCode
 *        HTTP status code (must be 301, 302, 303 or 307)
 * @return The created route
 * @see NormalizingRedirector
 */
public TemplateRoute redirectClient( String uriTemplate, String targetUriTemplate, int statusCode )
{
	int mode;
	switch( statusCode )
	{
		case 301:
			mode = Redirector.MODE_CLIENT_PERMANENT;
			break;
		case 302:
			mode = Redirector.MODE_CLIENT_FOUND;
			break;
		case 303:
			mode = Redirector.MODE_CLIENT_SEE_OTHER;
			break;
		case 307:
			mode = Redirector.MODE_CLIENT_TEMPORARY;
			break;
		default:
			throw new IllegalArgumentException( "Unsupported status code: " + statusCode );
	}

	TemplateRoute route = attach( uriTemplate, new NormalizingRedirector( getContext(), targetUriTemplate, mode ) );
	route.setMatchingMode( Template.MODE_EQUALS );
	return route;
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
protected TemplateRoute attach(Router router, Class<?> targetClass) {
    TemplateRoute route = null;
    Resource resource = AnnotationUtils.findAnnotation(targetClass, Resource.class);
    if (resource != null) {
        route = router.attach(resource.path(), new ServerResourceInjectedFinder(getContext(), targetClass));
        if (resource.strict()) {
            route.getTemplate().setMatchingMode(Template.MODE_EQUALS);
        } else {
            route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);
        }
    } else {
        throw new RuntimeException("Resource " + targetClass + " require @Resouce annotation.");
    }

    return route;
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
/**
 * 
 * @param router
 * @param strict
 *            The matching mode to use when parsing a formatted reference.
 * @param uriPattern
 * @param target
 * @return
 */
@Override
public TemplateRoute attach(Router router, boolean strict, String uriPattern, Restlet target) {
	if (logger.isDebugEnabled()) {
		logger.debug("Attaching Restlet of class '" + target.getClass().getName() + "' to URI='" + uriPattern
				+ "' (strict='" + strict + "')");
	}

	TemplateRoute route = router.attach(uriPattern, target);

	if (strict) {
		route.getTemplate().setMatchingMode(Template.MODE_EQUALS);
	} else {
		route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);
	}
	return route;
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
private void attachPath(String path,
		Class<? extends ServerResource> resourceClass, Role role) {
	RoleAuthorizer ra = new RoleAuthorizer();
	TemplateRoute route;
	if (role != null) {
		ra.getAuthorizedRoles().add(role);
		ra.setNext(resourceClass);
		route = attach(path, ra);
	} else {
		route = attach(path, resourceClass);
	}
	route.setMatchingMode(Template.MODE_STARTS_WITH);

	// Allow the user variable to match any valid path characters.
	// Needed because usernames from external sources may contain slashes.
	Template template = route.getTemplate();
	Map<String, Variable> variables = template.getVariables();
	variables.put(UserResource.USERNAME_URI_ATTRIBUTE, new Variable(Variable.TYPE_URI_PATH));
	template.setVariables(variables);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
public ActionRouter() {
	super();

	// Routing is tolerant of extraneous leading and trailing slashes.
	// TODO: Determine a better mechanism for being tolerant of slashes.
	TemplateRoute route;

	route = attach("/{uuid}/{command}/", ActionResource.class);
	route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);

	route = attach("/{uuid}/{command}", ActionResource.class);
	route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);

	route = attach("{uuid}/{command}/", ActionResource.class);
	route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);

	route = attach("{uuid}/{command}", ActionResource.class);
	route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);

	attachDefault(InvalidActionResource.class);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
@Override
public TemplateRoute attach(Restlet target) {
    if (target.getContext() == null) {
        target.setContext(getContext().createChildContext());
    }

    return super.attach(target);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
@Override
public TemplateRoute attachDefault(Restlet defaultTarget) {
    if (defaultTarget.getContext() == null) {
        defaultTarget.setContext(getContext().createChildContext());
    }

    return super.attachDefault(defaultTarget);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
private EntryPoint createEntryPoint()
        {
            Map<String, RestLink> entryPoints = new HashMap<>();
            for( Route r : parameters.router().get().getRoutes() )
            {
                if( r instanceof TemplateRoute)
                {
                    TemplateRoute route = (TemplateRoute) r;
                    Template template = route.getTemplate();
                    // Only include patterns that doesn't have variables, and has a proper name.
                    if( template.getVariableNames().isEmpty() && route.getName().indexOf( '>' ) == -1 )
                    {
                        Reference hostRef = parameters.request().get().getOriginalRef();
//                        Reference reference = new Reference( hostRef, template.getPattern() );
                        RestLink link;
                        if( route.getDescription() == null )
                        {
                            link = resourceBuilder.createRestLink( template.getPattern(), hostRef, Method.GET );
                        }
                        else
                        {
                            link = resourceBuilder.createRestLink( template.getPattern(), hostRef, Method.GET, route.getDescription() );
                        }
                        entryPoints.put( route.getName(), link );
                    }
                }
            }
            ValueBuilder<EntryPoint> builder = vbf.newValueBuilder( EntryPoint.class );
            builder.prototype().identity().set( StringIdentity.identityOf( "/" ) );
            builder.prototype().api().set( entryPoints );
            return builder.newInstance();
        }
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
@Override
protected TemplateRoute createRoute( String uriPattern, Restlet target, int matchingMode )
{
	if( target instanceof CapturingRedirector )
	{
		// Use CapturingRoutes for CapturingRedirectors
		TemplateRoute result = new CapturingRoute( this, new ResolvingTemplate( uriPattern, matchingMode, Variable.TYPE_URI_SEGMENT, "", true, false ), target );
		result.setMatchingQuery( getDefaultMatchingQuery() );
		return result;
	}
	else
		return super.createRoute( uriPattern, target, matchingMode );
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
/**
 * @param pathTemplate
 *        The URI path template that must match the relative part of the
 *        resource URI.
 * @param target
 *        The target Restlet to attach.
 * @return The created route.
 */
public TemplateRoute attachFallback( String pathTemplate, Restlet target )
{
	TemplateRoute existingRoute = null;
	for( Route route : getRoutes() )
	{
		if( route instanceof TemplateRoute )
		{
			TemplateRoute templateRoute = (TemplateRoute) route;
			if( templateRoute.getTemplate().getPattern().equals( pathTemplate ) )
			{
				existingRoute = templateRoute;
				break;
			}
		}
	}

	if( existingRoute != null )
	{
		Restlet current = existingRoute.getNext();
		if( current instanceof Fallback )
		{
			// Add to current Fallback
			( (Fallback) current ).addTarget( target );
		}
		else
		{
			// Replace current target with Fallback
			Fallback fallback = new Fallback( getContext(), cacheDuration, current, target );
			existingRoute.setNext( fallback );
		}

		return existingRoute;
	}

	return attach( pathTemplate, target );
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
@Override
protected TemplateRoute createRoute( String uriPattern, Restlet target, int matchingMode )
{
	TemplateRoute result = new TemplateRoute( this, new ResolvingTemplate( uriPattern, matchingMode, Variable.TYPE_URI_SEGMENT, "", true, false ), target );
	result.setMatchingQuery( getDefaultMatchingQuery() );
	return result;
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
private void list(Map<Restlet, String> all, Restlet restlet, String path) {
	all.put(restlet, path);
	if (restlet instanceof Router) {
		for (Route r : ((Router)restlet).getRoutes()) {
			list(all, r, path + ((TemplateRoute)r).getTemplate().getPattern());
		}
	} else if (restlet instanceof Filter) {
		list(all, ((Filter) restlet).getNext(), path);
	}
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
/**
 * Bind all resources to routes. Override this if you need to.
 */
private void addRoutes(){
	
	root.attach(AboutServerResource.uri, AboutServerResource.class);
	root.attach(LobbyServerResource.uri, LobbyServerResource.class);
	root.attach(BatchServerResource.uri, BatchServerResource.class);
	
	root.attach(SearchServerResource.uri, SearchServerResource.class);
	
	root.attach(WatchServiceServerResource.uri, WatchServiceServerResource.class);
	
	root.attach(WatchAddServerResource.uri, WatchAddServerResource.class);
	root.attach(WatchDeleteServerResource.uri, WatchDeleteServerResource.class);
	root.attach(WatchPoolChangesServerResource.uri, WatchPoolChangesServerResource.class);
	root.attach(WatchPoolRefreshServerResource.uri, WatchPoolRefreshServerResource.class);
	root.attach(WatchRemoveServerResource.uri, WatchRemoveServerResource.class);
	root.attach(WatchServerResource.uri, WatchServerResource.class);
	
	root.attach(HistoryServiceServerResource.uri, HistoryServiceServerResource.class);
	root.attach(HistoryServerResource.uri, HistoryServerResource.class);
	root.attach(HistoryQueryServerResource.uri, HistoryQueryServerResource.class);
	root.attach(HistoryRollupServerResource.uri, HistoryRollupServerResource.class);
	
	root.attach(AlarmServerResource.uri, AlarmServerResource.class);
	root.attach(AlarmServiceServerResource.uri,AlarmServiceServerResource.class);
	root.attach(AlarmAckServerResource.uri, AlarmAckServerResource.class);
	root.attach(RangeAlarmMaxResource.uri, RangeAlarmMaxServerResource.class);
	root.attach(RangeAlarmMinResource.uri, RangeAlarmMinServerResource.class);
	
	// Last route. 
	TemplateRoute route = root.attach( ObjServerResource.uri + "{+href}", ObjServerResource.class);
	route.setMatchingMode(Template.MODE_STARTS_WITH);
	Map<String, Variable> variables = route.getTemplate().getVariables();
	variables.put("href",new Variable(Variable.TYPE_URI_PATH));
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
public DashboardRouter(Context context) throws ConfigurationException {
	super(context);

	TemplateRoute route;
	route = attach("?user={user}", DashboardResource.class);
	route.setMatchingQuery(true);
	route.getTemplate().getVariables()
			.put("user", new Variable(Variable.TYPE_URI_QUERY));

	attach("", DashboardResource.class);

	attach("/", DashboardResource.class);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
private void attachLogin(RootRouter router) {
	TemplateRoute route = router.attach(LoginResource.getResourceRoot(), LoginResource.class);
	route.getTemplate().setMatchingMode(Template.MODE_STARTS_WITH);

	router.attach(RegistrationResource.getResourceRoot(), RegistrationResource.class);

	router.attach(ResetPasswordResource.getResourceRoot(), ResetPasswordResource.class);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
private AuthenticatorsTemplateRoute guardAndAttach(Router rootRouter, Class<? extends ServerResource> router,
		String rootUri) {
	Authenticators authenticators = getAuthenticators(rootRouter.getApplication());
	authenticators.getLast().setNext(router);
	TemplateRoute route = attach(rootRouter, rootUri, authenticators.getFirst());
	return new AuthenticatorsTemplateRoute(route, authenticators);
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
public GraphiteRouter(Context context) throws ConfigurationException, ValidationException {
	super(context);

	// contains full url, including different port
	String hostname = Configuration.getInstance().getProperty(
			RequiredParameters.SLIPSTREAM_METERING_HOSTNAME.getName());
	String target = hostname + "/render?{query}";
	Redirector redirector = new GraphiteRedirector(getContext(), target, Redirector.MODE_SERVER_OUTBOUND);

	TemplateRoute route = attach("/render?{query}", redirector);
	route.setMatchingQuery(true);
	route.getTemplate().getVariables().put("query", new Variable(Variable.TYPE_URI_QUERY));
}
 

import org.restlet.routing.TemplateRoute; //导入依赖的package包/类
private void attachRootModule() {
	TemplateRoute route;
	route = attach("?chooser={chooser}", ModuleListResource.class);
	route.setMatchingQuery(true);
	route.getTemplate().getVariables()
			.put("chooser", new Variable(Variable.TYPE_URI_QUERY));

	attach("", ModuleListResource.class);
}