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;
}
