public FtMetaField New(int dataType) { FtMetaField result = FieldFactory.CreateMetaField(dataType, HeadingCount); Add(result); return(result); }
private static FieldBase[] CreateCoreFields(ArrayList fields, TypedRecordAttribute recordAttribute) { FieldBase curField; var arr = new ArrayList(); var someOptional = false; for (var i = 0; i < fields.Count; i++) { var fieldInfo = (FieldInfo)fields[i]; curField = FieldFactory.CreateField(fieldInfo, recordAttribute, someOptional); if (curField != null) { someOptional = curField.mIsOptional; arr.Add(curField); if (arr.Count > 1) { ((FieldBase)arr[arr.Count - 2]).mNextIsOptional = ((FieldBase)arr[arr.Count - 1]).mIsOptional; } } } if (arr.Count > 0) { ((FieldBase)arr[0]).mIsFirst = true; ((FieldBase)arr[arr.Count - 1]).mIsLast = true; } return((FieldBase[])arr.ToArray(typeof(FieldBase))); }
public void Create_CorrectArg_ShouldReturnAField() { var factory = new FieldFactory(); var result = factory.Create(new Mock <IContest>().Object, "name"); Assert.IsInstanceOf <Field>(result); }
static void Main() { try { var bots = new List <IBot> { new MediumBot(), new EasyBot() }; var fieldFactory = new FieldFactory(); var board = new Board(7, 6, fieldFactory); var gameFactory = new GameFactory(board, bots.ToArray()); var playerFactory = new PlayerFactory(); var proxy = new GameProxy(); var logger = new Log4netAdapter("GameAPI"); var api = new GameAPI(gameFactory, playerFactory, logger, proxy); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Form1(api)); } catch (Exception e) { Console.WriteLine(e); MessageBox.Show(e.ToString()); Application.Exit(); } }
void UpdateExposedParameters() { parameters.Clear(); if (graph.exposedParameters.Count != 0) { parameters.Add(new Label("Exposed Parameters:")); } foreach (var param in graph.exposedParameters) { if (param.settings.isHidden) { continue; } VisualElement prop = new VisualElement(); prop.style.display = DisplayStyle.Flex; Type paramType = Type.GetType(param.type); var field = FieldFactory.CreateField(paramType, param.serializedValue.value, (newValue) => { Undo.RegisterCompleteObjectUndo(graph, "Changed Parameter " + param.name + " to " + newValue); param.serializedValue.value = newValue; }, param.name); prop.Add(field); parameters.Add(prop); } }
internal FtFieldDefinition New(int dataType) { FtFieldDefinition definition = FieldFactory.CreateFieldDefinition(Count, dataType); list.Add(definition); return(definition); }
private object GetFormValues(Type typeOfModel, string prefix) { var vm = Activator.CreateInstance(typeOfModel); foreach (var property in vm.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { var propertyName = string.IsNullOrEmpty(prefix) ? property.Name : string.Format("{0}.{1}", prefix, property.Name); if (property.IsReadonly()) { continue; } if (!property.PropertyType.IsValueType && property.PropertyType != typeof(string) && !typeof(IEnumerable).IsAssignableFrom(property.PropertyType)) { var childValue = GetFormValues(property.PropertyType, propertyName); property.SetValue(vm, childValue, null); continue; } var elements = ((RemoteWebDriver)Browser).FindElementsByName(propertyName); var format = GetFormatStringForProperty(property); property.SetValue(vm, FieldFactory.Create(elements).Get(new ModelFieldType(property.PropertyType, format)), null); } return(vm); }
protected internal override FtMetaField CreateCopy() { FtMetaField field = FieldFactory.CreateMetaField(DataType, HeadingCount); field.Assign(this); return(field); }
/// <summary> /// Initializes a new instance of the <see cref="GroupBoxController"/> class. /// </summary> /// <param name="element">The element representig the related <see cref="GroupBox"/></param> /// <param name="enabled">True if the <see cref="GroupBox"/> is modifiable, false otherwise</param> public GroupBoxController(GroupBox element, bool enabled) : base(enabled) { groupPanel = new EnhancedGroupBox { HeaderText = element.Name, HeaderFont = new Font("Tahoma", 8, FontStyle.Italic), BorderColor = Color.Black, CornerRadius = 5, BorderSize = 1 }; this.element = element; controllers = new List <FieldController>(); if (!String.IsNullOrEmpty(element.Description)) { groupPanel.AddElement(new Label() { Text = element.Description, ForeColor = Color.FromArgb(90, 90, 90), Font = new Font("Tahoma", 8, FontStyle.Regular) }); } foreach (Field field in element.Fields) { FieldController controller = FieldFactory.CreateController(field, enabled); controllers.Add(controller); controller.SeparatedEditingRequest += OnInnerSeparatedRequest; groupPanel.AddElement(controller as Control); } Content = groupPanel; }
public void Process_WordsAlreadyPopulated_DoesNothing() { // arrange var database = new Mock <Database>(); database.Setup(x => x.Name).Returns("fake"); var itemMock = ItemFactory.CreateItem(database: database.Object); database.Setup(x => x.GetItem("item")).Returns(itemMock.Object); var field = FieldFactory.CreateField(itemMock.Object, ID.NewID, Constants.Fields.WordList, "lorem\nipsum"); ItemFactory.AddFields(itemMock, new[] { field }); var sut = new GetProfanityListFromItem(database.Object); sut.ItemPath = "item"; var args = new ProfanityFilterArgs(); args.WordList = new[] { "dolor" }; // act sut.Process(args); // assert Assert.That(args.WordList, Is.EquivalentTo(new[] { "dolor" })); }
public Display(ApplicationConfig config) { this.background = (Field)FieldFactory.MakeField(config.BackgroundField); this.numberField = (FieldString)FieldFactory.MakeField(config.NumberField); this.trialField = (FieldString)FieldFactory.MakeField(config.TrialField); this.recordField = (FieldString)FieldFactory.MakeField(config.RecordField); this.resultField = (FieldImage)FieldFactory.MakeField(config.ResultField); }
private Field CreateField(XmlSchemaElement schema) { XmlSchema onTheFlySchema = new XmlSchema(); onTheFlySchema.Items.Add(schema); return(FieldFactory.CreateField("GroupBox", schema.Name, onTheFlySchema)); }
public TestModel() : base() { ModelName = "test.user"; No = FieldFactory.CreateIntegerField(this, nameof(No)); Name = FieldFactory.CreateStringField(this, nameof(Name), 100); Price = FieldFactory.CreateDecimalField(this, nameof(Price), 10, 2); ParentId = FieldFactory.CreateMany2OneField(this, nameof(ParentId), "test.parent"); }
private Item CreateDictionaryEntryItem(string phrase) { var item = ItemFactory.CreateItem(); var field = FieldFactory.CreateField(item.Object, ID.NewID, "Phrase", phrase); ItemFactory.AddFields(item, new[] { field }); return(item.Object); }
public void CheckIfThereIsOnlyOneInstance() { FieldFactory firstField = FieldFactory.Instance; FieldFactory secondField = FieldFactory.Instance; Assert.AreSame(firstField, secondField); }
private Mock <Item> CreateMockBlogItem(bool rssEnabled) { var itemMock = ItemFactory.CreateItem(); var rssEnabledField = FieldFactory.CreateField(itemMock.Object, ID.NewID, "Enable RSS", rssEnabled ? "1" : "0"); ItemFactory.AddFields(itemMock, new[] { rssEnabledField }); return(itemMock); }
public void GetFieldWithSession() { Session session = new Session(5, 3); FieldFactory factory = new FieldFactory(); for (int i = 1; i <= session.Levels; i++) { session.CurrentLevel = i; Field field = factory.MakeField(session.StartIndex, session.EndIndex); } }
static void Main(string[] args) { var ninjaFactory = new NinjaFactory(); var data = new Data(); var fieldFactory = new FieldFactory(); var inputReader = new ConsoleReader(); var inputWriter = new ConsoleWriter(); Engine start = new Engine(ninjaFactory, data, fieldFactory, inputReader, inputWriter); start.Run(); }
private Field getitem(int index) { global::System.IntPtr cPtr = GmsecPINVOKE.FieldList_getitem(swigCPtr, index); Field ret = (cPtr == global::System.IntPtr.Zero) ? null : FieldFactory.BuildField(cPtr, false); if (GmsecPINVOKE.SWIGPendingException.Pending) { throw GmsecPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public Board Generate(int mineCount) { if (mineCount < 1 || this.ColumnCount * this.RowCount < mineCount) { throw new ArgumentException("invalid mine count"); } FieldFactory fieldFactory = new FieldFactory(); int countOfPlacedMine = 0; Random chanceToMine = new Random(); while (mineCount > countOfPlacedMine) { for (int rowIndex = 0; rowIndex < this.RowCount; rowIndex++) { if (countOfPlacedMine == mineCount) { break; } for (int columnIndex = 0; columnIndex < this.ColumnCount; columnIndex++) { if (countOfPlacedMine == mineCount) { break; } int randomNumber = chanceToMine.Next(0, 2); if (randomNumber == 1) { this.Board[rowIndex, columnIndex] = fieldFactory.GetField(Field.Field.MINE_CONTENT); countOfPlacedMine++; } } } } for (int rowIndex = 0; rowIndex < this.RowCount; rowIndex++) { for (int columnIndex = 0; columnIndex < this.ColumnCount; columnIndex++) { if (this.Board[rowIndex, columnIndex] != null) { continue; } int neighbourMinesCount = GetNeighbourMinesCount(rowIndex, columnIndex); this.Board[rowIndex, columnIndex] = fieldFactory.GetField(neighbourMinesCount); } } return(this.Board); }
public void GetField() { FieldFactory fieldFactory = new FieldFactory(); Field field = fieldFactory.MakeField(0, 10); int i = 0; foreach (LexemLine line in field.LexemLines) { Assert.AreEqual(i * FieldSettings.PictureHeight, line.Y); i++; } Assert.AreEqual(FieldSettings.RowNumbers, field.LexemLines.Count); }
private NodeController CreateController(Node node, bool enabled) { List <FieldController> fieldControllers = new List <FieldController>(); foreach (Field field in node.Fields) { fieldControllers.Add(FieldFactory.CreateController(field, enabled)); } NodeController controller = new NodeController(node.ID, node.Name, fieldControllers.ToArray()); return(controller); }
private void CreateOutputPort(TypeInfo typeInfo) { var element = FieldFactory.CreateField(typeInfo.DataType, dataNode.outputValue, (newValue) => { owner.RegisterCompleteObjectUndo("Create TestNodeView " + typeInfo.fullName); dataNode.outputValue = newValue; NotifyNodeChanged(); valueChangeCallback?.Invoke(); }, $"{typeInfo.fullName.Split('.').LastOrDefault()}Value"); controlsContainer.Add(element); style.width = 200; }
void Awake() { if (instance == null) { instance = this; } else if (instance != this) { Destroy(gameObject); } DontDestroyOnLoad(gameObject); }
protected void InputModel(T model) { foreach (var property in model.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) { if (property.IsReadonly()) { continue; } var elements = ((RemoteWebDriver)Browser).FindElementsByName(property.Name); var format = GetFormatStringForProperty(property); FieldFactory.Create(elements).Set(new ModelFieldValue(property.GetValue(model, null), format)); } }
private static void PopulateFields(ICollection <IField> schema, Type template, string parentName, int currentDepth, int maxDepth) { if (currentDepth >= maxDepth) { return; } string concat(params string[] args) => string.Join(".", args).TrimStart('.'); foreach (MemberInfo member in GetPublicFieldsAndPropertiesFrom(template)) { string temp; IField field; Type valueType = GetValueType(member); #if DEBUG System.Diagnostics.Debug.WriteLine($"{concat(parentName, member.Name)}: <{valueType.Name}>"); #endif switch (GetKindOfType(valueType, out Type collectionElementType)) { case KindOfType.Primitive: field = FieldFactory.CreateInstance(valueType, template); field.Name = concat(parentName, member.Name); schema.Add(field); break; case KindOfType.CollectionOfPrimitives: field = FieldFactory.CreateInstance(valueType); field.Name = concat(parentName, member.Name); schema.Add(field); field = FieldFactory.CreateInstance(collectionElementType); field.Name = concat(parentName, member.Name, Item); schema.Add(field); break; case KindOfType.Object: temp = concat(parentName, member.Name); PopulateFields(schema, valueType, temp, (currentDepth + 1), maxDepth); break; case KindOfType.CollectionOfObjects: field = FieldFactory.CreateInstance(valueType); field.Name = concat(parentName, member.Name); schema.Add(field); temp = concat(parentName, member.Name, Item); PopulateFields(schema, collectionElementType, temp, (currentDepth + 1), maxDepth); break; } } }
public LevelParser(XmlDocument xmlFile) { _xmlFile = xmlFile; _fieldFactory = new FieldFactory(); StartFieldsPlayerOne = new List <StartField>(); StartFieldsPlayerTwo = new List <StartField>(); StartFieldsPlayerThree = new List <StartField>(); StartFieldsPlayerFour = new List <StartField>(); AllFields = new List <IField>(); // Parse XML and connect the fields ParseXML(); }
private CommentItem CreateCommentItem() { var itemMock = ItemFactory.CreateItem(); ItemFactory.AddFields(itemMock, new[] { FieldFactory.CreateField(itemMock.Object, ID.NewID, "IP Address", "127.0.0.1"), FieldFactory.CreateField(itemMock.Object, ID.NewID, "Comment", "comment"), FieldFactory.CreateField(itemMock.Object, ID.NewID, "Name", "name"), FieldFactory.CreateField(itemMock.Object, ID.NewID, "Email", "email"), FieldFactory.CreateField(itemMock.Object, ID.NewID, "Website", "website") }); return(new CommentItem(itemMock.Object)); }
/// <summary> /// Initializes a new instance of the <see cref="ChoiceBox"/> class. /// </summary> /// <param name="typeName">The name of the class that rapresents the generic type of the instance.</param> /// <param name="elementName">The name of the <see cref="ChoiceBox"/> instance in the presentation.xml file of the workflow.</param> /// <param name="schema">The schema xml that describe the <see cref="ChoiceBox"/> type.</param> public ChoiceBox(String typeName, String elementName, XmlSchemaSet schema) : base(typeName, elementName, schema) { fields = new List <Field>(); //Instatiate all the possible fields XmlSchemaType myType = (schema.GlobalElements[new XmlQualifiedName(elementName)] as XmlSchemaElement).SchemaType; XmlSchemaChoice choice = (myType as XmlSchemaComplexType).Particle as XmlSchemaChoice; foreach (XmlSchemaElement element in choice.Items) { Field subfield = FieldFactory.CreateField(element); fields.Add(subfield); } }
void UpdateExposedParameters() { parameters.Clear(); bool header = true; bool showUpdateButton = false; foreach (var param in graph.exposedParameters) { if (param.settings.isHidden) { continue; } if (header) { var headerLabel = new Label("Exposed Parameters"); headerLabel.AddToClassList("Header"); parameters.Add(headerLabel); header = false; showUpdateButton = true; } VisualElement prop = new VisualElement(); prop.AddToClassList("Indent"); prop.style.display = DisplayStyle.Flex; Type paramType = Type.GetType(param.type); var field = FieldFactory.CreateField(paramType, param.serializedValue.value, (newValue) => { Undo.RegisterCompleteObjectUndo(graph, "Changed Parameter " + param.name + " to " + newValue); param.serializedValue.value = newValue; }, param.name); prop.Add(field); parameters.Add(prop); } if (showUpdateButton) { var updateButton = new Button(() => { MixtureGraphProcessor.RunOnce(graph); graph.SaveAllTextures(false); }) { text = "Update" }; updateButton.AddToClassList("Indent"); parameters.Add(updateButton); } }
/* This test will consume 117/200 of your daily request. Use with caution */ public void FetchDataAsync_should_export_a_record_for_each_of_the_mockaroo_data_types() { // Arrange var records = Convert.ToInt32(TestContext.Properties[RecordsProperty] ?? 1); var endpoint = Gigobyte.Mockaroo.Mockaroo.Endpoint(ApiKey.GetValue(), records, Format.JSON); var dataType = (DataType)Enum.Parse(typeof(DataType), Convert.ToString(TestContext.DataRow[0])); var field = new FieldFactory().CreateInstance(dataType); field.Name = "name"; // Act TestContext.WriteLine("Context: {0}", dataType); var data = MockarooClient.FetchDataAsync(endpoint, new Schema(field)).Result; var json = JArray.Parse(Encoding.Default.GetString(data)); // Assert json.Count.ShouldBeGreaterThanOrEqualTo(1); }