public static void Start(params string[] args)
{
var parser = new Parser(
parserSettings =>
{
if (parserSettings == null)
{
throw new ArgumentNullException(
nameof(parserSettings), @"If this is null the CommandLineParser dependency is likely broken."
);
}
parserSettings.AutoHelp = true;
parserSettings.AutoVersion = true;
parserSettings.IgnoreUnknownArguments = true;
}
);
FactoryRegistry <IPluginBootstrapContext> .RegisterFactory(PluginBootstrapContext.CreateFactory(args ?? Array.Empty <string>(), parser));
var commandLineOptions = parser.ParseArguments <ClientCommandLineOptions>(args)
.MapResult(HandleParsedArguments, HandleParserErrors);
if (!string.IsNullOrWhiteSpace(commandLineOptions.WorkingDirectory))
{
var workingDirectory = commandLineOptions.WorkingDirectory.Trim();
if (Directory.Exists(workingDirectory))
{
Directory.SetCurrentDirectory(workingDirectory);
}
}
Context = new ClientContext(commandLineOptions, Log.Default);
Context.Start();
}
public StoreSaveState Load(ResourceRegistry resourceRegistry, FactoryRegistry factoryRegistry, ModifierRegistry modiferRegistry)
{
string path = string.Format(@"{0}{1}", directoryPath, FILE_NAME);
StoreSaveState storage = null;
try
{
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
using (StreamReader reader = new StreamReader(fileStream))
{
storage = JsonConvert.DeserializeObject <StoreSaveState>(reader.ReadToEnd());
}
}
}
catch (FileNotFoundException)
{
throw new FileNotFoundException(string.Format("An existing save file could not be found to load at: {0}", path));
}
ResourceCheckpoint checkpoint = new ResourceCheckpoint(storage.ResourceCheckpoint.CheckpointTimeUTC,
storage.ResourceCheckpoint.ResourceAmounts,
resourceRegistry);
FactoryManager factoryManager = new FactoryManager(storage.FactoryManager.FactoryAmounts, factoryRegistry);
ModifierManager modifierManager = new ModifierManager(storage.ModiferManager.ModifierDurations, modiferRegistry);
return(new StoreSaveState()
{
ResourceCheckpoint = checkpoint, FactoryManager = factoryManager, ModiferManager = modifierManager
});
}
/// <summary>
/// Convert Geography Markup representation to <see cref="IGeometry" /> representation.
/// </summary>
/// <param name="source">The source string.</param>
/// <param name="factory">The factory used for geometry production.</param>
/// <returns>The <see cref="IGeometry" /> representation of the geometry.</returns>
public static IGeometry ToGeometry(String source, IGeometryFactory factory)
{
if (source == null)
{
throw new ArgumentNullException("The geometry text is null.", "source");
}
if (factory == null)
{
factory = FactoryRegistry.GetFactory <IGeometryFactory>();
}
StringReader sr = new StringReader(source);
XDocument doc = XDocument.Load(sr);
XElement firstElement = doc.Elements().FirstOrDefault();
if (firstElement != null)
{
return(ToGeometry(firstElement, factory));
}
else
{
throw new ArgumentException("The source text contains no elements.", "source");
}
}
public Store(IStoreIO storeIO)
{
resourceRegistry = new ResourceRegistry();
factoryRegistry = new FactoryRegistry();
modifierRegistry = new ModifierRegistry();
this.storeIO = storeIO;
}
public List <IViewModel> getViewModel <T>(IEnumerable <T> dbModel, Table_Type type)
where T : class
{
List <IViewModel> datas = new List <IViewModel>();
var obj = FactoryRegistry.GetInstance(type);
if (dbModel == null || obj == null)
{
return(datas);
}
var viewpros = obj.GetType().GetProperties();
if (!dbModel.Any())
{
return(datas);
}
var dbpros = dbModel.First().GetType().GetProperties();
dbModel.ToList().ForEach(db => {
obj = FactoryRegistry.GetInstance(type);
foreach (var item in viewpros)
{
var p = dbpros.FirstOrDefault(x => x.Name.ToUpper() == item.Name.ToUpper());
if (p != null)
{
var _pt = p.PropertyType;
if (_pt == typeof(string))
{
item.SetValue(obj, p.GetValue(db));
}
else if (_pt == typeof(DateTime) || _pt == typeof(Nullable <DateTime>))
{
if (p.GetValue(db) != null)
{
item.SetValue(obj, TypeTransfer.objDateToString(p.GetValue(db)));
}
else
{
item.SetValue(obj, string.Empty);
}
}
else
{
if (p.GetValue(db) != null)
{
item.SetValue(obj, p.GetValue(db).ToString());
}
else
{
item.SetValue(obj, string.Empty);
}
}
}
}
datas.Add(obj);
});
return(datas);
}
public ActionResult A96DateDetail()
{
ViewBag.action = new SelectList(actions, "Value", "Text");
var jqgridInfo = FactoryRegistry.GetInstance(Table_Type.A96_Trade).TojqGridData(null, null, true);
ViewBag.jqgridColNames = jqgridInfo.colNames;
ViewBag.jqgridColModel = jqgridInfo.colModel;
return(View());
}
public ActionResult A95_1Detail()
{
ViewBag.action = new SelectList(actions, "Value", "Text");
var jqgridInfo = FactoryRegistry.GetInstance(Table_Type.A95_1).TojqGridData(new int[] { 100, 150, 230, 190, 165, 100 }, null, true);
ViewBag.jqgridColNames = jqgridInfo.colNames;
ViewBag.jqgridColModel = jqgridInfo.colModel;
return(View());
}
/// <summary>
/// Convert Geography Markup representation to <see cref="IGeometry" /> representation.
/// </summary>
/// <param name="source">The source XElement node.</param>
/// <param name="factory">The factory used for geometry production.</param>
/// <returns>The <see cref="IGeometry" /> representation of the geometry.</returns>
public static IGeometry ToGeometry(XElement node, IGeometryFactory factory)
{
if (node == null)
{
throw new ArgumentNullException("The geometry node is null.", "node");
}
if (factory == null)
{
factory = FactoryRegistry.GetFactory <IGeometryFactory>();
}
IGeometry resultGeometry = null;
try
{
switch (node.Name.LocalName)
{
case "Point":
resultGeometry = ReadPoint(node.Elements(), factory);
break;
case "LineString":
resultGeometry = ReadLineString(node.Elements(), factory);
break;
case "LinearRing":
resultGeometry = ReadLinearRing(node.Elements(), factory);
break;
case "Polygon":
resultGeometry = ReadPolygon(node.Elements(), factory);
break;
case "MultiPoint":
resultGeometry = ReadMultiPoint(node.Elements(), factory);
break;
case "MultiLineString":
resultGeometry = ReadMultiLineString(node.Elements(), factory);
break;
case "MultiPolygon":
resultGeometry = ReadMultiPolygon(node.Elements(), factory);
break;
case "GeomCollection":
break;
}
}
catch (Exception ex)
{
throw new ArgumentException("node", "Failed to convert XElement to Geometry.", ex);
}
return(resultGeometry);
}
public object ExecuteModule(Type interfaceType, IResolver resolver, object existingObject)
{
// If we already have an object, just return that object (this module is for creating a new one from the Factory)
if (existingObject != null)
{
return(existingObject);
}
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver), $"{nameof(FactoryModule)} requires a non-null {nameof(IResolver)}");
}
else if (interfaceType == null)
{
throw new ArgumentNullException(nameof(interfaceType), $"{nameof(FactoryModule)} requires a non-null {nameof(interfaceType)}");
}
FactoryRegistry registry = RegistrationParser.GetRegistrationRegistry <FactoryRegistry>(interfaceType.Name);
if (string.IsNullOrWhiteSpace(registry.Factory))
{
throw new InvalidOperationException($"No factory setup was registered to the Interface \"{interfaceType.Name}\" within the Registration.");
}
// Generate class from Factory
IResolverRegistry factoryRegistry = RegistrationParser.GetRegistrationRegistry(registry.Factory);
foreach (Type factoryInterfaceType in RegistrationParser.GetInterfaceTypesInAssemblies())
{
if (!factoryInterfaceType.Name.Equals(factoryRegistry.Interface))
{
continue;
}
object factory = resolver.Resolve(factoryInterfaceType);
MethodInfo factoryMethod = factory.GetType()
.GetMethod(registry.FactoryMethod);
try
{
ParameterInfo parameter = factoryMethod.GetParameters()[0];
if (parameter.ParameterType != typeof(IResolver))
{
throw new NotSupportedException($"{nameof(FactoryModule)} does not support calling factory methods that require unique parameters beyond just the {nameof(IResolver)}.");
}
return(factoryMethod.Invoke(factory, new[] { resolver }));
}
catch (IndexOutOfRangeException) // No parameters thus the GetParameters()[0} would throw this
{
return(factoryMethod.Invoke(factory, null));
}
}
throw new TypeAccessException($"Interface \"{interfaceType.Name}\" was marked to use a Factory but the Factory could not be mapped to. Searched for \"{factoryRegistry.Class}\"");
}
/// <summary>
/// Converts the face to a SFA polygon.
/// </summary>
/// <param name="factory">The geometry factory used to produce the polygon.</param>
/// <returns>The polygon geometry representing the face.</returns>
public IPolygon ToGeometry(IGeometryFactory factory = null)
{
if (factory == null)
{
factory = FactoryRegistry.GetFactory <IGeometryFactory>();
}
return(factory.CreatePolygon(Vertices.Select(vertex => vertex.Position),
Holes.Select(hole => hole.Vertices.Select(vertex => vertex.Position).Reverse())));
}
public static PluginInstance Create([NotNull, ValidatedNotNull] Plugin plugin)
{
var bootstrapContext = FactoryRegistry <IPluginBootstrapContext> .Create(plugin);
var context = FactoryRegistry <IPluginContext> .Create(plugin);
var entry = plugin.Reference.CreateInstance();
return(new PluginInstance(entry, bootstrapContext, context));
}
/// <summary>
/// Resolves the geometry factory.
/// </summary>
/// <returns>The factory for producing geometries.</returns>
protected IGeometryFactory ResolveFactory()
{
if (_factory == null)
{
if (_factoryType == null)
{
_factory = FactoryRegistry.GetFactory <IGeometryFactory>();
}
else
{
_factory = (IGeometryFactory)FactoryRegistry.GetFactory(_factoryType);
}
}
return(_factory);
}
/// <summary>
/// Computes the result.
/// </summary>
protected override void ComputeResult()
{
if (Source.ReferenceSystem != null && _targetReferenceSystem != null && !Source.ReferenceSystem.Equals(_targetReferenceSystem))
{
// strategy pattern
_transformation = TransformationStrategyFactory.CreateStrategy(Source.ReferenceSystem as ReferenceSystem, _targetReferenceSystem as ReferenceSystem);
}
if (_factory == null)
{
_factory = (IGeometryFactory)FactoryRegistry.GetFactory(FactoryRegistry.GetContract(Source.Factory), _targetReferenceSystem);
}
_intermediateResult = Compute(Source);
}
internal ServerContext(ServerCommandLineOptions startupOptions, [NotNull] Logger logger) : base(
startupOptions, logger
)
{
// Register the factory for creating service plugin contexts
FactoryRegistry <IPluginContext> .RegisterFactory(new ServerPluginContext.Factory());
if (startupOptions.Port > 0)
{
Options.ServerPort = startupOptions.Port;
}
RestApi = new RestApi(startupOptions.ApiPort);
Network = CreateNetwork();
}
private void Init()
{
if (BrowserStackConfiguration.EnableBrowserStack)
{
if (BrowserStackConfiguration.BrowserStackOnly)
{
FactoryRegistry.Clear();
}
//add supported browsers
SetBrowserFactories().ToList().ForEach(f => FactoryRegistry.RegisterBrowserFactory(f));
if (SeleniumTestsConfiguration.FastMode)
{
SeleniumTestsConfiguration.FastMode = false;
Log("FastMode is not supported for BrowserStack. This setting is going to be ignored.");
}
}
}
public void FactoryRegistryMethodsTest()
{
Assert.IsTrue(FactoryRegistry.AutoLocation);
FactoryRegistry.AutoLocation = false;
Assert.IsFalse(FactoryRegistry.AutoLocation);
FactoryRegistry.AutoLocation = true;
Assert.IsTrue(FactoryRegistry.AutoLocation);
// default query
IMetadataFactory metadataFactory = FactoryRegistry.GetFactory <IMetadataFactory>();
Assert.IsNotNull(metadataFactory);
Assert.IsInstanceOf <MetadataFactory>(metadataFactory);
IGeometryFactory geometryFactory = FactoryRegistry.GetFactory <IGeometryFactory>();
Assert.IsNotNull(geometryFactory);
Assert.IsInstanceOf <GeometryFactory>(geometryFactory);
geometryFactory = FactoryRegistry.GetFactoryFor <IGeometry>() as IGeometryFactory;
Assert.IsNotNull(geometryFactory);
Assert.IsInstanceOf <GeometryFactory>(geometryFactory);
// parameterized query
geometryFactory = FactoryRegistry.GetFactory <IGeometryFactory>(PrecisionModel.Default, _referenceSystemMock.Object);
Assert.IsNotNull(geometryFactory);
Assert.IsInstanceOf <GeometryFactory>(geometryFactory);
Assert.AreEqual(PrecisionModel.Default, geometryFactory.PrecisionModel);
Assert.AreEqual(_referenceSystemMock.Object, geometryFactory.ReferenceSystem);
geometryFactory = FactoryRegistry.GetFactoryFor <IGeometry>(PrecisionModel.Default, _referenceSystemMock.Object) as IGeometryFactory;
Assert.IsNotNull(geometryFactory);
Assert.IsInstanceOf <GeometryFactory>(geometryFactory);
Assert.AreEqual(PrecisionModel.Default, geometryFactory.PrecisionModel);
Assert.AreEqual(_referenceSystemMock.Object, geometryFactory.ReferenceSystem);
// exceptions
Assert.Throws <ArgumentNullException>(() => FactoryRegistry.GetFactory(null));
}
/// <summary>
/// dataRow to ViewModel
/// </summary>
/// <param name="item"></param>
/// <param name="titles"></param>
/// <param name="type"></param>
/// <returns></returns>
public List <IViewModel> getViewModel(IEnumerable <DataRow> items, List <string> titles, Table_Type type)
{
List <IViewModel> datas = new List <IViewModel>();
var obj = FactoryRegistry.GetInstance(type);
if (obj == null)
{
return(datas);
}
var pros = obj.GetType().GetProperties();
if (!items.Any() || items.First().ItemArray.Count() != titles.Count)
{
return(datas);
}
items.ToList().ForEach(item =>
{
obj = FactoryRegistry.GetInstance(type);
for (int i = 0; i < titles.Count; i++) //每一行所有資料
{
string data = null;
if (item[i].GetType().Name.Equals("DateTime"))
{
data = TypeTransfer.objDateToString(item[i]);
}
else
{
data = TypeTransfer.objToString(item[i]);
}
if (!data.IsNullOrWhiteSpace()) //資料有值
{
var PInfo = pros.Where(x => x.Name.Trim().ToLower() == titles[i].Trim().ToLower())
.FirstOrDefault();
if (PInfo != null)
{
PInfo.SetValue(obj, data);
}
}
}
datas.Add(obj);
});
return(datas);
}
/// <summary>
/// Resolves the geometry factory.
/// </summary>
/// <param name="referenceSystem">The reference system.</param>
/// <returns>The factory for producing geometries.</returns>
protected IGeometryFactory ResolveFactory(IReferenceSystem referenceSystem)
{
if (_factory == null)
{
if (_factoryType == null)
{
_factory = FactoryRegistry.GetFactory <IGeometryFactory>(referenceSystem);
}
else
{
_factory = (IGeometryFactory)FactoryRegistry.GetFactory(_factoryType, referenceSystem);
}
}
if (referenceSystem != null && !_factory.ReferenceSystem.Equals(referenceSystem))
{
_factory = (IGeometryFactory)FactoryRegistry.GetFactory(_factory.GetType(), referenceSystem);
}
return(_factory);
}
private static ServerCommandLineOptions ParseCommandLineArgs(params string[] args)
{
var parser = new Parser(
parserSettings =>
{
if (parserSettings == null)
{
throw new ArgumentNullException(
nameof(parserSettings), @"If this is null the CommandLineParser dependency is likely broken."
);
}
parserSettings.AutoHelp = true;
parserSettings.AutoVersion = true;
parserSettings.IgnoreUnknownArguments = true;
parserSettings.MaximumDisplayWidth = Console.BufferWidth;
}
);
FactoryRegistry <IPluginBootstrapContext> .RegisterFactory(PluginBootstrapContext.CreateFactory(args ?? Array.Empty <string>(), parser));
return(parser.ParseArguments <ServerCommandLineOptions>(args)
.MapResult(commandLineOptions => commandLineOptions, errors => default));
}
internal ClientContext(ClientCommandLineOptions startupOptions, Logger logger, INetworkHelper networkHelper) : base(
startupOptions, logger, networkHelper
)
{
FactoryRegistry <IPluginContext> .RegisterFactory(new ClientPluginContext.Factory());
}
/// <summary>
/// Convert Well-known Binary representation to <see cref="IGeometry" /> representation.
/// </summary>
/// <param name="source">The source byte array.</param>
/// <param name="factory">The factory used for geometry production.</param>
/// <param name="referenceSystem">The reference system of the geometry.</param>
/// <returns>The <see cref="IGeometry" /> representation of the geometry.</returns>
/// <exception cref="System.ArgumentNullException">The source is null.</exception>
/// <exception cref="System.ArgumentException">
/// The source is empty.;source
/// or
/// The content of the source is invalid.;source
/// </exception>
public static IGeometry ToGeometry(Byte[] source, IGeometryFactory factory)
{
if (source == null)
{
throw new ArgumentNullException("source", "The source is null.");
}
if (source.Length == 0)
{
throw new ArgumentException("The source is empty.", "source");
}
if (factory == null)
{
factory = FactoryRegistry.GetFactory <IGeometryFactory>();
}
try
{
ByteOrder byteOrder = (source[0] == 1) ? ByteOrder.LittleEndian : ByteOrder.BigEndian;
IGeometry resultGeometry = null;
switch ((WellKnownBinaryTypes)EndianBitConverter.ToInt32(source, 1, byteOrder))
{
case WellKnownBinaryTypes.Point:
resultGeometry = ComputePoint(source, byteOrder, GeometryModel.Spatial2D, factory);
break;
case WellKnownBinaryTypes.PointZ:
resultGeometry = ComputePoint(source, byteOrder, GeometryModel.Spatial3D, factory);
break;
case WellKnownBinaryTypes.LineString:
resultGeometry = ComputeLineString(source, byteOrder, GeometryModel.Spatial2D, factory);
break;
case WellKnownBinaryTypes.LineStringZ:
resultGeometry = ComputeLineString(source, byteOrder, GeometryModel.Spatial3D, factory);
break;
case WellKnownBinaryTypes.Polygon:
resultGeometry = ComputePolygon(source, byteOrder, GeometryModel.Spatial2D, factory);
break;
case WellKnownBinaryTypes.PolygonZ:
resultGeometry = ComputePolygon(source, byteOrder, GeometryModel.Spatial3D, factory);
break;
case WellKnownBinaryTypes.MultiPoint:
resultGeometry = ComputeMultiPoint(source, byteOrder, GeometryModel.Spatial2D, factory);
break;
case WellKnownBinaryTypes.MultiPointZ:
resultGeometry = ComputeMultiPoint(source, byteOrder, GeometryModel.Spatial3D, factory);
break;
case WellKnownBinaryTypes.MultiLineString:
resultGeometry = ComputeMultiLineString(source, byteOrder, GeometryModel.Spatial2D, factory);
break;
case WellKnownBinaryTypes.MultiLineStringZ:
resultGeometry = ComputeMultiLineString(source, byteOrder, GeometryModel.Spatial3D, factory);
break;
case WellKnownBinaryTypes.MultiPolygon:
resultGeometry = ComputeMultiPolygon(source, byteOrder, GeometryModel.Spatial2D, factory);
break;
case WellKnownBinaryTypes.MultiPolygonZ:
resultGeometry = ComputeMultiPolygon(source, byteOrder, GeometryModel.Spatial3D, factory);
break;
}
return(resultGeometry);
}
catch
{
throw new ArgumentException("The content of the source is invalid.", "source");
}
}
/// <summary>
/// Convert Well-known Binary representation to <see cref="IGeometry" /> representation.
/// </summary>
/// <param name="source">The source byte array.</param>
/// <param name="referenceSystem">The reference system of the geometry.</param>
/// <returns>The <see cref="IGeometry" /> representation of the geometry.</returns>
/// <exception cref="System.ArgumentNullException">The source is null.</exception>
/// <exception cref="System.ArgumentException">
/// The source is empty.
/// or
/// The content of the source is invalid.
/// </exception>
public static IGeometry ToGeometry(Byte[] source, IReferenceSystem referenceSystem)
{
return(ToGeometry(source, FactoryRegistry.GetFactory <IGeometryFactory>(referenceSystem)));
}
internal ClientContext(ClientCommandLineOptions startupOptions, [NotNull] Logger logger) : base(
startupOptions, logger
)
{
FactoryRegistry <IPluginContext> .RegisterFactory(new ClientPluginContext.Factory());
}
public static void Start(params string[] args)
{
(string[] Args, Parser Parser, ServerCommandLineOptions CommandLineOptions)parsedArguments = ParseCommandLineArgs(args);
if (!string.IsNullOrWhiteSpace(parsedArguments.CommandLineOptions.WorkingDirectory))
{
var workingDirectory = parsedArguments.CommandLineOptions.WorkingDirectory.Trim();
if (Directory.Exists(workingDirectory))
{
Directory.SetCurrentDirectory(workingDirectory);
}
}
if (!PreContextSetup(args))
{
return;
}
var logger = Log.Default;
var packetTypeRegistry = new PacketTypeRegistry(logger);
if (!packetTypeRegistry.TryRegisterBuiltIn())
{
logger.Error("Failed to load built-in packet types.");
return;
}
var packetHandlerRegistry = new PacketHandlerRegistry(packetTypeRegistry, logger);
var networkHelper = new NetworkHelper(packetTypeRegistry, packetHandlerRegistry);
FactoryRegistry <IPluginBootstrapContext> .RegisterFactory(
PluginBootstrapContext.CreateFactory(
parsedArguments.Args ?? Array.Empty <string>(),
parsedArguments.Parser,
networkHelper
)
);
Context = new ServerContext(parsedArguments.CommandLineOptions, logger, networkHelper);
var noHaltOnError = Context?.StartupOptions.DoNotHaltOnError ?? false;
if (!PostContextSetup())
{
return;
}
MainThread = Context.StartWithActionQueue();
Action action;
while (null != (action = MainThread.NextAction))
{
action.Invoke();
}
Log.Diagnostic("Bootstrapper exited.");
// At this point dbs should be saved and all threads should be killed. Give a message saying that the server has shutdown and to press any key to exit.
// Having the message and the console.readline() allows the server to exit properly if the console has crashed, and it allows us to know that the server context has shutdown.
if (Context.HasErrors)
{
if (noHaltOnError)
{
Console.WriteLine(Strings.Errors.errorservercrashnohalt);
}
else
{
Console.WriteLine(Strings.Errors.errorservercrash);
Console.ReadLine();
}
}
}
/// <summary>
/// Convert Geography Markup representation to <see cref="IGeometry" /> representation.
/// </summary>
/// <param name="source">The source node.</param>
/// <param name="referenceSystem">The reference system of the geometry.</param>
/// <returns>The <see cref="IGeometry" /> representation of the geometry.</returns>
public static IGeometry ToGeometry(XElement node, IReferenceSystem referenceSystem)
{
return(ToGeometry(node, FactoryRegistry.GetFactory <IGeometryFactory>(referenceSystem)));
}
