protected void lnkBtnSave_Click(object sender, EventArgs e) { string name = RouterName.Text.Trim(); string startPlace = ddlStartPlace.SelectedValue.ToString(); string desPlace = ddlDesPlace.SelectedValue.ToString(); string distance = txtDistance.Text; string description = txtDescription.Text; if (BLLRouter.checkRouterNameExist(name) != 0) { ClientScript.RegisterStartupScript(this.GetType(), "Notify", "alert('!!!Router Name existed. Please try again');", true); } else { Router router = new Router(); router.RouterName = name; router.StartPlace = startPlace; router.DestinationPlace = desPlace; router.Distance = Int32.Parse(distance); router.Description = description; router.Status = true; BLLRouter.InsertRouter(router); Response.Redirect("RouterList.aspx"); } }
public RequestContext(IServerContext context, Router router, Route route, ParameterDictionary routeparams) { Context=context; Router=router; Route=route; RouteParams=routeparams; }
/// <summary> /// Creates a new Guided Variable Neighbourhood Search solver. /// </summary> /// <param name="router"></param> /// <param name="max"></param> /// <param name="deliveryTime"></param> /// <param name="thresholdPrecentage"></param> /// <param name="lambda"></param> public GuidedVNS(Router router, Second max, Second deliveryTime, float thresholdPrecentage, float lambda) : base(max, deliveryTime) { _router = router; _thresholdPercentage = thresholdPrecentage; _lambda = lambda; _intraImprovements = new List<IImprovement>(); //_intra_improvements.Add( // new ArbitraryInsertionSolver()); _intraImprovements.Add( new HillClimbing3OptSolver(true, true)); _interImprovements = new List<IInterImprovement>(); _interImprovements.Add( new RelocateImprovement()); _interImprovements.Add( new ExchangeInterImprovement()); //_inter_improvements.Add( // new TwoOptInterImprovement()); _interImprovements.Add( new RelocateExchangeInterImprovement()); _interImprovements.Add( new CrossExchangeInterImprovement()); }
public static void Register(HttpConfiguration http, IConfiguration config) { var router = new Router(http, e => { e.DefaultConventionsAre(new IRouteConvention[] { new SpecifiedPartRouteConvention("v1"), new MethodNameRouteConvention(), new ParameterNameRouteConvention().DetectGreedyArguments() }); e.AddAll<KeyValueController>(); }); var container = new Container(c => { c.Scan(a => { a.TheCallingAssembly(); a.WithDefaultConventions(); }); c.For<IConfiguration>().Use(config); c.For<VariableStore>().Use<VariableStore>().Singleton(); }); http.Filters.Add(new NullAsNotFoundFilter()); http.Formatters.Add(new PlainTextMediaTypeFormatter()); http.DependencyResolver = new StructureMapDependencyResolver(container); }
public async void TestRouter() { var routeTable = new RouteTable( Route.Get("/").With(() => new TextResponse("root")), Route.Get("/1").With(() => new TextResponse("one")), Route.Get("/2").With(() => new TextResponse("two")), Route.Get("/3").With(() => new TextResponse("three")), Route.Get("/{number}/capture").With(() => new TextResponse("some number")) ); var router = new Router(routeTable); var req1 = new HttpRequest(RemoteEndPoint, false, "localhost", Method.GET, new Uri("http://localhost/invalid"), "/invalid", string.Empty, new Dictionary<string, string>(), ContentTypes.Plain, 0, false, new MemoryStream()); var result1 = await router.HandleRequest(req1, DateTime.UtcNow); var resp1 = result1.HttpResponse; Assert.AreEqual(HttpStatusCode.NotFound, resp1.StatusCode); var req2 = new HttpRequest(RemoteEndPoint, false, "localhost", Method.GET, new Uri("http://localhost/1"), "/1", string.Empty, new Dictionary<string, string>(), ContentTypes.Plain, 0, false, new MemoryStream()); var result2 = await router.HandleRequest(req2, DateTime.UtcNow); var resp2 = result2.HttpResponse; Assert.IsInstanceOf<TextResponse>(resp2); Assert.AreEqual(ContentTypes.Plain, resp2.ContentType); Assert.AreEqual("one", System.Text.Encoding.UTF8.GetString(resp2.Body)); var req3 = new HttpRequest(RemoteEndPoint, false, "localhost", Method.GET, new Uri("http://localhost/8/capture"), "/8/capture", string.Empty, new Dictionary<string, string>(), ContentTypes.Plain, 0, false, new MemoryStream()); await router.HandleRequest(req3, DateTime.UtcNow); Assert.AreEqual("8", req3.PathVariables["number"]); }
public void Allows_CreatesAllowedMethods() { var r=new Router(); var ctrl=r.Controller<TestController>(null); ctrl.Handles("/foo").Allows("biz"); Assert.IsNotNull(ctrl.Current.AllowedMethods); }
public void buildGraph(string filename) { using (StreamReader file = new StreamReader(filename)) { string line = null; char[] spaceDelim = { ' ' }; int numRouters = int.Parse(file.ReadLine()); for (int i = 0; i < numRouters; i++) { line = file.ReadLine(); Router r = new Router(numRouters); r.distance[i] = 0; // distance to itself is 0 r.nextHop[i] = i; // next hop to itself is itself string[] neighbors = line.Split(spaceDelim); for (int j = 1; j < neighbors.Length; j += 2) { r.addNeighbor(neighbors[j][0] - 'A', neighbors[j + 1][0] - '0'); } this.graph.Add(r); } } }
public void Allows_DoesNotDuplicate() { var r=new Router(); var ctrl=r.Controller<TestController>(null); ctrl.Handles("/foo").Allows("biz").Allows("biz"); Assert.IsTrue(ctrl.Current.AllowedMethods.Any(x=>x=="biz")); Assert.AreEqual(1, ctrl.Current.AllowedMethods.Count()); }
public void Allows_AddsMethods() { var r=new Router(); var ctrl=r.Controller<TestController>(null); ctrl.Handles("/foo").Allows("biz").Allows("baz"); Assert.IsTrue(ctrl.Current.AllowedMethods.Any(x=>x=="biz")); Assert.IsTrue(ctrl.Current.AllowedMethods.Any(x=>x=="baz")); }
void before_each() { _subject = new Router(); _handler = new EventForTestingHandler(); _event = new EventForTesting { ID = 6 }; }
internal static HostReport[] Generate(Router router, RouterMetrics routerMetrics) { return router.Select((routeTable, tableIndex) => new HostReport { Host = routeTable.HostPattern, Endpoints = routeTable.Select((ep, epIndex) => new HostReport.Endpoint { Method = ep.Method.ToString(), Route = ep.Route.PathTemplate, CurrentResponseRate = routerMetrics.responseRateCounters[tableIndex][epIndex].GetCurrentRate(), MaxResponseRate = routerMetrics.responseRateCounters[tableIndex][epIndex].MaxRate, Bytes = new HostReport.Endpoint.BytesTransferred { In = routerMetrics.totalRequestBytesIn[tableIndex][epIndex], Out = routerMetrics.totalResponseBytesOut[tableIndex][epIndex] }, StatusCodeCounters = routerMetrics.statusCodesCounters[tableIndex][epIndex].Where(entry => entry.Count > 0) .Select(entry => new HostReport.Endpoint.StatusCodeCounter { StatusCode = entry.Code, Count = entry.Count } ).ToArray(), StatusCodeCountersByHour = routerMetrics.hourlyStatusCodesCounters[tableIndex][epIndex].Select(entry => new HostReport.Endpoint.HourlyStatusCodeCounter { TimeHours = entry.TimeHours, StatusCodeCounters = entry.StatusCodes.Select(kvp => new HostReport.Endpoint.StatusCodeCounter { StatusCode = (int)kvp.Key, Count = kvp.Value } ).ToArray(), } ).ToArray(), HandlerTimes = routerMetrics.handlerTimes[tableIndex][epIndex].GetTimes(0.5f, 0.9f, 0.999f) .Zip(new [] { 50.0f, 90.0f, 99.9f }, (value, percentile) => new HostReport.Endpoint.HandlerTime { Percentile = percentile, Value = value } ).ToArray() } ).ToArray() } ).ToArray(); }
protected void Page_Load(object sender, EventArgs e) { int routerId = Convert.ToInt32(Request.QueryString["RouterID"].ToString()); router = BLLRouter.getRouterByID(routerId)[0]; if (!IsPostBack) { fillData(); } }
void InitRouter() { lock(routerinit) { router=new Router(); var landing=router.Controller((c) => new HomeController(c)); landing.Handles("/").With(x=>x.HomePage()); } }
public AutoRouter(Router processor, Parser argParser, DependencyResolver resolver, bool debug) { m_logger = new CategoryLogger(this); m_processor = processor; m_taskResultLookup = new Dictionary<Type, PropertyInfo>(); m_argParser = argParser; m_resolver = resolver; m_debug = debug; CacheResultProperty(typeof(Task<object>)); }
public void AlsoExecute_Should_Be_Added() { var r=new Router(); var controller=new TestController(new RequestContext(null, r, null, null)); var ctrl=r.Controller(x=>controller); bool calledexecute=false; ctrl.Handles("/foo").With(x=>x.Test()).AlsoExecute(c=>calledexecute=true); bool skip=false; ctrl.Current.Responder(null, ref skip); Assert.IsTrue(calledexecute); }
public void ControllerGetsPopulated() { var router=new Router(); var home=router.Controller(c => new HomeController(c)); home.Handles("/home").With(x=>x.GetHome()); var context=new FakeServerContext(); context.RequestUrl=new Uri("http://foo.bar/home"); context.HttpMethod="get"; router.Execute(context); Assert.AreEqual("mehfoobar", context.WrittenText()); }
public CronshopServer(int dosPeriodInSeconds = 20, int dosThreshold = 20) : base(dosPeriodInSeconds, dosThreshold) { Router = new Router { {"root", "/"}, {"cron", "/cron/{action}/{token}/{id}"}, {"all", "*"}, }; RequestAccepted += IncomingRequestAccepted; }
public override void ConfigureRoutes(Router router) { router.Match("(/:controller(/:action(/:id)))", "default", c => c.Defaults(d => d.Controller("root").Action("index"))) // .SetFilter<BeforeActionFilter>() // .SetFilter<AfterActionFilter>() ; router.Match("/viewcomponents/:controller(/:action(/:id))", c => c.Match("(/:area/:controller(/:action(/:id)))", "viewcomponents", ic => ic.Defaults(d => d.Action("index")))); }
void InitRouter() { lock(routerinit) { router=new Router(); var landing=router.Controller((c) => new LandingController(c)); landing.Handles("/").With(x=>x.Landing()); var bounce=router.Controller(c => new BounceController(c)); bounce.Handles("/bounce/post/{key}").With(x=>x.Post(x.RouteParams["key"])).Allows("POST").Allows("GET").Allows("PUT").Allows("DELETE"); bounce.Handles("/bounce/dequeue/{key}").With(x=>x.Dequeue(x.RouteParams["key"])); bounce.Handles("/bounce/view/{key}").With(x=>x.View(x.RouteParams["key"])); } }
public override void ConfigureRoutes(Router router) { Router.Instance.Match("(/:controller(/:action(/:id)))", "default", c => c.Defaults(d => d.Controller("todo").Action("index"))) .WithActionFilter<TestActionFilter>() .WithAuthorizationFilter<TestAuthFilter>() .WithExceptionFilter<TestExceptionFilter>() ; Router.Instance.Match("/viewcomponents/:controller(/:action(/:id))", c => c.Match("(/:area/:controller(/:action(/:id)))", "viewcomponents", ic => ic.Defaults(d => d.Action("index")))); }
readonly BlockingCollection<IndexedLog> queue; // Single-reader multiple-writer #endregion Fields #region Constructors public RequestLogs(Router router, int capacity) { this.capacity = capacity; queue = new BlockingCollection<IndexedLog>(capacity); drainBuffers = new Queue<Log>[router.Length][]; for (int i=0; i<drainBuffers.Length; i++) { drainBuffers[i] = new Queue<Log>[router[i].Length]; for (int j=0; j<drainBuffers[i].Length; j++) { drainBuffers[i][j] = new Queue<Log>(capacity); } } }
public void DefiningRoute_SimpleParam_1_Node() { const string path = "/:controller"; var router = new Router(); var route = router.Match(path, new DummyHandlerMediator()); Assert.IsNotNull(route); Assert.AreEqual(path, route.Path); Assert.IsNull(route.Name); var nodes = route.RouteNodes; Assert.AreEqual(1, nodes.Length); Assert.IsTrue(nodes[0].IsNamedParam); Assert.AreEqual("/", (nodes[0] as Internal.Term.NamedParam).Item1); Assert.AreEqual("controller", (nodes[0] as Internal.Term.NamedParam).Item2); }
public void DefiningRoute_SimpleLiteral_1_Node() { const string path = "/something"; var router = new Router(); var route = router.Match(path, new DummyHandlerMediator()); Assert.IsNotNull(route); Assert.AreEqual(path, route.Path); Assert.IsNull(route.Name); var nodes = route.RouteNodes; Assert.AreEqual(1, nodes.Length); Assert.IsTrue(nodes[0].IsLiteral); Assert.AreEqual("/something", (nodes[0] as Internal.Term.Literal).Item); }
public void FromRoute_Should_Populate_Model() { var r = new Router(); var ctrl = r.Controller(c => new TestController(c)); var foo = ctrl.Handles("/foo"). UsingModel(c => new TestModel()). FromRoute(). With((c, m) => c.TestWithModel(m)); bool skip = false; var routeparams=new ParameterDictionary(); routeparams.Add("Foo", new string[]{"bar"}); var view=foo.Current.Responder( new RequestContext(null, null, null, routeparams), ref skip); Assert.AreEqual("foobar", view.ToString()); }
public static void Main(string[] args) { /* ForeignDevicePortOptions options = new ForeignDevicePortOptions() { PortId = 1, BbmdHost = "<bbmd-ip-here>", BbmdPort = 47808, LocalHost = "0.0.0.0", LocalPort = 47808, RegistrationInterval = TimeSpan.FromSeconds(30) }; */ EthernetPortOptions ethOptions = new EthernetPortOptions() { PortId = 1 }; PortManagerOptions portMgrOptions = new PortManagerOptions(); RouterOptions routerOpts = new RouterOptions(); routerOpts.PortNetworkMappings.Add(new KeyValuePair<byte, ushort>(1, 0)); HostOptions hostOpts = new HostOptions(); DeviceFinderOptions finderOpts = new DeviceFinderOptions(); //using (ForeignDevicePort port = new ForeignDevicePort(options)) using (EthernetPort port = new EthernetPort(ethOptions)) using (PortManager manager = new PortManager(portMgrOptions)) using (Router router = new Router(routerOpts)) using (Host host = new Host(hostOpts)) using (DeviceFinder finder = new DeviceFinder(finderOpts)) using (Session session = new Session(port, manager, router, host, finder)) { var client = new BACnet.Client.Client(host); // as long as there is at least 1 new devices found every 10 seconds, // for each found device, read that devices name and print it to the console finder.Timeout(TimeSpan.FromSeconds(10)) .Catch(Observable.Empty<DeviceTableEntry>()) .ForEachAsync(entry => { Console.WriteLine(entry.Instance); }) .Wait(); } }
public void Start(Router router) { if (lifeCycleToken.Start()) { this.router = router; this.router.Start(); var getContextLoopThread = new Thread(GetContextLoop) { Priority = ThreadPriority.AboveNormal, IsBackground = false, Name = name }; getContextLoopThread.Start(); } }
public void Allows_ThrowsNotSupportedForBadType() { var r=new Router(); var ctrl=r.Controller<TestController>(null); var tmp=ctrl.Handles("/foo"); ctrl.Current.AllowedMethods=new ReadOnlyCollection<string>(new List<string>()); bool threw=false; try { tmp.Allows("biz"); } catch(NotSupportedException e) { threw=true; } Assert.IsTrue(threw); }
public void Execute_DefaultsToOnlyGetHttpMethod() { var router=new Router(); var r=new Route { Responder=(RequestContext c, ref bool skip) => new WrapperView("foo"), AllowedMethods=null, Pattern=new FakePatternMatcher("/foo") }; router.AddRoute(r); var context=new FakeServerContext(); context.RequestUrl=new Uri("http://meh.com/foo"); context.HttpMethod="post"; Assert.IsFalse(router.Execute(context)); context.HttpMethod="get"; Assert.IsTrue(router.Execute(context)); }
public void Start(Router router) { if (lifeCycleToken.Start()) { timer.Start(); this.router = router; this.router.Start(); var connectionLoopThread = new Thread(ConnectionLoop) { Priority = ThreadPriority.AboveNormal, IsBackground = false, Name = name }; connectionLoopThread.Start(); } }
public void Execute_ChecksValidatorsForBadParameters() { var router=new Router(); var parameters = new ParameterDictionary(); parameters.Add("id", "1234"); var badvalidators = new List<RouteParamsMustMatch>(); badvalidators.Add(x => x["id"] == "xxx"); var bad=new Route { Responder=(RequestContext c, ref bool skip) => new WrapperView("bad"), Pattern=new FakePatternMatcher("/foo/1234", parameters), ParameterValidators=badvalidators }; router.AddRoute(bad); var context=new FakeServerContext(); context.RequestUrl=new Uri("http://meh.com/foo/1234"); context.HttpMethod="get"; Assert.IsFalse(router.Execute(context)); }
public void RoutingSerializationCHSortedRoutingComparisonTest() { const string embeddedString = "OsmSharp.Test.Unittests.test_network_real1.osm"; // creates a new interpreter. var interpreter = new OsmRoutingInterpreter(); // do the data processing. var original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource( Assembly.GetExecutingAssembly() .GetManifestResourceStream(embeddedString)), interpreter, Vehicle.Car); // create serializer. var routingSerializer = new OsmSharp.Routing.CH.Serialization.Sorted.CHEdgeDataDataSourceSerializer(true); // serialize/deserialize. TagsCollectionBase metaData = new TagsCollection(); metaData.Add("some_key", "some_value"); byte[] byteArray; using (var stream = new MemoryStream()) { try { routingSerializer.Serialize(stream, original, metaData); byteArray = stream.ToArray(); } catch (Exception) { if (Debugger.IsAttached) { Debugger.Break(); } throw; } } IBasicRouterDataSource <CHEdgeData> deserializedVersion = routingSerializer.Deserialize(new MemoryStream(byteArray), out metaData); Assert.AreEqual(original.TagsIndex.Get(0), deserializedVersion.TagsIndex.Get(0)); Assert.IsTrue(deserializedVersion.SupportsProfile(Vehicle.Car)); Assert.IsFalse(deserializedVersion.SupportsProfile(Vehicle.Bicycle)); // create reference router. original = CHEdgeGraphOsmStreamTarget.Preprocess(new XmlOsmStreamSource( Assembly.GetExecutingAssembly() .GetManifestResourceStream(embeddedString)), interpreter, Vehicle.Car); var basicRouterOriginal = new CHRouter(); Router referenceRouter = Router.CreateCHFrom( original, basicRouterOriginal, interpreter); // try to do some routing on the deserialized version. var basicRouter = new CHRouter(); Router router = Router.CreateCHFrom( deserializedVersion, basicRouter, interpreter); // loop over all nodes and resolve their locations. var resolvedReference = new RouterPoint[original.VertexCount]; var resolved = new RouterPoint[original.VertexCount]; for (uint idx = 1; idx < original.VertexCount + 1; idx++) { // resolve each vertex. float latitude, longitude; if (original.GetVertex(idx, out latitude, out longitude)) { resolvedReference[idx - 1] = referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude)); resolved[idx - 1] = router.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude)); } Assert.IsNotNull(resolvedReference[idx - 1]); Assert.IsNotNull(resolved[idx - 1]); Assert.AreEqual(resolvedReference[idx - 1].Location.Latitude, resolved[idx - 1].Location.Latitude, 0.0001); Assert.AreEqual(resolvedReference[idx - 1].Location.Longitude, resolved[idx - 1].Location.Longitude, 0.0001); } // // check all the routes having the same weight(s). // for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++) // { // for (int toIdx = 0; toIdx < resolved.Length; toIdx++) // { // OsmSharpRoute referenceRoute = referenceRouter.Calculate(VehicleEnum.Car, // resolvedReference[fromIdx], resolvedReference[toIdx]); // OsmSharpRoute route = router.Calculate(VehicleEnum.Car, // resolved[fromIdx], resolved[toIdx]); // Assert.IsNotNull(referenceRoute); // Assert.IsNotNull(route); // //Assert.AreEqual(referenceRoute.TotalDistance, route.TotalDistance, 0.1); // // TODO: meta data is missing in some CH routing; see issue // //Assert.AreEqual(reference_route.TotalTime, route.TotalTime, 0.0001); // } // } }
public async Task DoStuff() { var watch = new Stopwatch(); watch.Start(); var router = new Router(); var eventstore = new EventStore(router); IRepository rep = new Repository(eventstore); var cache = new MemoryCache(); //rep = new CacheRepository(rep, eventstore, cache); var session = new Session(rep); for (var index = 0; index < 15_000; index++) { await session.Add(new Employee(Guid.NewGuid())); } await session.Commit(); for (var i = 0; i < 15_000; i++) { await session.Add(new Employee(Guid.NewGuid())); await session.Commit(); } for (var i = 0; i < 15_000; i++) { var rep2 = new Repository(eventstore); var session2 = new Session(rep2); await session2.Add(new Employee(Guid.NewGuid())); await session2.Commit(); } Parallel.For(0, 300, async i => { var id2 = Guid.NewGuid(); var employee = new Employee(id2); var session2 = new Session(rep); await session2.Add(employee); await session2.Commit(); for (int j = 0; j < 100; j++) { var e = await session2.Get <Employee>(id2); for (int k = 0; k < 10; k++) { e.GiveRaise(10); } await session2.Commit(); } }); var id = Guid.NewGuid(); await session.Add(new Employee(id)); await session.Commit(); for (var i = 0; i < 5_000; i++) { var employee = await session.Get <Employee>(id); employee.GiveRaise(10); await session.Commit(); } var registrar = new RouteRegistrar(new ServiceLocator(rep, router)); registrar.RegisterInAssemblyOf(typeof(EmployeeGiveRaise)); var num = 3000; var tasks = new Task[num]; for (int i = 0; i < num; i++) { tasks[i] = router.Send(new EmployeeGiveRaise(id, 10)); } await Task.WhenAll(tasks); Parallel.For(0, 3000, async i => { var id2 = Guid.NewGuid(); var employee = new Employee(id2); var session2 = new Session(rep); await session2.Add(employee); await session2.Commit(); for (int j = 0; j < 100; j++) { await router.Send(new EmployeeGiveRaise(id2, 10)); } }); watch.Stop(); Console.WriteLine($"{eventstore.Count:##,###} events saved"); Console.WriteLine($"{eventstore.Read:##,###} events read from eventstore"); Console.WriteLine($"{Employee.AppliedEvents:##,###} events applied"); Console.WriteLine($"{watch.ElapsedMilliseconds:##,###} ms"); Console.WriteLine($"{Employee.AppliedEvents / watch.ElapsedMilliseconds:##,###} events handled per ms"); }
public PID CreateActor(Func <IActor> actorProducer, string id, string address = default, IContext parent = default, int routing = 0) { if (routing == 0) { return(GetOrCreateActor(id, address, parent, () => CreateActor(typeof(object), id, parent, () => WithGuardiad(Props.FromProducer(actorProducer), parent)))); } return(GetOrCreateActor(id, address, parent, () => CreateActor(typeof(object), id, parent, () => Router.NewRoundRobinPool(WithChildGuardiad(Props.FromProducer(actorProducer)), routing)))); }
public RestServer(int port) { httpServer = new HttpServer(port); router = new Router(); httpServer.RequestHandler += HttpServer_RequestHandler; }
private void OpenEventViewPage(object sender, TappedRoutedEventArgs e) { var eventId = ((Button)sender).Tag; Router.GoToPage <EventShow>(eventId); }
private void SendDataNotifyCharaData(NecClient client) { IBuffer res3 = BufferProvider.Provide(); //sub_read_int32 res3.WriteInt32(1); //sub_481AA0 res3.WriteCString("soulname"); //sub_481AA0 res3.WriteCString("charaname"); //sub_484420 res3.WriteFloat(1); res3.WriteFloat(2); res3.WriteFloat(3); res3.WriteByte(1); //sub_read_int32 res3.WriteInt32(1); //sub_483420 res3.WriteInt32(1); //sub_483470 res3.WriteInt16(1); //sub_483420 int numEntries = 19; res3.WriteInt32(numEntries);//influences a loop that needs to be under 19 //sub_483660 for (int i = 0; i < numEntries; i++) { res3.WriteInt32(i); } //sub_483420 numEntries = 19; res3.WriteInt32(numEntries);//influences a loop that needs to be under 19 //sub_4948C0 for (int i = 0; i < numEntries; i++) { for (int j = 0; j < numEntries; j++) { res3.WriteInt32(j); res3.WriteByte((byte)j); res3.WriteByte((byte)(j + 1)); res3.WriteByte((byte)(j + 2)); } res3.WriteByte(1); res3.WriteByte(2); res3.WriteByte(1);//Bool res3.WriteByte(3); res3.WriteByte(4); res3.WriteByte(5); res3.WriteByte(6); res3.WriteByte(7); } //sub_483420 numEntries = 19; res3.WriteInt32(numEntries);//influences a loop that needs to be under 19 //sub_483420 for (int i = 0; i < numEntries; i++) { res3.WriteInt32(i); } //sub_4835C0 res3.WriteInt32(3); //sub_484660 res3.WriteInt32(1); res3.WriteInt32(1); res3.WriteByte(2); res3.WriteByte(3); res3.WriteByte(4); //sub_483420 res3.WriteInt32(1); //sub_4837C0 res3.WriteInt32(1); //sub_read_byte res3.WriteByte(5); //sub_494890 res3.WriteByte(1);//Bool //sub_4835E0 res3.WriteInt32(1); //sub_483920 res3.WriteInt32(1); //sub_483440 res3.WriteInt16(2); //sub_read_byte res3.WriteByte(6); //sub_read_byte res3.WriteByte(7); //sub_read_int_32 res3.WriteInt32(1); //sub_483580 res3.WriteInt32(1); //sub_483420 numEntries = 128; res3.WriteInt32(numEntries);//influences a loop that needs to be under 128 //sub_485A70 for (int i = 0; i < numEntries; i++) { res3.WriteInt32(i); res3.WriteInt32(i + 1); res3.WriteInt32(i + 2); } //sub_481AA0 res3.WriteCString("nofuckingideawhatthisis"); Router.Send(client, (ushort)AreaPacketId.revc_data_notify_chara_data, res3); }
public override void Execute(string[] command, NecClient client, ChatMessage message, List <ChatResponse> responses) { // Check the list to know what recv do // recv_data_notify_eventlink spawn the aura for changing area for event // recv_data_notify_maplink spawn the aura for changing map // recv_data_notify_goldobject_data permit to get item or gold? // recv_data_notify_eo_data permit to get the effect, of spell, and other things // recv_data_notify_ggate_stone_data permit to acess object or display name of object (when you acess object, it's like npc, you can have discussion and take choice), // recv_talkring_create_masterring_r send a message in the shop that say you create a Master ring // recv_sixthsense_trap_notify icon that avertise if a trap is around you // recv_event_system_message Show system message on the middle of the screen // Recv event_message Permit to get dialogue message without name // Recv_event_message_no_object permit to get the dialogue, with name, comment, and 1 other things that i don't know // recv_event_select_exec_winpos open some windows with text, need recv_event_select_push to permit to get the choice like the other beelow ? // recv_event_select_exec put it before the recv_event_select_push!! The recv_event_select_push, put the choice, the recv_event_select_exec take the choice in the window, and put a title // recv_event_request_int open a pin code ? //recv_0xE8B9 = 0xE8B9, IBuffer res = BufferProvider.Provide(); res.WriteUInt32(client.Character.InstanceId); res.WriteFloat(4); Router.Send(client, 0xE8B9, res, ServerType.Area); //-------------------------------------------------------------- //recv_self_dragon_pos_notify = 0x6FB2; /*IBuffer res = BufferProvider.Provide(); * res.WriteInt32(client.Character.InstanceId); //Works with character instance ID, might be able to use its own ID. * * res.WriteFloat(client.Character.X); // X * res.WriteFloat(client.Character.Y); // Y * res.WriteFloat(client.Character.Z); // Z * //Location on minimap where the icon for a guardian statue is. * * res.WriteByte(1);//Bool? Shows a minimap icon if 1, doesn't if any other value. * Router.Send(client, 0x6FB2, res, ServerType.Area); * * //-------------------------------------------------------------- * //recv_quest_hint = 0x505E, * /*IBuffer res = BufferProvider.Provide(); * res.WriteInt32(client.Character.InstanceId); // Quester's instance id * * res.WriteInt32(0); // * //I think the above int32 is for quest text as our pop-up is missing text. * res.WriteFloat(client.Character.X); // X * res.WriteFloat(client.Character.Y); // Y * res.WriteFloat(client.Character.Z); // Z * //Location on minimap where the icon should show for a hint. * * res.WriteInt32(j++); //Hint "instance" ID, increasing this as it goes on will make it more show up instead of updating one. * Router.Send(client, (ushort)AreaPacketId.recv_quest_hint, res, ServerType.Area); * //-------------------------------------------------------------- * * //recv_charabody_self_notify_abyss_stead_pos = 0x679B, * /*IBuffer res = BufferProvider.Provide(); * res.WriteFloat(client.Character.X); * res.WriteFloat(client.Character.Y); * res.WriteFloat(client.Character.Z); * Router.Send(client, (ushort)AreaPacketId.recv_charabody_self_notify_abyss_stead_pos, res, ServerType.Area);* * //-------------------------------------------------------------- * * //recv_monster_hate_on = 0x5C47 * /*IBuffer res = BufferProvider.Provide(); * res.WriteInt32(0x38);//Monster instance ID, has to be a monster or causes a crash(the game knows it isn't if it isn't) * res.WriteInt32(client.Character.InstanceId);//Player/Character instance ID * Router.Send(client, (ushort)AreaPacketId.recv_monster_hate_on, res, ServerType.Area); * //Causes the monster fight music to go off * //-------------------------------------------------------------- * * /*IBuffer res = BufferProvider.Provide(); // Show a panel "The scale will be available in" * res.WriteInt32(90); // Time before the "scale" be available * Router.Send(client, (ushort) AreaPacketId.recv_charabody_self_warpdragon_penalty, res, ServerType.Area); * * //-------------------------------------------------------------- * * /*IBuffer res1 = BufferProvider.Provide(); // Message that signal a player stole an another player body * res1.WriteByte(1); * res1.WriteByte(0); // ?? * res1.WriteInt16(0); // ?? * * res1.WriteInt16(80); // Pieces that the player stoles * res1.WriteCString("PoorSoulPlayer"); // Length 0x31 // Name of stolen player ? * res1.WriteCString($"{client.Character.Name}"); // Length 0x5B // Name of player * Router.Send(client, (ushort)AreaPacketId.recv_charabody_notify_loot_item, res1, ServerType.Area); * * -------------------------------------------------------------- * * /* IBuffer res2 = BufferProvider.Provide(); // "A new help item has added, and open the help menu" * res2.WriteInt32(0); * Router.Send(client, (ushort)AreaPacketId.recv_charabody_notify_loot_start2, res2, ServerType.Area); * * /*IBuffer res2 = BufferProvider.Provide(); * res2.WriteInt32(client.Character.InstanceId); * res2.WriteInt32(4); //4 = chara dissapear, is dead ??? * res2.WriteInt32(10); * Router.Send(client, (ushort)AreaPacketId.recv_charabody_notify_deadstate, res2, ServerType.Area); * * ------------------------------------------------------------ * * /* IBuffer res = BufferProvider.Provide(); // It's the aura portal for event * res.WriteInt32(0); // ID * * res.WriteFloat(client.Character.X); //x * res.WriteFloat(client.Character.Y + 50); //y * res.WriteFloat(client.Character.Z + 2); //z * * res.WriteByte(180); * * res.WriteFloat(client.Character.Y + 50); // Size * res.WriteFloat(5); // distance * * res.WriteInt32(4); // Color * Router.Send(client, (ushort) AreaPacketId.recv_data_notify_eventlink, res, ServerType.Area); * * ---------------------------------------------------------- * * IBuffer res1 = BufferProvider.Provide(); // it's the aura portal for map * res1.WriteInt32(2); // ID * * * res1.WriteFloat(client.Character.X); //x * res1.WriteFloat(client.Character.Y); //y * res1.WriteFloat(client.Character.Z + 2); //z * res1.WriteByte(180); // offset * * res1.WriteFloat(1000); // Size * res1.WriteFloat(100); // distance * * res1.WriteInt32(0); // Type of aura 0 to 5, crash above 5 * Router.Send(client, (ushort) AreaPacketId.recv_data_notify_maplink, res1, ServerType.Area); * * ---------------------------------------------------------- * * /* IBuffer res = BufferProvider.Provide(); * res.WriteInt32(1); // ID * * res.WriteFloat(client.Character.X);//X of the float text * res.WriteFloat(client.Character.Y + 50);//Y of the float text * res.WriteFloat(client.Character.Z + 120);//Z of the float text * * res.WriteFloat(client.Character.X);//X of the float text * res.WriteFloat(client.Character.Y + 50);//Y of the float text * res.WriteFloat(client.Character.Z + 120);//Z of the float text * res.WriteByte(180); // view offest ? * * res.WriteInt32(0); * res.WriteInt32(0); * res.WriteInt32(0); * * res.WriteInt32(0); // Jump item animation * Router.Send(client, (ushort)AreaPacketId.recv_data_notify_goldobject_data, res, ServerType.Area); * * ------------------------------------------------------------ * * /*IBuffer res = BufferProvider.Provide(); * res.WriteInt32(0);// 0 or 1, other = crash * res.WriteInt32(1);// ?? * res.WriteByte(1);// 0 = Text, 1 = F to examine , other = dissapear the both, text and examine, but not the effect ? * res.WriteCString("a");//"0x5B" first sentence of the text * res.WriteCString("b");//"0x5B" second sentence * res.WriteFloat(client.Character.X);//X of the float text * res.WriteFloat(client.Character.Y +50);//Y of the float text * res.WriteFloat(client.Character.Z + 120);//Z of the float text * res.WriteByte(180);// view offset * res.WriteInt32(2016001);// 0 = permit to see the examine and text but no models, to see models refer to the model_common.csv * * res.WriteInt16(100);// size of the object * * * res.WriteInt32(0);// 0 = collision, 1 = no collision ?(maybe), when you appear the things lool like object * * res.WriteInt32(2);//0= no effect color appear, blue = cleared, yellow = puzzle, red = ready for fight * Router.Send(client, (ushort)AreaPacketId.recv_data_notify_ggate_stone_data, res, ServerType.Area); * * ----------------------------------------------------------- * * * /* IBuffer res = BufferProvider.Provide(); * res.WriteInt32(client.Character.InstanceId); * res.WriteInt32(2); * res.WriteCString("ToBeFound"); // find max size * res.WriteCString("ToBeFound"); // find max size * res.WriteFloat(client.Character.X); * res.WriteFloat(client.Character.Y); * res.WriteFloat(client.Character.Z); * res.WriteByte(180); * res.WriteInt32(0); * * int numEntries = 19; * res.WriteInt32(numEntries);//less than or equal to 19 * for (int i = 0; i < numEntries; i++) * res.WriteInt32(0); * * numEntries = 19; * res.WriteInt32(0); * for (int i = 0; i < numEntries; i++) * { * res.WriteInt32(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteInt32(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0); * * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0);//bool * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0); * } * * numEntries = 19; * res.WriteInt32(0); * for (int i = 0; i < numEntries; i++) * { * res.WriteInt32(0); * } * * res.WriteInt32(0); * res.WriteInt32(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteByte(0); * res.WriteInt32(0); * res.WriteInt32(0); * res.WriteInt32(0); * res.WriteInt32(0); * res.WriteByte(0); * res.WriteByte(0);//bool * res.WriteInt32(0); * Router.Send(client.Map, (ushort)AreaPacketId.recv_data_notify_charabody_data, res, ServerType.Area); * * * /* * IBuffer res0 = BufferProvider.Provide(); * res0.WriteInt32(0); //1 = cinematic, 0 Just start the event without cinematic * res0.WriteByte(0); * * Router.Send(client, (ushort)AreaPacketId.recv_event_start, res0); */ /* IBuffer res = BufferProvider.Provide(); * res.WriteInt16(2); * res.WriteByte(1); * res.WriteInt32(1); * int numEntries = 0xA; * res.WriteInt32(numEntries);// less than or equal to 0xA * for (int i = 0; i < numEntries; i++) * { * res.WriteByte(1); * res.WriteInt32(1); * res.WriteFixedString("./interface/premiumservice/icon_%06d.dds", 0x19); * } * numEntries = 0x64; * res.WriteInt32(numEntries);//less than or equal to 0x64 * for (int i = 0; i < numEntries; i++) * { * res.WriteByte(1); * res.WriteFixedString("./interface/premiumservice/icon_%06d.dds", 0x1F); * } * Router.Send(client.Map, (ushort)AreaPacketId.recv_cash_shop_notify_open, res, ServerType.Area); /* * * * * /* IBuffer res = BufferProvider.Provide(); * res.WriteCString($"{client.Soul.Name}"); * res.WriteCString($"{client.Character.Name}"); * Router.Send(client.Map, (ushort)AreaPacketId.recv_charabody_self_salvage_notify, res, ServerType.Area); */ //recv_data_notify_maplink /* IBuffer res = BufferProvider.Provide(); * res.WriteCString("ababab"); // Length 0xC01 * Router.Send(client, (ushort)AreaPacketId.recv_event_system_message, res, ServerType.Area); show system message on middle of the screen. * * IBuffer res0 = BufferProvider.Provide(); * res0.WriteInt32(client.Character.InstanceId); * Router.Send(client, (ushort)AreaPacketId.recv_gimmick_access_object_r, res0); * * IBuffer res1 = BufferProvider.Provide(); * res1.WriteInt32(105005); * * res1.WriteInt32(105005); * * res1.WriteInt32(105005); * Router.Send(client, (ushort)AreaPacketId.recv_gimmick_access_object_notify, res1); Maybe permit to spawn door and chair on the map ? * * * IBuffer res = BufferProvider.Provide(); * res.WriteInt32(105005); * res.WriteFloat(-1175); * res.WriteFloat(422); * res.WriteFloat(-0); * res.WriteByte(1); * res.WriteInt32(105005); * res.WriteInt32(105005); * * Router.Send(client, (ushort)AreaPacketId.recv_data_notify_gimmick_data, res, ServerType.Area); * * * IBuffer res2 = BufferProvider.Provide(); * res2.WriteInt32(105005); * res2.WriteInt32(105005); * Router.Send(client, (ushort)AreaPacketId.recv_gimmick_state_update, res2); * * /* IBuffer res = BufferProvider.Provide(); * res.WriteByte(1); * res.WriteByte(0); * res.WriteByte(0); * * res.WriteCString("Hello My name is patrick"); * * Router.Send(client, (ushort)AreaPacketId.recv_dbg_message, res, ServerType.Area); * / Display message in the chat (only this function ?) Maybe message for equiped and unequiped item ? and use potion ? * * * * * /* IBuffer res2 = BufferProvider.Provide(); * * res2.WriteInt32(100006); * * res2.WriteByte(0); // bool * Router.Send(client, (ushort)AreaPacketId.recv_event_select_ready, res2); * * IBuffer res0 = BufferProvider.Provide(); * res0.WriteCString("Cinematic test !"); // find max size Text display at the top of the screen * res0.WriteInt32(100006); * Router.Send(client, (ushort)AreaPacketId.recv_event_show_board_start, res0); */ /* IBuffer res3 = BufferProvider.Provide(); * res3.WriteInt32(0); * Router.Send(client, (ushort)AreaPacketId.recv_event_change_type, res3); */ }
private void CancelClick(object sender, TappedRoutedEventArgs e) { Router.GoBack(); }
public TestSource(Router router) : base(router) { this.closed = new AtomicBoolean(false); this.cts = new CancellationTokenSource(); }
/// <summary> /// Returns null if calculation fails /// </summary> /// <param name="router"></param> /// <param name="profile"></param> /// <param name=""></param> /// <returns></returns> public void GetRoute_Recursive(Routingprofile profile, List <Geocache> AllGeocaches, Coordinate Startpoint, Coordinate Endpoint, List <Geocache> GeocachesToInclude) { Fileoperations.Routerlog.AddMainSection("Started new Routing"); /// <summary> /// Holds all information on the route. /// </summary> RouteData CompleteRouteData = new RouteData(); RouterPoint Startpoint_RP; RouterPoint Endpoint_RP; Route InitialRoute; List <Geocache> GeocachesNotAlreadyUsed = new List <Geocache>(); CompleteRouteData.Profile = profile; #region Create Routers if (Program.RouterDB.IsEmpty) { MessageBox.Show("Import or set RouterDB before creating route!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); Application.UseWaitCursor = false; return; } //One for every thread Router1 = new Router(Program.RouterDB); Router2 = new Router(Program.RouterDB); #endregion GeocachesNotAlreadyUsed = RemoveGeocachesWithNegativePoints(AllGeocaches); #region Calculate Initial route try { Startpoint_RP = Router1.Resolve(CompleteRouteData.Profile.ItineroProfile.profile, Startpoint, 100F); } catch (Itinero.Exceptions.ResolveFailedException) { MessageBox.Show("Please select a Startingpoint close to a road"); Application.UseWaitCursor = false; return; } try { Endpoint_RP = Router1.Resolve(CompleteRouteData.Profile.ItineroProfile.profile, Endpoint, 100F); } catch (Itinero.Exceptions.ResolveFailedException) { MessageBox.Show("Please select an Endpoint close to a road"); Application.UseWaitCursor = false; return; } //Calculate initial Route try { InitialRoute = Router1.Calculate(CompleteRouteData.Profile.ItineroProfile.profile, Startpoint_RP, Endpoint_RP); } catch (Itinero.Exceptions.RouteNotFoundException) { MessageBox.Show("Can't calculate a route between start and endpoint. Please change your selection"); Application.UseWaitCursor = false; return; } CompleteRouteData.TotalDistance = InitialRoute.TotalDistance; CompleteRouteData.TotalTime = InitialRoute.TotalTime; //Empty list as no resolving happenend yet CompleteRouteData.partialRoutes.Add(new PartialRoute(InitialRoute, new List <GeocacheRoutingInformation>())); Fileoperations.Routerlog.AddMainInformation("Calculated Initial Route"); Fileoperations.Routerlog.AddSubInformation("Length:" + InitialRoute.TotalDistance); Fileoperations.Routerlog.AddSubInformation("Time:" + InitialRoute.TotalTime); DisplayPreliminaryRoute(CompleteRouteData); #endregion #region ForceInclude Program.MainWindow.UpdateStatus("Starting adding Geocaches set as ForceInclude", 10); AddGeocachesToRoute(CompleteRouteData, GeocachesToInclude); Fileoperations.Routerlog.AddMainInformation("Adding Geocaches the user selected done"); Fileoperations.Routerlog.AddSubInformation("Length: " + CompleteRouteData.TotalDistance); Fileoperations.Routerlog.AddSubInformation("Time: " + CompleteRouteData.TotalTime); Fileoperations.Routerlog.AddSubInformation("Geocaches on Route: " + CompleteRouteData.GeocachesOnRoute().Count); Fileoperations.Routerlog.AddSubInformation("Points collected: " + CompleteRouteData.TotalPoints); DisplayPreliminaryRoute(CompleteRouteData); #endregion #region Autotargetselection if (Program.DB.Autotargetselection) { Program.MainWindow.UpdateStatus("Starting Autotargetselection", 20); CompleteRouteData = DirectionDecision(CompleteRouteData, GeocachesNotAlreadyUsed); Fileoperations.Routerlog.AddMainInformation("Autotargetselection done"); Fileoperations.Routerlog.AddSubInformation("Length: " + CompleteRouteData.TotalDistance); Fileoperations.Routerlog.AddSubInformation("Time: " + CompleteRouteData.TotalTime); Fileoperations.Routerlog.AddSubInformation("Geocaches on Route: " + CompleteRouteData.GeocachesOnRoute().Count); Fileoperations.Routerlog.AddSubInformation("Points collected: " + CompleteRouteData.TotalPoints); if (CheckIfIsland()) { Program.RouteCalculationRunning = false; Program.MainWindow.UpdateStatus("Route calculation failed", 100); Application.UseWaitCursor = false; } DisplayPreliminaryRoute(CompleteRouteData); } #endregion #region Resolving Program.MainWindow.UpdateStatus("Starting calculation of geocache positions", 40); CompleteRouteData = ResolveAndAddGeocachesToPartialRoutes(CompleteRouteData, GeocachesNotAlreadyUsed); #endregion #region Filling route Program.MainWindow.UpdateStatus("Started filling route with geocaches", 50); CompleteRouteData = FillRouteWithGeocachesUntilMaxDistanceIsReached(CompleteRouteData); Fileoperations.Routerlog.AddMainInformation("Adding Geocaches that improve rating done"); Fileoperations.Routerlog.AddSubInformation("Length: " + CompleteRouteData.TotalDistance); Fileoperations.Routerlog.AddSubInformation("Time: " + CompleteRouteData.TotalTime); Fileoperations.Routerlog.AddSubInformation("Geocaches on Route: " + CompleteRouteData.GeocachesOnRoute().Count); Fileoperations.Routerlog.AddSubInformation("Points collected: " + CompleteRouteData.TotalPoints); #endregion if (CheckIfIsland()) { Program.RouteCalculationRunning = false; Program.MainWindow.UpdateStatus("Route calculation failed", 100); Application.UseWaitCursor = false; } //TODO Add geocaches that lie directly on route Program.RouteCalculationRunning = false; //To make sure not another preliminary route is displayed Program.MainWindow.AddFinalRoute(CompleteRouteData); Program.MainWindow.UpdateStatus("Route calculation done", 100); Application.UseWaitCursor = false; }
// XML public override void Read(XmlReader reader) { Clear(); string name = null; Enabled = bool.Parse(reader.GetAttribute(XmlTag.Enabled)); while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: { name = reader.Name; if (RemoteRouterData.XmlRoot.Equals(name)) { Router.Read(reader); } break; } case XmlNodeType.Text: { switch (name) { case XmlTag.Id: { Id = reader.Value; break; } case XmlTag.Name: { Name = reader.Value; break; } case XmlTag.GroupImage: { GroupPath = reader.Value; break; } case XmlTag.DownloadFolder: { DownloadFolder = reader.Value; break; } case XmlTag.Folder: { FileData data = new FileData(reader.Value) { Shared = true }; AddFolder(data); break; } } break; } case XmlNodeType.EndElement: { if (XmlRoot.Equals(reader.Name)) { return; } break; } } } }
public Publisher() { router = UnityBuilder.Named("Publisher") .WithTransport <NetMQTransport>(t => t.WithPublisher(TcpAddress.Wildcard(5556))) .Build(); }
private void OpenEventCreatePage(object sender, TappedRoutedEventArgs e) { Router.GoToPage <EventCreate>(); }
protected override void Load(ContainerBuilder builder) { // IMessageConverter<IRoutingMessage> builder.Register(c => new RoutingMessageConverter()) .As <Core.IMessageConverter <IRoutingMessage> >() .SingleInstance(); // IRoutingPerfCounter builder.Register( c => { Routing.PerfCounter = NullRoutingPerfCounter.Instance; return(Routing.PerfCounter); }) .As <IRoutingPerfCounter>() .AutoActivate() .SingleInstance(); // IRoutingUserAnalyticsLogger builder.Register( c => { Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance; return(Routing.UserAnalyticsLogger); }) .As <IRoutingUserAnalyticsLogger>() .AutoActivate() .SingleInstance(); // IRoutingUserMetricLogger builder.Register( c => { Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance; return(Routing.UserMetricLogger); }) .As <IRoutingUserMetricLogger>() .AutoActivate() .SingleInstance(); // IMessageConverter<Message> builder.Register(c => new DeviceClientMessageConverter()) .As <Core.IMessageConverter <Message> >() .SingleInstance(); // IMessageConverter<Twin> builder.Register(c => new TwinMessageConverter()) .As <Core.IMessageConverter <Twin> >() .SingleInstance(); // IMessageConverter<TwinCollection> builder.Register(c => new TwinCollectionMessageConverter()) .As <Core.IMessageConverter <TwinCollection> >() .SingleInstance(); // IMessageConverterProvider builder.Register( c => new MessageConverterProvider( new Dictionary <Type, IMessageConverter>() { { typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() }, { typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() }, { typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() } })) .As <IMessageConverterProvider>() .SingleInstance(); // IDeviceConnectivityManager builder.Register( c => { var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); IDeviceConnectivityManager deviceConnectivityManager = this.experimentalFeatures.DisableConnectivityCheck ? new NullDeviceConnectivityManager() : new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2), edgeHubCredentials.Identity) as IDeviceConnectivityManager; return(deviceConnectivityManager); }) .As <IDeviceConnectivityManager>() .SingleInstance(); // IDeviceClientProvider builder.Register( c => { IClientProvider underlyingClientProvider = new ClientProvider(); IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>()); return(connectivityAwareClientProvider); }) .As <IClientProvider>() .SingleInstance(); // Task<ICloudConnectionProvider> builder.Register( async c => { var productInfoStore = await c.Resolve <Task <IProductInfoStore> >(); var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); var clientProvider = c.Resolve <IClientProvider>(); var tokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubClientAuthTokenProvider"); var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >(); var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); var deviceScopeIdentitiesCacheTask = c.Resolve <Task <IDeviceScopeIdentitiesCache> >(); var proxy = c.Resolve <Option <IWebProxy> >(); IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await deviceScopeIdentitiesCacheTask; ICredentialsCache credentialsCache = await credentialsCacheTask; ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider( messageConverterProvider, this.connectionPoolSize, clientProvider, this.upstreamProtocol, tokenProvider, deviceScopeIdentitiesCache, credentialsCache, edgeHubCredentials.Identity, this.cloudConnectionIdleTimeout, this.closeCloudConnectionOnIdleTimeout, this.operationTimeout, this.useServerHeartbeat, proxy, productInfoStore); return(cloudConnectionProvider); }) .As <Task <ICloudConnectionProvider> >() .SingleInstance(); // IIdentityProvider builder.Register(_ => new IdentityProvider(this.iotHubName)) .As <IIdentityProvider>() .SingleInstance(); // Task<IConnectionManager> builder.Register( async c => { var cloudConnectionProviderTask = c.Resolve <Task <ICloudConnectionProvider> >(); var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >(); var identityProvider = c.Resolve <IIdentityProvider>(); var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>(); ICloudConnectionProvider cloudConnectionProvider = await cloudConnectionProviderTask; ICredentialsCache credentialsCache = await credentialsCacheTask; IConnectionManager connectionManager = new ConnectionManager( cloudConnectionProvider, credentialsCache, identityProvider, deviceConnectivityManager, this.maxConnectedClients); return(connectionManager); }) .As <Task <IConnectionManager> >() .SingleInstance(); // Task<IEndpointFactory> builder.Register( async c => { var messageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(new EndpointFactory(connectionManager, messageConverter, this.edgeDeviceId, this.maxUpstreamBatchSize, this.upstreamFanOutFactor) as IEndpointFactory); }) .As <Task <IEndpointFactory> >() .SingleInstance(); // Task<RouteFactory> builder.Register(async c => new EdgeRouteFactory(await c.Resolve <Task <IEndpointFactory> >()) as RouteFactory) .As <Task <RouteFactory> >() .SingleInstance(); // RouterConfig builder.Register(c => new RouterConfig(Enumerable.Empty <Route>())) .As <RouterConfig>() .SingleInstance(); if (!this.isStoreAndForwardEnabled) { // EndpointExecutorConfig builder.Register( c => { RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1)); TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1); TimeSpan defaultTimeout = TimeSpan.FromSeconds(60); return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true)); }) .As <EndpointExecutorConfig>() .SingleInstance(); // IEndpointExecutorFactory builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>())) .As <IEndpointExecutorFactory>() .SingleInstance(); // Task<Router> builder.Register( async c => { var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>(); var routerConfig = c.Resolve <RouterConfig>(); Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory); return(router); }) .As <Task <Router> >() .SingleInstance(); // Task<ITwinManager> builder.Register( async c => { if (!this.useV1TwinManager) { var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); ITwinManager twinManager = new PassThroughTwinManager(connectionManager, messageConverterProvider); return(twinManager); } else { var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>())); } }) .As <Task <ITwinManager> >() .SingleInstance(); } else { // EndpointExecutorConfig builder.Register( c => { // Endpoint executor config values - // ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default) // Num of retries = int.MaxValue(we want to keep retrying till the message is sent) // Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires) // Timeout - time for which we want for the ack from the endpoint = 30s // TODO - Should the number of retries be tied to the Store and Forward ttl? Not // doing that right now as that value can be changed at runtime, but these settings // cannot. Need to make the number of retries dynamically configurable for that. TimeSpan minWait = TimeSpan.FromSeconds(1); TimeSpan maxWait = TimeSpan.FromSeconds(60); TimeSpan delta = TimeSpan.FromSeconds(1); int retries = int.MaxValue; RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta); TimeSpan timeout = TimeSpan.FromSeconds(30); TimeSpan revivePeriod = TimeSpan.FromSeconds(30); return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod)); }) .As <EndpointExecutorConfig>() .SingleInstance(); // Task<ICheckpointStore> builder.Register( async c => { var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >(); IStoreProvider storeProvider = new StoreProvider(dbStoreProvider); ICheckpointStore checkpointStore = CheckpointStore.Create(storeProvider); return(checkpointStore); }) .As <Task <ICheckpointStore> >() .SingleInstance(); // Task<IMessageStore> builder.Register( async c => { var checkpointStore = await c.Resolve <Task <ICheckpointStore> >(); var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >(); IStoreProvider storeProvider = new StoreProvider(dbStoreProvider); IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, this.storeAndForwardConfiguration.TimeToLive); return(messageStore); }) .As <Task <IMessageStore> >() .SingleInstance(); // Task<IEndpointExecutorFactory> builder.Register( async c => { var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>(); var messageStore = await c.Resolve <Task <IMessageStore> >(); IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore); return(endpointExecutorFactory); }) .As <Task <IEndpointExecutorFactory> >() .SingleInstance(); // Task<Router> builder.Register( async c => { var checkpointStore = await c.Resolve <Task <ICheckpointStore> >(); var routerConfig = c.Resolve <RouterConfig>(); var endpointExecutorFactory = await c.Resolve <Task <IEndpointExecutorFactory> >(); return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore)); }) .As <Task <Router> >() .SingleInstance(); // Task<ITwinManager> builder.Register( async c => { if (this.useV1TwinManager) { var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >(); var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.Some <IStoreProvider>(new StoreProvider(dbStoreProvider)))); } else { var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>(); var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); IEntityStore <string, TwinStoreEntity> entityStore = await this.GetTwinStore(c); IConnectionManager connectionManager = await connectionManagerTask; ITwinManager twinManager = StoringTwinManager.Create( connectionManager, messageConverterProvider, entityStore, deviceConnectivityManager, new ReportedPropertiesValidator(), this.minTwinSyncPeriod, this.reportedPropertiesSyncFrequency); return(twinManager); } }) .As <Task <ITwinManager> >() .SingleInstance(); } // IClientCredentials "EdgeHubCredentials" builder.Register( c => { var identityFactory = c.Resolve <IClientCredentialsFactory>(); IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse( () => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId)); return(edgeHubCredentials); }) .Named <IClientCredentials>("EdgeHubCredentials") .SingleInstance(); // Task<IInvokeMethodHandler> builder.Register( async c => { IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(new InvokeMethodHandler(connectionManager) as IInvokeMethodHandler); }) .As <Task <IInvokeMethodHandler> >() .SingleInstance(); // Task<ISubscriptionProcessor> builder.Register( async c => { var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); if (this.experimentalFeatures.DisableCloudSubscriptions) { return(new LocalSubscriptionProcessor(await connectionManagerTask) as ISubscriptionProcessor); } else { var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >(); var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>(); IConnectionManager connectionManager = await connectionManagerTask; IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask; return(new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager) as ISubscriptionProcessor); } }) .As <Task <ISubscriptionProcessor> >() .SingleInstance(); // Task<IEdgeHub> builder.Register( async c => { var routingMessageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >(); var routerTask = c.Resolve <Task <Router> >(); var twinManagerTask = c.Resolve <Task <ITwinManager> >(); var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >(); var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); var subscriptionProcessorTask = c.Resolve <Task <ISubscriptionProcessor> >(); Router router = await routerTask; ITwinManager twinManager = await twinManagerTask; IConnectionManager connectionManager = await connectionManagerTask; IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask; ISubscriptionProcessor subscriptionProcessor = await subscriptionProcessorTask; IEdgeHub hub = new RoutingEdgeHub( router, routingMessageConverter, connectionManager, twinManager, this.edgeDeviceId, invokeMethodHandler, subscriptionProcessor); return(hub); }) .As <Task <IEdgeHub> >() .SingleInstance(); // Task<ConfigUpdater> builder.Register( async c => { IMessageStore messageStore = this.isStoreAndForwardEnabled ? await c.Resolve <Task <IMessageStore> >() : null; var storageSpaceChecker = c.Resolve <IStorageSpaceChecker>(); var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >(); Router router = await c.Resolve <Task <Router> >(); var twinManagerTask = c.Resolve <Task <ITwinManager> >(); var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >(); var twinManager = await twinManagerTask; var configUpdater = new ConfigUpdater(router, messageStore, this.configUpdateFrequency, storageSpaceChecker); return(configUpdater); }) .As <Task <ConfigUpdater> >() .SingleInstance(); // Task<IConfigSource> builder.Register <Task <IConfigSource> >( async c => { RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >(); if (this.useTwinConfig) { var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >(); var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >(); var twinManagerTask = c.Resolve <Task <ITwinManager> >(); var edgeHubTask = c.Resolve <Task <IEdgeHub> >(); ITwinManager twinManager = await twinManagerTask; IEdgeHub edgeHub = await edgeHubTask; IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >(); var edgeHubConnection = await EdgeHubConnection.Create( edgeHubCredentials.Identity, edgeHub, twinManager, connectionManager, routeFactory, twinCollectionMessageConverter, this.versionInfo, deviceScopeIdentitiesCache); return(new TwinConfigSource(edgeHubConnection, edgeHubCredentials.Identity.Id, this.versionInfo, twinManager, twinMessageConverter, twinCollectionMessageConverter, routeFactory)); } else { return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration)); } }) .As <Task <IConfigSource> >() .SingleInstance(); // Task<IConnectionProvider> builder.Register( async c => { var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); var edgeHubTask = c.Resolve <Task <IEdgeHub> >(); IConnectionManager connectionManager = await connectionManagerTask; IEdgeHub edgeHub = await edgeHubTask; IConnectionProvider connectionProvider = new ConnectionProvider(connectionManager, edgeHub, this.messageAckTimeout); return(connectionProvider); }) .As <Task <IConnectionProvider> >() .SingleInstance(); base.Load(builder); }
private void EditUser(object sender, TappedRoutedEventArgs e) { Router.GoToPage <UserEdit>(this.user.Id); }
/// <summary> /// Initializes a new instance of the <see cref="RoutedViewHost"/> class. /// </summary> /// <exception cref="Exception">You *must* register an IScreen class representing your App's main Screen.</exception> public RoutedViewHost() { this.WhenActivated(new Action <Action <IDisposable> >(d => { bool currentlyPopping = false; bool popToRootPending = false; bool userInstigated = false; d(this.WhenAnyObservable(x => x.Router.NavigationChanged) .Where(_ => Router.NavigationStack.Count == 0) .Select(x => { // Xamarin Forms does not let us completely clear down the navigation stack // instead, we have to delay this request momentarily until we receive the new root view // then, we can insert the new root view first, and then pop to it popToRootPending = true; return(x); }) .Subscribe()); var previousCount = this.WhenAnyObservable(x => x.Router.NavigationChanged).CountChanged().Select(_ => Router.NavigationStack.Count).StartWith(Router.NavigationStack.Count); var currentCount = previousCount.Skip(1); d(Observable.Zip(previousCount, currentCount, (previous, current) => new { Delta = previous - current, Current = current }) .Where(_ => !userInstigated) .Where(x => x.Delta > 0) .SelectMany( async x => { // XF doesn't provide a means of navigating back more than one screen at a time apart from navigating right back to the root page // since we want as sensible an animation as possible, we pop to root if that makes sense. Otherwise, we pop each individual // screen until the delta is made up, animating only the last one var popToRoot = x.Current == 1; currentlyPopping = true; try { if (popToRoot) { await PopToRootAsync(true); } else if (!popToRootPending) { for (var i = 0; i < x.Delta; ++i) { await PopAsync(i == x.Delta - 1); } } } finally { currentlyPopping = false; ((IViewFor)CurrentPage).ViewModel = Router.GetCurrentViewModel(); } return(Unit.Default); }) .Subscribe()); d(this.WhenAnyObservable(x => x.Router.Navigate) .SelectMany(_ => PageForViewModel(Router.GetCurrentViewModel())) .SelectMany(async page => { if (popToRootPending && Navigation.NavigationStack.Count > 0) { Navigation.InsertPageBefore(page, Navigation.NavigationStack[0]); await PopToRootAsync(); } else { bool animated = true; var attribute = page.GetType().GetCustomAttribute <DisableAnimationAttribute>(); if (attribute != null) { animated = false; } await PushAsync(page, animated); } popToRootPending = false; return(page); }) .Subscribe()); var poppingEvent = Observable.FromEventPattern <NavigationEventArgs>(x => Popped += x, x => Popped -= x); // NB: Catch when the user hit back as opposed to the application // requesting Back via NavigateBack d(poppingEvent .Where(_ => !currentlyPopping && Router != null) .Subscribe(_ => { userInstigated = true; try { Router.NavigationStack.RemoveAt(Router.NavigationStack.Count - 1); } finally { userInstigated = false; } ((IViewFor)CurrentPage).ViewModel = Router.GetCurrentViewModel(); })); })); var screen = Locator.Current.GetService <IScreen>(); if (screen == null) { throw new Exception("You *must* register an IScreen class representing your App's main Screen"); } Router = screen.Router; this.WhenAnyValue(x => x.Router) .SelectMany(router => { return(router.NavigationStack.ToObservable() .Select(x => (Page)ViewLocator.Current.ResolveView(x)) .SelectMany(x => PushAsync(x).ToObservable()) .Finally(() => { var vm = router.GetCurrentViewModel(); if (vm == null) { return; } ((IViewFor)CurrentPage).ViewModel = vm; CurrentPage.Title = vm.UrlPathSegment; })); }) .Subscribe(); }
private void SendDataGetSelfCharaData(NecClient client) { IBuffer res = BufferProvider.Provide(); //sub_4953B0 res.WriteInt32(1); res.WriteInt32(1); res.WriteByte(1); res.WriteByte(2); res.WriteByte(3); //sub_484720 res.WriteInt32(1); res.WriteInt32(1); res.WriteInt16(1); res.WriteInt64(1); res.WriteInt64(2); res.WriteInt64(3); res.WriteInt64(4); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteByte(4); for (int i = 0; i < 7; i++) { res.WriteInt16((byte)i); //loop 7x } for (int i = 0; i < 9; i++) { res.WriteInt16((byte)i); //loop 9x } for (int i = 0; i < 9; i++) { res.WriteInt16((byte)i); //loop 9x } for (int i = 0; i < 11; i++) { res.WriteInt16((byte)i); //loop 11x } res.WriteInt64(5); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); //sub_484980 res.WriteInt32(1); res.WriteInt32(1); res.WriteInt32(1); for (int i = 0; i < 7; i++) { res.WriteInt16((byte)i); //loop 7x } for (int i = 0; i < 9; i++) { res.WriteInt16((byte)i); //loop 9x } for (int i = 0; i < 9; i++) { res.WriteInt16((byte)i); //loop 9x } for (int i = 0; i < 11; i++) { res.WriteInt16((byte)i); //loop 11x } //sub_484B00 res.WriteInt32(1); res.WriteInt32(1); res.WriteFixedString("hello", 65); res.WriteInt16(1); //sub_484420 res.WriteFloat(1); res.WriteFloat(2); res.WriteFloat(3); res.WriteByte(5); //sub_read_int32 res.WriteInt32(25); //sub_483420 res.WriteInt32(26); //sub_494AC0 res.WriteByte(6); res.WriteInt32(27); res.WriteInt32(28); res.WriteInt32(29); res.WriteByte(7); res.WriteByte(1);//Bool res.WriteByte(7); res.WriteByte(7); res.WriteByte(7); res.WriteByte(7); //sub_read_3-int16 res.WriteInt16(5); res.WriteInt16(6); res.WriteInt16(7); //sub_4833D0 res.WriteInt64(6); //sub_4833D0 res.WriteInt64(7); //sub_4834A0 res.WriteFixedString("Channel", 97); //sub_4834A0 res.WriteFixedString("QuestDescription?", 385); //sub_494890 res.WriteByte(1);//Bool //sub_4834A0 res.WriteFixedString("ItemDescription?", 385); //sub_494890 res.WriteByte(1);//Bool //sub_483420 int numEntries = 19; res.WriteInt32(numEntries);//has to be less than 19(defines how many int32s to read?) //sub_483660 for (int i = 0; i < numEntries; i++) { res.WriteInt32(-1); } //sub_483420 numEntries = 19; res.WriteInt32(numEntries);//has to be less than 19(i think this defines the next subs #of loops) //sub_4948C0 for (int i = 0; i < numEntries; i++) { for (int j = 0; j < 2; j++) { res.WriteInt32(j); res.WriteByte((byte)j); res.WriteByte((byte)(j + 1)); res.WriteByte((byte)(j + 2)); } res.WriteByte(1); res.WriteByte(2); res.WriteByte(1);//Bool res.WriteByte(3); res.WriteByte(4); res.WriteByte(5); res.WriteByte(6); res.WriteByte(7); } //sub_483420 numEntries = 19;//influences a loop that needs to be under 19 res.WriteInt32(numEntries); //sub_483420 for (int i = 0; i < numEntries; i++) { res.WriteInt32(-1); } //sub_483420 numEntries = 128; res.WriteInt32(numEntries);//has to be less than 128 //sub_485A70 for (int i = 0; i < numEntries; i++) { res.WriteInt32(0); res.WriteInt32(0); res.WriteInt32(0); } Router.Send(client, (ushort)AreaPacketId.recv_data_get_self_chara_data_r, res); }
public void TestSparseRemoval1Routing() { // use one edge definition everywhere. var tagsIndex = new TagsTableCollectionIndex(); var tags = new TagsCollection(new Tag("highway", "residential")); var edge = new LiveEdge(); edge.Forward = true; edge.Tags = tagsIndex.Add(tags); var graph = new MemoryDynamicGraph <LiveEdge>(); uint vertex1 = graph.AddVertex(51.267797f, 4.8013623f); uint vertex2 = graph.AddVertex(51.267702f, 4.8013396f); uint vertex3 = graph.AddVertex(51.267592f, 4.8013024f); graph.AddEdge(vertex1, vertex2, edge, null); graph.AddEdge(vertex2, vertex3, edge, null); graph.AddEdge(vertex3, vertex2, edge, null); // save vertex coordinates for later use. float latitude, longitude; graph.GetVertex(vertex1, out latitude, out longitude); var vertex1Coordinate = new GeoCoordinate(latitude, longitude); graph.GetVertex(vertex2, out latitude, out longitude); var vertex2Coordinate = new GeoCoordinate(latitude, longitude); graph.GetVertex(vertex3, out latitude, out longitude); var vertex3Coordinate = new GeoCoordinate(latitude, longitude); // execute pre-processor. var preProcessor = new LiveEdgePreprocessor(graph); preProcessor.Start(); // create router. var source = new DynamicGraphRouterDataSource <LiveEdge>( graph, tagsIndex); var router = Router.CreateLiveFrom(source, new OsmRoutingInterpreter()); // test some basic routing requests. // 1 -> 3: 1 -> 2 -> 3. var resolved1 = router.Resolve(Vehicle.Car, vertex1Coordinate); var resolved3 = router.Resolve(Vehicle.Car, vertex3Coordinate); var route = router.Calculate(Vehicle.Car, resolved1, resolved3); // verify the simple route result. Assert.IsNotNull(route); Assert.AreEqual(3, route.Segments.Length); Assert.AreEqual(vertex1Coordinate.Latitude, route.Segments[0].Latitude); Assert.AreEqual(vertex1Coordinate.Longitude, route.Segments[0].Longitude); Assert.AreEqual(vertex2Coordinate.Latitude, route.Segments[1].Latitude); Assert.AreEqual(vertex2Coordinate.Longitude, route.Segments[1].Longitude); Assert.AreEqual(vertex3Coordinate.Latitude, route.Segments[2].Latitude); Assert.AreEqual(vertex3Coordinate.Longitude, route.Segments[2].Longitude); // 1 -> 2: 1 -> 2. router = Router.CreateLiveFrom(source, new OsmRoutingInterpreter()); resolved1 = router.Resolve(Vehicle.Car, vertex1Coordinate); var resolved2 = router.Resolve(Vehicle.Car, vertex2Coordinate); route = router.Calculate(Vehicle.Car, resolved1, resolved2); // verify the simple route result. Assert.IsNotNull(route); Assert.AreEqual(2, route.Segments.Length); Assert.AreEqual(vertex1Coordinate.Latitude, route.Segments[0].Latitude); Assert.AreEqual(vertex1Coordinate.Longitude, route.Segments[0].Longitude); Assert.AreEqual(vertex2Coordinate.Latitude, route.Segments[1].Latitude); Assert.AreEqual(vertex2Coordinate.Longitude, route.Segments[1].Longitude); }
/// <summary> /// Returns a new router. /// </summary> /// <param name="data"></param> /// <param name="interpreter"></param> /// <param name="basicRouter"></param> /// <returns></returns> public override Router BuildRouter(IBasicRouterDataSource <CHEdgeData> data, IRoutingInterpreter interpreter, IRoutingAlgorithm <CHEdgeData> basicRouter) { return(Router.CreateCHFrom(data, basicRouter, interpreter)); }
private void btnAddTest_Click(object sender, EventArgs e) { Router.ChangeForm(this, new AddTest()); }
public override IEnumerator ReceivePayload(VisualPayload payload) { if (!SpoofData.GetFirstValue(payload.Data)) { var binsetId = BinsetIdField.GetFirstValue(payload.Data); int foundCsId; List <int> teams; if (binsetId > 0) { var command = new GetBinsetInfoCommand(binsetId); var commandIterator = CommandProcessor.Execute(command); while (commandIterator.MoveNext()) { yield return(null); } switch (command.Type) { case BinsetType.RefPatch: teams = new List <int> { 8 }; break; case BinsetType.Ref: teams = new List <int> { 1, 2, 3, 4, 5, 6, 7, 8 }; break; case BinsetType.Rcs: teams = command.Submissions.Select(s => s.Team).Distinct().OrderBy(v => v).ToList(); break; default: throw new Exception("Unknown binset type!"); } foundCsId = command.CsId; } else { teams = new List <int> { 8 }; foundCsId = -1; } var mut = new MutableObject { { "Teams", teams }, { "CSID", foundCsId } }; InfoTarget.SetValue(mut, payload.Data); } else { InfoTarget.SetValue(new List <int> { 8 }, payload.Data); } var routerIterator = Router.TransmitAll(payload); while (routerIterator.MoveNext()) { yield return(null); } }
/// <summary> /// Initializes a new instance of the <see cref="RoutedViewHost"/> class. /// </summary> /// <exception cref="Exception">You *must* register an IScreen class representing your App's main Screen.</exception> public RoutedViewHost() { this.WhenActivated(disposable => { var currentlyPopping = false; var popToRootPending = false; var userInstigated = false; this.WhenAnyObservable(x => x.Router.NavigationChanged) .Where(_ => Router.NavigationStack.Count == 0) .Select(x => { // Xamarin Forms does not let us completely clear down the navigation stack // instead, we have to delay this request momentarily until we receive the new root view // then, we can insert the new root view first, and then pop to it popToRootPending = true; return(x); }) .Subscribe() .DisposeWith(disposable); Router? .NavigationChanged? .CountChanged() .Select(_ => Router.NavigationStack.Count) .StartWith(Router.NavigationStack.Count) .Buffer(2, 1) .Select(counts => new { Delta = counts[0] - counts[1], Current = counts[1], // cache current viewmodel as it might change if some other Navigation command is executed midway CurrentViewModel = Router.GetCurrentViewModel() }) .Where(_ => !userInstigated) .Where(x => x.Delta > 0) .Select( async x => { // XF doesn't provide a means of navigating back more than one screen at a time apart from navigating right back to the root page // since we want as sensible an animation as possible, we pop to root if that makes sense. Otherwise, we pop each individual // screen until the delta is made up, animating only the last one var popToRoot = x.Current == 1; currentlyPopping = true; try { if (popToRoot) { await PopToRootAsync(true); } else if (!popToRootPending) { for (var i = 0; i < x.Delta; ++i) { await PopAsync(i == x.Delta - 1); } } } finally { currentlyPopping = false; if (CurrentPage is IViewFor page && x.CurrentViewModel is not null) { page.ViewModel = x.CurrentViewModel; } } return(Unit.Default); }) .Concat() .Subscribe() .DisposeWith(disposable); Router? .Navigate .SelectMany(_ => PageForViewModel(Router.GetCurrentViewModel())) .SelectMany(async page => { var animated = true; var attribute = page.GetType().GetCustomAttribute <DisableAnimationAttribute>(); if (attribute is not null) { animated = false; } if (popToRootPending && Navigation.NavigationStack.Count > 0) { Navigation.InsertPageBefore(page, Navigation.NavigationStack[0]); await PopToRootAsync(animated); } else { await PushAsync(page, animated); } popToRootPending = false; return(page); }) .Subscribe() .DisposeWith(disposable); var poppingEvent = Observable.FromEvent <EventHandler <NavigationEventArgs>, Unit>( eventHandler => { void Handler(object?sender, NavigationEventArgs e) => eventHandler(Unit.Default); return(Handler); }, x => Popped += x, x => Popped -= x); // NB: Catch when the user hit back as opposed to the application // requesting Back via NavigateBack poppingEvent .Where(_ => !currentlyPopping && Router is not null) .Subscribe(_ => { userInstigated = true; try { Router?.NavigationStack.RemoveAt(Router.NavigationStack.Count - 1); } finally { userInstigated = false; } var vm = Router?.GetCurrentViewModel(); if (CurrentPage is IViewFor page && vm is not null) { // don't replace view model if vm is null page.ViewModel = vm; } }) .DisposeWith(disposable); }); var screen = Locator.Current.GetService <IScreen>(); if (screen is null) { throw new Exception("You *must* register an IScreen class representing your App's main Screen"); } Router = screen.Router; this.WhenAnyValue(x => x.Router) .SelectMany(router => router !.NavigationStack .ToObservable() .Select(x => (Page)ViewLocator.Current.ResolveView(x) !) .SelectMany(x => PushAsync(x).ToObservable()) .Finally(() => { var vm = router.GetCurrentViewModel(); if (vm is null) { return; } ((IViewFor)CurrentPage).ViewModel = vm; CurrentPage.Title = vm.UrlPathSegment; })) .Subscribe(); }
/// <summary> /// Issue with generation instructions but where streetnames seem to be stripped. /// Some streetnames are missing from the instructions. /// </summary> protected void DoInstructionRegressionTest1() { OsmRoutingInterpreter interpreter = new OsmRoutingInterpreter(); Router router = this.CreateRouter(interpreter, "OsmSharp.Test.Unittests.test_routing_regression1.osm"); // resolve the three points in question. GeoCoordinate point35 = new GeoCoordinate(51.01257, 4.000753); RouterPoint point35resolved = router.Resolve(Vehicle.Car, point35, true); GeoCoordinate point45 = new GeoCoordinate(51.01315, 3.999588); RouterPoint point45resolved = router.Resolve(Vehicle.Car, point45, true); GeoCoordinate point40 = new GeoCoordinate(51.01250, 4.000013); RouterPoint point40resolved = router.Resolve(Vehicle.Car, point40, true); // calculate two smaller routes. Route route3545 = router.Calculate(Vehicle.Car, point35resolved, point45resolved); Route route4540 = router.Calculate(Vehicle.Car, point45resolved, point40resolved); Route route3540concatenated = Route.Concatenate(route3545, route4540, true); Route route3540 = router.Calculate(Vehicle.Car, point35resolved, point40resolved); // check if both routes are equal. Assert.AreEqual(route3540.Segments.Length, route3540concatenated.Segments.Length); for (int idx = 0; idx < route3540.Segments.Length; idx++) { Assert.AreEqual(route3540.Segments[idx].Distance, route3540concatenated.Segments[idx].Distance); Assert.AreEqual(route3540.Segments[idx].Latitude, route3540concatenated.Segments[idx].Latitude); Assert.AreEqual(route3540.Segments[idx].Longitude, route3540concatenated.Segments[idx].Longitude); Assert.AreEqual(route3540.Segments[idx].Time, route3540concatenated.Segments[idx].Time); Assert.AreEqual(route3540.Segments[idx].Type, route3540concatenated.Segments[idx].Type); Assert.AreEqual(route3540.Segments[idx].Name, route3540concatenated.Segments[idx].Name); // something that is allowed to be different in this case! // route3540.Entries[idx].Points != null // // check sidestreets. // if (route3540.Entries[idx].SideStreets != null && // route3540.Entries[idx].SideStreets.Length > 0) // { // check if the sidestreets represent the same information. // for (int metricIdx = 0; metricIdx < route3540concatenated.Entries[idx].SideStreets.Length; metricIdx++) // { // Assert.AreEqual(route3540.Entries[idx].SideStreets[metricIdx].WayName, // route3540concatenated.Entries[idx].SideStreets[metricIdx].WayName); // Assert.AreEqual(route3540.Entries[idx].SideStreets[metricIdx].Latitude, // route3540concatenated.Entries[idx].SideStreets[metricIdx].Latitude); // Assert.AreEqual(route3540.Entries[idx].SideStreets[metricIdx].Longitude, // route3540concatenated.Entries[idx].SideStreets[metricIdx].Longitude); // } // } // else // { // Assert.IsTrue(route3540concatenated.Entries[idx].SideStreets == null || // route3540concatenated.Entries[idx].SideStreets.Length == 0); // } // if (route3540.Entries[idx].Tags != null && // route3540.Entries[idx].Tags.Length > 0) // { // check if the Tags represent the same information. // for (int metricIdx = 0; metricIdx < route3540concatenated.Entries[idx].Tags.Length; metricIdx++) // { // Assert.AreEqual(route3540.Entries[idx].Tags[metricIdx].Key, // route3540concatenated.Entries[idx].Tags[metricIdx].Key); // Assert.AreEqual(route3540.Entries[idx].Tags[metricIdx].Value, // route3540concatenated.Entries[idx].Tags[metricIdx].Value); // } // } // else // { // Assert.IsTrue(route3540concatenated.Entries[idx].Tags == null || // route3540concatenated.Entries[idx].Tags.Length == 0); // } // Assert.AreEqual(route3540.Entries[idx].Distance, route3540concatenated.Entries[idx].Distance); } if (route3540.Tags != null && route3540.Tags.Length > 0) { for (int tagIdx = 0; tagIdx < route3540.Tags.Length; tagIdx++) { if (route3540.Tags[tagIdx].Key != "debug_route") { Assert.AreEqual(route3540.Tags[tagIdx].Key, route3540concatenated.Tags[tagIdx].Key); Assert.AreEqual(route3540.Tags[tagIdx].Value, route3540concatenated.Tags[tagIdx].Value); } } } else { Assert.IsTrue(route3540concatenated.Tags == null || route3540concatenated.Tags.Length == 0); } if (route3540.Metrics != null) { for (int metricIdx = 0; metricIdx < route3540concatenated.Segments.Length; metricIdx++) { Assert.AreEqual(route3540.Metrics[metricIdx].Key, route3540concatenated.Metrics[metricIdx].Key); Assert.AreEqual(route3540.Metrics[metricIdx].Value, route3540concatenated.Metrics[metricIdx].Value); } } else { Assert.IsNull(route3540concatenated.Metrics); } // remove the point in between, the only difference between the regular and the concatenated route. route3540concatenated.Segments[7].Points = null; // create the language generator. var languageGenerator = new LanguageTestGenerator(); // generate the instructions. List <Instruction> instructions = InstructionGenerator.Generate(route3540, interpreter, languageGenerator); List <Instruction> instructionsConcatenated = InstructionGenerator.Generate(route3540concatenated, interpreter, languageGenerator); Assert.AreEqual(instructions.Count, instructionsConcatenated.Count); for (int idx = 0; idx < instructions.Count; idx++) { Assert.AreEqual(instructions[idx].Location.Center, instructionsConcatenated[idx].Location.Center); Assert.AreEqual(instructions[idx].Text, instructionsConcatenated[idx].Text); } }
public BinsetInfoAdapter() { Router.AddSelectionState("Default"); }
private void OpenEventEditPage(object sender, TappedRoutedEventArgs e) { int eventId = (((Button)sender).Tag as int?).Value; Router.GoToPage <EventEdit>(eventId); }
public LoginViewModel(IRouter router = null) { Router = router ?? Locator.Current.GetService <IRouter>(); Login = ReactiveCommand.CreateAsyncTask(async o => await Router.ShowAsync <TodoListViewModel>()); }
/// <summary> /// Called right after the contraction. /// </summary> /// <param name="vertex"></param> /// <param name="edges"></param> void pre_processor_OnAfterContractionEvent(uint vertex, KeyValuePair <uint, CHEdgeData>[] edges) { // create a new CHRouter var router = new CHRouter(); // calculate all the routes between the neighbours of the contracted vertex. foreach (KeyValuePair <uint, CHEdgeData> from in edges) { // initialize the from-list. var fromList = new PathSegmentVisitList(); fromList.UpdateVertex(new PathSegment <long>(from.Key)); // initalize the from dictionary. Dictionary <uint, PathSegment <long> > fromDic = _pathsBeforeContraction[from.Key]; foreach (KeyValuePair <uint, CHEdgeData> to in edges) { // initialize the to-list. var toList = new PathSegmentVisitList(); toList.UpdateVertex(new PathSegment <long>(to.Key)); // calculate the route. PathSegment <long> route = router.Calculate(_data, _interpreter, OsmSharp.Routing.Vehicle.Car, fromList, toList, double.MaxValue); if ((fromDic[to.Key] == null && route != null) || (fromDic[to.Key] != null && route == null) || ((fromDic[to.Key] != null && route != null) && fromDic[to.Key] != route)) { // the route match! Assert.Fail("Routes are different before/after contraction!"); } } } if (_referenceRouter != null) { // do crazy verification! Router chRouter = Router.CreateCHFrom(_data, router, new OsmRoutingInterpreter()); // loop over all nodes and resolve their locations. var resolvedReference = new RouterPoint[_data.VertexCount - 1]; var resolved = new RouterPoint[_data.VertexCount - 1]; for (uint idx = 1; idx < _data.VertexCount; idx++) { // resolve each vertex. float latitude, longitude; if (_data.GetVertex(idx, out latitude, out longitude)) { resolvedReference[idx - 1] = _referenceRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude)); resolved[idx - 1] = chRouter.Resolve(Vehicle.Car, new GeoCoordinate(latitude, longitude)); } Assert.IsNotNull(resolvedReference[idx - 1]); Assert.IsNotNull(resolved[idx - 1]); Assert.AreEqual(resolvedReference[idx - 1].Location.Latitude, resolved[idx - 1].Location.Latitude, 0.0001); Assert.AreEqual(resolvedReference[idx - 1].Location.Longitude, resolved[idx - 1].Location.Longitude, 0.0001); } // limit tests to a fixed number. int maxTestCount = 100; int testEveryOther = (resolved.Length * resolved.Length) / maxTestCount; testEveryOther = System.Math.Max(testEveryOther, 1); // check all the routes having the same weight(s). for (int fromIdx = 0; fromIdx < resolved.Length; fromIdx++) { for (int toIdx = 0; toIdx < resolved.Length; toIdx++) { int testNumber = fromIdx * resolved.Length + toIdx; if (testNumber % testEveryOther == 0) { Route referenceRoute = _referenceRouter.Calculate(Vehicle.Car, resolvedReference[fromIdx], resolvedReference[toIdx]); Route route = chRouter.Calculate(Vehicle.Car, resolved[fromIdx], resolved[toIdx]); if (referenceRoute != null) { Assert.IsNotNull(referenceRoute); Assert.IsNotNull(route); this.CompareRoutes(referenceRoute, route); } } } } } }
public ServiceLocator(IRepository repository, Router bus) { _repository = repository; _bus = bus; }
public override void OnStart(Router router, GameBase game, System.Collections.Generic.Dictionary <string, object> args) { game.StartCoroutine(Main(game)); }
private void Awake() { Router.Players().ValueChanged += ValueChanged; }