/// <summary> /// Adds a Restriction to a Product's Measurement. /// </summary> /// <param name="addRestrictionToProductMeasurementMV">AddRestrictionToProductMeasurementModelView with the Product's and Measurement's persistence identifiers /// as well as the Restriction's data.</param> /// <returns>GetProductModelView with updated Product information.</returns> /// <exception cref="ResourceNotFoundException">Thrown when either the Product or the Measurement could not be found.</exception> public GetProductModelView addRestrictionToProductMeasurement(AddMeasurementRestrictionModelView addRestrictionToProductMeasurementMV) { ProductRepository productRepository = PersistenceContext.repositories().createProductRepository(); Product product = productRepository.find(addRestrictionToProductMeasurementMV.productId); if (product == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_PRODUCT_BY_ID, addRestrictionToProductMeasurementMV.productId)); } Measurement measurement = product.productMeasurements .Where(pm => pm.measurementId == addRestrictionToProductMeasurementMV.measurementId).Select(pm => pm.measurement).SingleOrDefault(); if (measurement == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_MEASUREMENT_BY_ID, addRestrictionToProductMeasurementMV.measurementId)); } Algorithm algorithm = new AlgorithmFactory().createAlgorithm(addRestrictionToProductMeasurementMV.restriction.algorithmId); if (addRestrictionToProductMeasurementMV.restriction.inputValues != null) { algorithm.setInputValues(InputValueModelViewService.toDictionary(addRestrictionToProductMeasurementMV.restriction.inputValues)); } algorithm.ready(); Restriction restriction = new Restriction(addRestrictionToProductMeasurementMV.restriction.description, algorithm); product.addMeasurementRestriction(measurement, restriction); product = productRepository.update(product); return(ProductModelViewService.fromEntity(product)); }
public static bool Calc(SensorGroup gp, IList <SensorAcqResult> acqs) { var alv = gp.GetVirtualItems(); if (alv.Any()) { foreach (var groupItem in alv) { if (groupItem.VirtualGroup.GroupType == GroupType.VirtualSensor) { AlgorithmFactory.CreateAlgorithm(groupItem.VirtualGroup).CalcData(acqs); groupItem.Value = (from acq in acqs where acq.Sensor.SensorID == groupItem.VirtualGroup.VirtualSensor.SensorID select acq).FirstOrDefault(); } } return(AlgorithmFactory.CreateAlgorithm(gp).CalcData(acqs)); } else { return(AlgorithmFactory.CreateAlgorithm(gp).CalcData(acqs)); } }
static void Main(string[] args) { //test funkcnosti iteratoru pres algoritmy foreach (var item in AlgorithmFactory.Algorithms) { item.AssignCase(); } //test funkcnosti iteratoru pres popisy algoritmu foreach (var item in AlgorithmFactory.Descriptions) { Console.WriteLine(item); } try { AlgorithmFactory.GetSelectionAlgorithm(1).AssignCase(); AlgorithmFactory.GetSelectionAlgorithm(10).AssignCase(); } catch (KeyNotFoundException e) { Console.WriteLine("Exception OK: {0}", e.Message); } Console.ReadKey(); }
// FIXME: This method keeps submitting the last entered values from the form // each time the page is refreshed. public void OnPostGenerate(int rows, int columns, Algorithm algorithm, Format format) { Grid grid = new Grid(new Point(columns, rows)); IAlgorithm linkingAlgorithm = AlgorithmFactory.GetAlgorithm(algorithm, grid); linkingAlgorithm.Apply(); DisplayFormat = format; switch (format) { case Format.Ascii: Maze += grid.ToString(); break; case Format.Png: grid.ToPng(); // FIXME: Need an expert on serving static files in ASP.NET Core to help me get this image source to work. ImageSource = @"~/StaticFiles/maze.png"; break; default: // REVIEW: What would be better here is displaying a flash message at the GUI. throw new ArgumentException("Given format does not match a known enum."); } }
public ApiBootstrapper(ComputeServer computeServer, WorkerPool workerPool, AlgorithmFactory algoFactory) { this.computeServer = computeServer; this.workerPool = workerPool; this.algoFactory = algoFactory; serverType = ServerTypes.Compute; }
/// <summary> /// Adds a Restriction to a Product's complementary Product. /// </summary> /// <param name="addRestrictionToProductComponentMV">AddRestrictionToProductComponentModelView containing the data of the Restriction instance being added.</param> /// <returns>GetProductModelView with updated Product information.</returns> /// <exception cref="ResourceNotFoundException">Thrown when either of the Products could not be found.</exception> public GetProductModelView addRestrictionToProductComponent(AddComponentRestrictionModelView addRestrictionToProductComponentMV) { ProductRepository productRepository = PersistenceContext.repositories().createProductRepository(); Product parentProduct = productRepository.find(addRestrictionToProductComponentMV.fatherProductId); if (parentProduct == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_PRODUCT_BY_ID, addRestrictionToProductComponentMV.fatherProductId)); } //filter product's components rather than accessing the repository Product childProduct = parentProduct.components .Where(component => component.complementaryProduct.Id == addRestrictionToProductComponentMV.childProductId) .Select(component => component.complementaryProduct).SingleOrDefault(); if (childProduct == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_PRODUCT_BY_ID, addRestrictionToProductComponentMV.childProductId)); } Algorithm algorithm = new AlgorithmFactory().createAlgorithm(addRestrictionToProductComponentMV.restriction.algorithmId); if (addRestrictionToProductComponentMV.restriction.inputValues != null) { algorithm.setInputValues(InputValueModelViewService.toDictionary(addRestrictionToProductComponentMV.restriction.inputValues)); } algorithm.ready(); Restriction restriction = new Restriction(addRestrictionToProductComponentMV.restriction.description, algorithm); parentProduct.addComplementaryProductRestriction(childProduct, restriction); parentProduct = productRepository.update(parentProduct); return(ProductModelViewService.fromEntity(parentProduct)); }
/// <summary> /// Returns an instance of GetAlgorithmModelView representing the instance of Algorithm. /// </summary> /// <param name="restrictionAlgorithm">RestrictionAlgorithm that matches the corresponding Algorithm.</param> /// <returns>GetAlgorithmModelView representing the instance of Algorithm.</returns> public GetAlgorithmModelView getAlgorithm(RestrictionAlgorithm restrictionAlgorithm) { //this throws ArgumentOutOfRangeException if the element is not recognized by the factory Algorithm algorithm = new AlgorithmFactory().createAlgorithm(restrictionAlgorithm); return(AlgorithmModelViewService.fromEntity(algorithm)); }
static void Main(string[] args) { AppDomain.CurrentDomain.UnhandledException += UnhandledException; Console.WriteLine("Reading configuration"); string algorithmConfigurationFileName = "configuration.json"; string algorithmConfigurationFilePath = Path.Combine(Directory.GetCurrentDirectory(), algorithmConfigurationFileName); if (File.Exists(algorithmConfigurationFilePath) == false) { throw new FileNotFoundException($"{algorithmConfigurationFileName} not found at {Directory.GetCurrentDirectory()}"); } string outputDirectory = "Output"; if (Directory.Exists(outputDirectory)) { Directory.Delete(outputDirectory, true); } var algorithm = AlgorithmFactory.Create(algorithmConfigurationFilePath); Console.WriteLine($"{algorithm.Name} algorithm is running...."); outputDirectory = algorithm.Run(); Console.WriteLine("Algorithm has completed"); WaitKeyPress(); Process.Start(Path.Combine(Directory.GetCurrentDirectory(), outputDirectory)); }
/// <summary> /// Adds a Restriction to a Product's Material. /// </summary> /// <param name="addRestrictionModelView">AddRestrictionToProductMaterialModelView containing the data of the Restriction instance being added.</param> /// <returns>GetProductModelView with updated Product information.</returns> /// <exception cref="ResourceNotFoundException">Thrown when the Product or the Material could not be found.</exception> public GetProductModelView addRestrictionToProductMaterial(AddProductMaterialRestrictionModelView addRestrictionModelView) { ProductRepository productRepository = PersistenceContext.repositories().createProductRepository(); Product product = productRepository.find(addRestrictionModelView.productId); if (product == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_PRODUCT_BY_ID, addRestrictionModelView.productId)); } //filter product's materials rather than accessing the repository Material material = product.productMaterials .Where(productMaterial => productMaterial.materialId == addRestrictionModelView.materialId) .Select(productMaterial => productMaterial.material).SingleOrDefault(); if (material == null) { throw new ResourceNotFoundException(string.Format(ERROR_UNABLE_TO_FIND_MATERIAL_BY_ID, addRestrictionModelView.materialId)); } Algorithm algorithm = new AlgorithmFactory().createAlgorithm(addRestrictionModelView.restriction.algorithmId); if (addRestrictionModelView.restriction.inputValues != null) { algorithm.setInputValues(InputValueModelViewService.toDictionary(addRestrictionModelView.restriction.inputValues)); } algorithm.ready(); Restriction restriction = new Restriction(addRestrictionModelView.restriction.description, algorithm); product.addMaterialRestriction(material, restriction); product = productRepository.update(product); return(ProductModelViewService.fromEntity(product)); }
public void ensureGetRequiredInputsReturnsEmptyList() { Console.WriteLine("ensureGetRequiredInputsReturnsNull"); Algorithm alg = new AlgorithmFactory().createAlgorithm(RestrictionAlgorithm.SAME_MATERIAL_AND_FINISH_ALGORITHM); Assert.Empty(alg.getRequiredInputs()); }
/// <summary> /// In case for some some crazed reason you want a client to validate the specified token rather than just letting the creator be authoritative. /// </summary> /// <returns>Validated?</returns> /// <param name="token">The token to be validated.</param> public static bool Validate(string token, string secret = null) { byte[] secretBytes = EncodingHelper.GetBytes(secret); AlgorithmFactory algorithmFactory = new AlgorithmFactory(); var tokenDecoded = DecodeToken(token); bool secretValid = string.IsNullOrEmpty(secret); bool expirationValid = JsonConvert.DeserializeObject <JwtExpiration>(tokenDecoded.Payload).Expiration == null; // actually check the secret if (secret != null) { var alg = algorithmFactory.Create(tokenDecoded.Header.Algorithm); var bytesToSign = EncodingHelper.GetBytes(String.Concat(JsonConvert.SerializeObject(tokenDecoded.Header), ".", tokenDecoded.Payload)); var testSignature = alg.Sign(secretBytes, bytesToSign); var decodedTestSignature = Convert.ToBase64String(testSignature); secretValid = decodedTestSignature == tokenDecoded.Verification; } //actually check the expiration var expiration = JsonConvert.DeserializeObject <JwtExpiration>(tokenDecoded.Payload).Expiration; if (expiration != null) { expirationValid = DateTimeHelpers.FromUnixTime((long)expiration) < DateTime.Now; } return(secretValid && expirationValid); }
public double ResultAlgorithm(int numberOfAlg) { AlgorithmFactory fuctory = new AlgorithmFactory(numberOfAlg, CompliteCodeMain, CompliteCodeChild); IAlgorithm algorithm = fuctory.Create(); algorithm?.CompareRes(); return(algorithm.Result); }
public void ensureSetInputValueFails() { Algorithm alg = new AlgorithmFactory().createAlgorithm(RestrictionAlgorithm.SAME_MATERIAL_AND_FINISH_ALGORITHM); Input input = Input.valueOf("one", "number 1"); Action action = () => alg.setInputValue(input, "1"); Assert.Throws <ArgumentException>(action); }
public Main(Algorithm algorithmName, Form1 basicform) { InitializeComponent(); observer = new UIExecuteObserver(this, basicform); algorithm = AlgorithmFactory.getAlorithm(algorithmName, observer); InitializeValues(); }
public void ensureWidthPercentageAlgorithmIsCreated() { Console.WriteLine("ensureWidthPercentageAlgorithmIsCreated"); AlgorithmFactory factory = new AlgorithmFactory(); Algorithm algorithm = factory.createAlgorithm(RestrictionAlgorithm.WIDTH_PERCENTAGE_ALGORITHM); Assert.True(algorithm.GetType().ToString() == "core.domain.WidthPercentageAlgorithm"); }
public void ensureCreateAlgorithmFailsIfAlgorithmDoesNotExistd() { Console.WriteLine("ensureCreateAlgorithmFailsIfAlgorithmDoesNotExistd"); AlgorithmFactory factory = new AlgorithmFactory(); Action create = () => factory.createAlgorithm(0); Assert.Throws <ArgumentOutOfRangeException>(create); }
/// <summary> /// Decodes secred data from Image /// </summary> /// <param name="algorithm">Algorithm used in decoding</param> /// <exception cref="System.NullReferenceException">Thrown if the <paramref name="algorithm"/> is is not known algorithm type.</exception> /// <exception cref="System.InvalidOperationException">TThrown if the <paramref name="algorithm"/> does not inherit from StegoAlgorithm.</exception> /// <exception cref="StegoCore.Exceptions.DecodeException">Thrown if error while decoding occurs</exception> /// <returns>Bytes of decoded secred data</returns> public byte[] Decode(AlgorithmEnum algorithm) { if (this.image == null) { throw new System.NullReferenceException("Image cannot be null"); } var alg = AlgorithmFactory.Create(algorithm); return(alg.Decode(this.image, this.settings)); }
public void LSB_Embed_And_Decode_SecretDataLength() { var lsb = AlgorithmFactory.Create(AlgorithmEnum.Lsb); byte[] secretDataBytes = System.IO.File.ReadAllBytes(FileHelper.GetPathToSecretData()); var secretData = new SecretData(secretDataBytes); var imageWithSecret = lsb.Embed(Image.Load(FileHelper.GetPathToImage()), secretData, null); int readedLength = lsb.ReadSecretLength(imageWithSecret, null); Assert.Equal(secretDataBytes.Length, readedLength); }
public GameManager(HttpClient client) { this.client = client; lobby = new Lobby(client); algorithmFactory = new AlgorithmFactory(); player = new Player(); factory = new FactionFactory(); standart = algorithmFactory.GetDefault("Standart"); hopper = algorithmFactory.GetDefault("Hopper"); tower = algorithmFactory.GetDefault("Tower"); teleport = algorithmFactory.GetDefault("Teleport"); }
public void InitAlgorithm(string algoName, double h_trg) { //アルゴリズムをセット if (env != null && env.Network != null && env.Network.Nodes != null && env.Network.Nodes.Count() > 0) { //foreach (AATBasedAgentIO aat in env.Network.Nodes) foreach (AgentIO aat in env.Network.Nodes) { aat.Algorithm = (AlgorithmFactory.CreateAlgorithm(algoName, h_trg)); } } }
/// <summary> /// Returns an instance of GetAllInputsModelView representing the Algorithm's required inputs. /// </summary> /// <param name="restrictionAlgorithm">RestrictionAlgorithm that matches the corresponding Algorithm.</param> /// <returns>GetAllInputsModelView representing the Algorithm's required inputs. </returns> /// <exception cref="ResourceNotFoundException">Thrown when the Algorithm has no required inputs.</exception> public GetAllInputsModelView getAlgorithmRequiredInputs(RestrictionAlgorithm restrictionAlgorithm) { Algorithm algorithm = new AlgorithmFactory().createAlgorithm(restrictionAlgorithm); List <Input> requiredInputs = algorithm.getRequiredInputs(); if (!requiredInputs.Any()) { throw new ResourceNotFoundException(NO_REQUIRED_INPUTS); } return(InputModelViewService.fromCollection(requiredInputs)); }
public void ensureSetInputValuesFails() { Input input1 = Input.valueOf("one", "number 1"); Input input2 = Input.valueOf("two", "number 2"); Algorithm alg = new AlgorithmFactory().createAlgorithm(RestrictionAlgorithm.SAME_MATERIAL_AND_FINISH_ALGORITHM); Dictionary <Input, string> inputValues = new Dictionary <Input, string>(); inputValues.Add(input1, "1"); inputValues.Add(input2, "2"); Action action = () => alg.setInputValues(inputValues); Assert.Throws <ArgumentException>(action); }
public string run(string password, string algo) { AlgorithmFactory factory = new AlgorithmFactory(algo); IAlgo algorithm = factory.create(); if (algorithm == null) { return(null); } string newPassword = algorithm.generate(password); return(newPassword); }
public ComputeServer(SystemConfiguration systemConfig, string name, AlgorithmFactory algoFactory) { uuid = Guid.NewGuid().ToString(); this.name = name; config = systemConfig.Servers[name]; var mediatorConfig = systemConfig.Servers.First(kvp => kvp.Value.Type == ServerTypes.Mediator).Value; mediator = new MediatorConnector(mediatorConfig); workerPool = new WorkerPool(config.PoolSize, uuid, mediator); //bootstrapper = new ComputeBootstrapper(this, workerPool); bootstrapper = new ApiBootstrapper(this, workerPool, algoFactory); }
public IExternalOverlapRemoval <TVertex> GenerateOverlapRemovalAlgorithm(Dictionary <TVertex, Rect> rectangles = null) { if (ExternalOverlapRemovalAlgorithm == null) { //create default OR return(AlgorithmFactory.CreateOverlapRemovalAlgorithm(DefaultOverlapRemovalAlgorithm, null, DefaultOverlapRemovalAlgorithmParams)); } else { var overlap = ExternalOverlapRemovalAlgorithm; overlap.Rectangles = rectangles; return(overlap); } }
/// <summary> /// Embed secret data in Image /// </summary> /// <param name="algorithm">Algorithm used in embending</param> /// <exception cref="System.NullReferenceException">Thrown if the <paramref name="algorithm"/> is is not known algorithm type.</exception> /// <exception cref="System.InvalidOperationException">TThrown if the <paramref name="algorithm"/> does not inherit from StegoAlgorithm.</exception> /// <exception cref="StegoCore.Exceptions.DataToBigException">Thrown if the secred data is to big for embending</exception> /// <returns>Image with embeded secret data</returns> public Image <Rgba32> Embed(AlgorithmEnum algorithm) { if (this.image == null) { throw new System.NullReferenceException("Image cannot be null"); } if (this.secretData == null) { throw new System.NullReferenceException("Secret data cannot be null"); } var alg = AlgorithmFactory.Create(algorithm); return(alg.Embed(this.image, this.secretData, this.settings)); }
private void Init() { _hashSHA1Generator = AlgorithmFactory.GetHasher(EHashType.SHA_1); _hashSHA256Generator = AlgorithmFactory.GetHasher(EHashType.SHA_256); hashSHA512Generator = AlgorithmFactory.GetHasher(EHashType.SHA_512); defaultHashGenerator = hashSHA512Generator; signHMACSHA1Generator = AlgorithmFactory.GetSigner(ESignType.HMAC_SHA1); signHMACSHA256Generator = AlgorithmFactory.GetSigner(ESignType.HMAC_SHA256); _saltGenerator = new SecureRNGAdapter(); _asymmetricCryptGenerator = new RSAAdapter(); Encoder = Encoding.UTF8; aes128 = AlgorithmFactory.GetSymmetricTransformCrypt(ESymmetricTransformCryptType.AES_128); aes256 = AlgorithmFactory.GetSymmetricTransformCrypt(ESymmetricTransformCryptType.AES_256); }
public IExternalEdgeRouting <TVertex, TEdge> GenerateEdgeRoutingAlgorithm(Size DesiredSize) { if (ExternalEdgeRoutingAlgorithm == null && DefaultEdgeRoutingAlgorithm != EdgeRoutingAlgorithmTypeEnum.None) { return(AlgorithmFactory.CreateEdgeRoutingAlgorithm(DefaultEdgeRoutingAlgorithm, new Rect(DesiredSize), Graph, null, null, DefaultEdgeRoutingAlgorithmParams)); } else if (ExternalEdgeRoutingAlgorithm != null) { return(ExternalEdgeRoutingAlgorithm); } else { return(null); } }
private void Encrypt_Decrypt(AlgorithmEnum alg, IImageFormat imageFormat, string outFileName) { Configuration.Default.AddImageFormat(imageFormat); var algorithm = AlgorithmFactory.Create(alg); byte[] secretDataBytes = System.IO.File.ReadAllBytes(FileHelper.GetPathToSecretData()); var notSavedStego = EncryptAndSave(algorithm, secretDataBytes, outFileName); var stegoImage = Image.Load(outFileName); byte[] resultSecret = algorithm.Decode(notSavedStego, null); Assert.Equal(secretDataBytes, resultSecret); }
public IExternalLayout <TVertex> GenerateLayoutAlgorithm(Dictionary <TVertex, Size> vertexSizes) { if (ExternalLayoutAlgorithm != null) { var alg = ExternalLayoutAlgorithm; if (alg.NeedVertexSizes) { alg.VertexSizes = vertexSizes; } return(alg); } else { return(AlgorithmFactory.CreateLayoutAlgorithm(DefaultLayoutAlgorithm, Graph, null, vertexSizes, DefaultLayoutAlgorithmParams)); } }
public void ensureApplyRemovesUnnecessaryFinishes() { Console.WriteLine("ensureApplyRemovesUnnecessaryFinishes"); Material material = new Material("#24", "K6205", "ola.jpg", new List <Color>(new[] { Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100) }), new List <Finish>(new[] { Finish.valueOf("der alte wurfelt nicht", 12), Finish.valueOf("schrödinger's box", 13) })); ProductCategory cat = new ProductCategory("AI"); DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 90.0, 100.0, 150.0 })); Measurement measurement = new Measurement(discrete, discrete, discrete); List <Measurement> measurements = new List <Measurement>() { measurement }; Product product = new Product("#12", "Mother Goose of Mutual Recursion: Recursive Mother Goose", "product12.glb", cat, new List <Material>(new[] { material }), measurements); Product component = new Product("#13", "Mother Goose of Diffractive Recitavo: Diffraction Mother Goose", "product13.gltf", cat, new List <Material>(new[] { material }), measurements); CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("#8", product, CustomizedDimensions.valueOf(100, 100, 100)).withMaterial(CustomizedMaterial.valueOf(material, Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100), Finish.valueOf("schrödinger's box", 13))).build(); Algorithm algorithm = new AlgorithmFactory().createAlgorithm(RestrictionAlgorithm.SAME_MATERIAL_AND_FINISH_ALGORITHM); Assert.Equal("schrödinger's box", algorithm.apply(custom, component).productMaterials[0].material.Finishes[0].description); }
private static void RunAlgorithm() { IFigure startingContainer; IAlgorithm algorithm; Stopwatch stopwatch = new Stopwatch(); IContainerFactory containerFactory = new ContainerFactory(); IAlgorithmFactory factory = new AlgorithmFactory(); if (Properties.Dimensionality == AlgorithmDimensionality.TwoDimensional) { startingContainer = containerFactory.Create(Properties, ContainerWidth, ContainerHeight); algorithm = factory.Create(Properties, startingContainer); } else { startingContainer = containerFactory.Create(Properties, ContainerWidth, ContainerHeight, ContainerDepth); algorithm = factory.Create(Properties, startingContainer); } ObjectSet objectsToPack = LoadObjectSet(); if (!CheckContainerSize(objectsToPack)) { throw new InvalidContainerSizeException("Container is not big enough to contain biggest object. Enlarge the container."); } stopwatch.Reset(); var sortedObjects = SortingHelper.Sort(objectsToPack, Ordering); stopwatch.Start(); algorithm.Execute(sortedObjects); stopwatch.Stop(); var endResults = algorithm.CreateResults(); endResults.ExecutionTime = stopwatch.ElapsedMilliseconds; WriteResiltsToCsv(endResults, startingContainer); }
public ServerFactory(SystemConfiguration configuration, AlgorithmFactory algoFactory, DataSource dataSource) { SystemConfig = configuration; AlgorithmFactory = algoFactory; DataSource = dataSource; }