private Type GetType(FieldTypes type) { switch (type) { case FieldTypes.Boolean: return(typeof(bool)); case FieldTypes.DateTime: return(typeof(DateTime)); case FieldTypes.Double: return(typeof(Double)); case FieldTypes.Int: return(typeof(int)); case FieldTypes.Money: return(typeof(decimal)); case FieldTypes.Varchar: return(typeof(string)); default: return(typeof(string)); } }
/// <summary> /// Create a value for the scoped fieldtype, with a preferred default /// </summary> /// <param name="scope">Scope (usually the name of the type) for which to create the field</param> /// <param name="fieldType">FieldType of the field to construct</param> /// <param name="preferredDefaultValue">preferred default</param> /// <returns>a new or cached value for the given fieldType, with the scope of it's value being restricted to the Type scope</returns> public object CreateCachedValue(string scope, FieldTypes fieldType, object preferredDefaultValue) { if (fieldType == FieldTypes.FLAGS) { return(preferredDefaultValue); } string requestedField = scope + "." + fieldType.ToString(); object fieldValue = preferredDefaultValue; // Check if the configuration exists if (LastUsedFieldValues == null) { LastUsedFieldValues = new Dictionary <string, object>(); } // Check if settings for the requesting type exist, if not create! if (LastUsedFieldValues.ContainsKey(requestedField)) { // Check if a value is set (not null)! if (LastUsedFieldValues[requestedField] != null) { fieldValue = LastUsedFieldValues[requestedField]; } else { // Overwrite null value LastUsedFieldValues[requestedField] = fieldValue; } } else { LastUsedFieldValues.Add(requestedField, fieldValue); } return(fieldValue); }
/// <summary> /// This function will be used to add /// table cell /// </summary> /// <param name="tableRow">Table Row</param> /// <param name="aField">Field</param> /// <param name="fieldType">Type of field</param> /// <returns></returns> private static TableCell AddTableCell(TableRow tableRow, string value, FieldTypes fieldType) { TableCell tableCell1 = new TableCell(); string valueToPrint = "NA"; switch (fieldType) { case FieldTypes.DateTime: if (!string.IsNullOrWhiteSpace(value)) { DateTime createdDate = DateTime.Now; createdDate = DateTime.Parse(value); valueToPrint = TimeAgo(createdDate); } else { valueToPrint = "NA"; } break; case FieldTypes.Text: valueToPrint = !string.IsNullOrWhiteSpace(value) ? value : "NA"; break; default: valueToPrint = !string.IsNullOrWhiteSpace(value) ? value : "NA"; break; } tableCell1.Text = valueToPrint; tableRow.Cells.Add(tableCell1); return(tableCell1); }
public void TestUpdateValidSpecialProperties(ResourceId resource, FieldTypes fType, Properties.PropertyName propName) { var guid = GuidsForUpdate[resource].Values.First(); var handler = new DefaultManager(); var props = GenerateExceptedProperties(Defines.FieldTypeApi, propName.GetEnumStringValue(), SpecialMappingValue[propName]); if (propName != Properties.PropertyName.Field) { props[Properties.PropertyName.Field.GetEnumStringValue()] = UuidUtil.GetId(FieldsCreator.Data[$"{Defines.ReferenceResource[resource].First()}-{FieldType.Mail.ToString()}-2"].Guid); } var request = GenerateUpdateRequest(resource, guid.ToString(), props); var response = handler.Send <object>(FieldManager.FieldHandlingRelativeUrl, JsonConvert.SerializeObject(request), TestCoreFramework.Enums.HttpMethod.PUT); PrAssert.That(response, PrIs.SuccessfulResponse().And.HttpCode(System.Net.HttpStatusCode.NoContent)); var result = (new FieldManager()).GetFieldDetails(guid); if (propName == Properties.PropertyName.Enabled) { PrAssert.That(result.Result.Values.SingleOrDefault().Key.ToString(), PrIs.Not.EqualTo(propName.GetEnumStringValue())); } else { PrAssert.That(result.Result.Values.SingleOrDefault().Value.Properties[propName.GetEnumStringValue()], PrIs.Not.EqualTo(SpecialMappingValue[propName])); } }
/// <summary> /// This function will be used to add /// table cell /// </summary> /// <param name="tableRow">Table Row</param> /// <param name="aField">Field</param> /// <param name="fieldType">Type of field</param> /// <returns></returns> private static TableCell AddTableCell(TableRow tableRow, Sitecore.Data.Fields.Field aField, FieldTypes fieldType) { TableCell tableCell1 = new TableCell(); string valueToPrint = "NA"; switch (fieldType) { case FieldTypes.DateTime: if ((aField != null) && !string.IsNullOrEmpty(aField.Value)) { string dateFormat = "r"; DateTime createdDate = DateTime.Now; createdDate = Sitecore.DateUtil.IsoDateToDateTime(aField.Value); valueToPrint = createdDate.ToString(dateFormat); } else { valueToPrint = "NA"; } break; case FieldTypes.Text: valueToPrint = ((aField != null) && !string.IsNullOrEmpty(aField.Value)) ? aField.Value : "NA"; break; default: valueToPrint = ((aField != null) && !string.IsNullOrEmpty(aField.Value)) ? aField.Value : "NA"; break; } tableCell1.Text = valueToPrint; tableRow.Cells.Add(tableCell1); return tableCell1; }
private char GetCharFromFieldType(FieldTypes value) { char result; switch (value) { case FieldTypes.Empty: result = '+'; break; case FieldTypes.Snake: result = 'o'; break; case FieldTypes.NextHead: result = GetAnimatedCircle(); break; case FieldTypes.Wall: result = '▒'; break; default: throw new ArgumentException("Unknown field type"); } return(result); }
bool Find2() { foreach (var cctor in DeobUtils.GetInitCctors(module, 3)) { foreach (var calledMethod in DotNetUtils.GetCalledMethods(module, cctor)) { var type = calledMethod.DeclaringType; if (type.IsPublic) { continue; } var fieldTypes = new FieldTypes(type); if (!fieldTypes.All(requiredFields1)) { continue; } if (!HasInitializeMethod(type, "_Initialize") && !HasInitializeMethod(type, "_Initialize64")) { continue; } initializeMethod = calledMethod; postInitializeMethod = FindMethod(type, "System.Void", "PostInitialize", "()"); loadMethod = FindMethod(type, "System.IntPtr", "Load", "()"); cliSecureRtType = type; FindStringDecrypters(); return(true); } } return(false); }
public void Initialize(string webURL, ContentType contentType, SearchFilter filter, bool isOr) { this.WebURL = webURL; this.ContentType = contentType; this.IsOr = isOr; this.FillFilterTypeComboBox(); this.FillPropertyComboBox(); string fieldName = filter.FieldName; CamlFilterTypes filterType = filter.FilterType; FieldTypes fieldType = filter.FieldType; this.SearchFilter = new SearchFilter(fieldName, fieldType, filterType, filter.FilterValue); PropertyComboBox.SelectedValue = this.SearchFilter.FieldName; FilterTypeComboBox.SelectedValue = this.SearchFilter.FieldType; if (this.IsOr == true) { AndOrComboBox.SelectedIndex = 1; } else { AndOrComboBox.SelectedIndex = 0; } PropertyLabel.Content = this.SearchFilter.FieldName; FilterTypeLabel.Content = this.SearchFilter.FilterType.ToString(); FilterValueLabel.Content = this.SearchFilter.FilterValue; AndOrLabel.Content = Languages.Translate(this.IsOr == true ? "Or" : "And"); }
private string GetCamlFieldTypeString(FieldTypes fieldType) { string camlString = String.Empty; switch (fieldType) { case FieldTypes.Boolean: camlString = "boolean"; break; case FieldTypes.Choice: camlString = "Text"; break; case FieldTypes.Computed: camlString = "text"; break; case FieldTypes.ContentType: camlString = "text"; break; case FieldTypes.ContentTypeId: camlString = "text"; break; case FieldTypes.Counter: camlString = "number"; break; case FieldTypes.DateTime: camlString = "DateTime"; break; case FieldTypes.File: camlString = "text"; break; case FieldTypes.Lookup: camlString = "number"; break; case FieldTypes.Note: camlString = "text"; break; case FieldTypes.Number: camlString = "number"; break; case FieldTypes.Text: camlString = "text"; break; case FieldTypes.User: camlString = "text"; break; } return(camlString); }
internal pSprite(Texture2D texture, FieldTypes fieldType, OriginTypes originType, ClockTypes clockType, Vector2 startPosition, float drawDepth, bool alwaysDraw, Color colour, Object tag) { Type = SpriteTypes.Image; localTexture = texture; Disposable = false; SpriteEffect = SpriteEffects.None; OriginType = originType; UpdateTextureSize(); UpdateTextureAlignment(); Clock = clockType; CurrentPosition = startPosition; StartPosition = CurrentPosition; CurrentRotation = 0; CurrentScale = 1; Depth = drawDepth; AlwaysDraw = alwaysDraw; Field = fieldType; CurrentColour = colour; StartColour = colour; Tag = tag; }
internal static string AnalysisJDBCType(FieldTypes fieldType) { switch (fieldType) { case FieldTypes.String: return(JDBCTypes.VARCHAR.ToString()); case FieldTypes.Decimal: return(JDBCTypes.DECIMAL.ToString()); case FieldTypes.Int32: return(JDBCTypes.INTEGER.ToString()); case FieldTypes.Long: return(JDBCTypes.BIGINT.ToString()); case FieldTypes.DateTime: return(JDBCTypes.TIMESTAMP.ToString()); case FieldTypes.Float: case FieldTypes.Double: case FieldTypes.Bool: return("暂时不支持的数据类型"); default: throw new ArgumentException(nameof(fieldType)); } }
/// <summary> /// Construct a CsvFile, based on a DataTable /// Second line of input file may contain the data types, /// and optionally widths. /// </summary> /// <param name="filename">comma seperated filename</param> public CsvFile(string filename, FieldTypes fieldType = FieldTypes.AutoDetect) { char[] delim = { ',' }; ReadFile(filename); fieldNames = ParseCSV(lines[0]); if (fieldType == FieldTypes.AllText) { dataTypes = new string[fieldNames.Length]; for (int i = 0; i < dataTypes.Length; i++) { dataTypes[i] = "String"; } ParseFile(dataTypes, fieldNames, 1, ""); return; } else {// auto detect dataTypes = lines[1].Split(delim); if (!ValidDataTypes(dataTypes)) { dataTypes = EstimateDataTypes(); ParseFile(dataTypes, fieldNames, 1, ""); } else { ParseFile(dataTypes, fieldNames, 2, ""); } } }
public EditMetadata(FieldTypes validationType, string errorString, string displayString) { this.validationType = validationType; this.customString = ".*"; this.errorString = errorString; this.displayString = displayString; }
// -------------------------------------------------------- /// <summary> /// The add field. /// </summary> /// <param name="field"> /// The field. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public bool AddField(FieldTypes field) { if (field != FieldTypes.Undefined) { if (fields == null) { fields = new HashSet <FieldTypes>(); } if (fields.Add(field)) { switch (field) { case FieldTypes.IdCardType_IdCardNumber: fields.Add(FieldTypes.IdCardType); fields.Add(FieldTypes.IdCardNumber); break; case FieldTypes.PolicyType_PolicyNumber: fields.Add(FieldTypes.PolicyType); fields.Add(FieldTypes.PolicyNumber); break; case FieldTypes.InsuranceCompanyCode_InsuranceCompanyCoding: fields.Add(FieldTypes.InsuranceCompanyCode); fields.Add(FieldTypes.InsuranceCompanyCoding); break; } return(true); } } return(false); }
public void Add(String _DataType, String _DataField, FieldTypes _FieldType, Object _DataValue, String _Expression) { DataItems fField = new DataItems(); if (_DataType.ToUpper() == "NUMBER") { fField.DataType = DataTypes.Number; } else if (_DataType.ToUpper() == "NVARCHAR") { fField.DataType = DataTypes.NVarchar; } else if (_DataType.ToUpper() == "DATETIME") { fField.DataType = DataTypes.DateTime; } else { fField.DataType = DataTypes.Undefined; } fField.FieldType = _FieldType; fField.DataValue = _DataValue; fField.DataField = _DataField; fField.Expression = _Expression; base.List.Add(fField); }
public static Field GetField(FieldTypes fieldType) { switch (fieldType) { case FieldTypes.ONE: return new NumberField((int)fieldType); case FieldTypes.TWO: return new NumberField((int)fieldType); case FieldTypes.THREE: return new NumberField((int)fieldType); case FieldTypes.FOUR: return new NumberField((int)fieldType); case FieldTypes.FIVE: return new NumberField((int)fieldType); case FieldTypes.SIX: return new NumberField((int)fieldType); case FieldTypes.MIN: return new MiddleLayerField(); case FieldTypes.MAX: return new MiddleLayerField(); case FieldTypes.SKALA: return new SkalaField(); case FieldTypes.FULL: return new FullField(); default: return MoreOfAKindFieldFactory.GetField(fieldType); } }
bool Find3() { foreach (var type in module.Types) { if (type.Fields.Count < 1 || type.Fields.Count > 2) { continue; } var fieldTypes = new FieldTypes(type); if (!fieldTypes.Exactly(requiredFields6) && !fieldTypes.Exactly(requiredFields7)) { continue; } if (type.Methods.Count != 2) { continue; } if (type.FindStaticConstructor() == null) { continue; } var cs = type.FindMethod("cs"); if (cs == null) { continue; } AddStringDecrypterMethod(cs); cliSecureRtType = type; return(true); } return(false); }
public CamlFilter(string fieldName, FieldTypes fieldType, CamlFilterTypes filterType, string filterValue) { FieldName = fieldName; FieldType = fieldType; FilterType = filterType; FilterValue = filterValue; }
/// <summary> /// The retrieve handler. /// </summary> /// <param name="fieldType"> /// The field type. /// </param> /// <returns> /// The <see cref="PrepareHandler"/>. /// </returns> private PrepareHandler RetrieveHandler(FieldTypes fieldType) { switch (fieldType) { case FieldTypes.BirthDate: return(PrepareDate); case FieldTypes.FamilyName: case FieldTypes.FirstName: case FieldTypes.MiddleName: return(PrepareText); case FieldTypes.BirthPlace: case FieldTypes.ENP: case FieldTypes.PolicyType: case FieldTypes.PolicyNumber: case FieldTypes.IdCardNumber: return(PrepareText); case FieldTypes.SNILS: return(PrepareSNILS); case FieldTypes.IdCardType: case FieldTypes.InsuranceTerritory: default: return(PrepareDefault); } }
/// <summary> /// Initializes a new instance of the <see cref="MonitoredItemReference"/> struct. /// </summary> /// <param name="index">The index.</param> /// <param name="fieldType">Type of the field.</param> /// <param name="mappingType">Type of the mapping.</param> public MonitoredItemReference(int index, FieldTypes fieldType, MappingTypes mappingType) : this() { this.Index = index; this.FieldType = fieldType; this.MappingType = mappingType; }
internal pSprite(pTexture texture, FieldTypes field, OriginTypes origin, ClockTypes clocking, Vector2 position, float depth, bool alwaysDraw, Color4 colour) { Field = field; Origin = origin; Clocking = clocking; Position = position; Colour = colour; Scale = Vector2.One; Rotation = 0; DrawDepth = depth; AlwaysDraw = alwaysDraw; if (!alwaysDraw) { Alpha = 0; } else { Alpha = 1; } Texture = texture; UsesTextures = true; }
public FieldSettings(FieldTypes generalType) { InitializeComponent(); descriptionCtrl.DescriptionChange = DescriptionChange; EnablePanel(generalType); Result = null; }
private void EnablePanel(FieldTypes generalType) { switch (generalType) { case FieldTypes.Number: fieldRuleCtrl = new NumberFieldCtrl(); break; case FieldTypes.String: fieldRuleCtrl = new StringFieldCtrl(); break; case FieldTypes.Date: case FieldTypes.Time: fieldRuleCtrl = new DateTimeFieldCtrl(); ((DateTimeFieldCtrl)fieldRuleCtrl).SetRuleDateTimeType(generalType); break; case FieldTypes.Enumerator: fieldRuleCtrl = new EnumeratorCtrl(); break; case FieldTypes.MappedSource: fieldRuleCtrl = new MappedSourceCtrl(); break; } this.controlPanel.Controls.Add((UserControl)this.fieldRuleCtrl, 0, 1); ((UserControl)this.fieldRuleCtrl).Dock = DockStyle.Fill; }
List <TypeDef> FindVmHandlerTypes() { var requiredFields = new string[] { null, "System.Collections.Generic.Dictionary`2<System.UInt16,System.Type>", "System.UInt16", }; var cflowDeobfuscator = new CflowDeobfuscator(); foreach (var type in module.Types) { var cctor = type.FindStaticConstructor(); if (cctor == null) { continue; } requiredFields[0] = type.FullName; var fieldTypes = new FieldTypes(type); if (!fieldTypes.All(requiredFields)) { continue; } cflowDeobfuscator.Deobfuscate(cctor); var handlers = FindVmHandlerTypes(cctor); return(handlers); } return(null); }
public override void InputValues(LayerTypes layer, FieldTypes field, int[] diceNumbers) { if (field == _fieldPointer && !IsColumnFull()) { Layers[layer].InputValues(field, diceNumbers); if (field == FieldTypes.ONE) {/*ako je unos jedinica, upisuju se još i u pomoćni spremnik * središnjeg sloja stupca, jer je potrebno kod računanja bodova*/ Layers[LayerTypes.MIDDLE].InputValues(field, diceNumbers); } if (_fieldPointer != FieldTypes.YAMB) {/*ako nije došlo do kraja stupca pomjeri pokazivač na sljedeće polje*/ int newFieldPointer = (int)_fieldPointer + 1; _fieldPointer = (FieldTypes)newFieldPointer; } } else { throw new InaccessibleFieldException("Illegal field is selected or the column is already filled."); } }
internal pAnimation(Texture2D[] textures, FieldTypes fieldType, OriginTypes originType, ClockTypes clockType, Vector2 startPosition, float drawDepth, bool alwaysDraw, Color colour, object tag) : base(textures[0], fieldType, originType, clockType, startPosition, drawDepth, alwaysDraw, colour, tag) { TextureArray = textures; TextureCount = textures.Length; }
public FieldSource(int position, FieldTypes type, SourceOrientation orientation, Func <double, double> f) { Function = f; Position = position; FieldType = type; Orientation = orientation; }
public void Find() { var requiredFields = new string[] { "System.Threading.ReaderWriterLock", "System.Collections.Hashtable", }; foreach (var type in module.GetTypes()) { var fieldTypes = new FieldTypes(type); if (!fieldTypes.All(requiredFields)) continue; if (type.FindMethod("Finalize") == null) continue; var executeMethod = DotNetUtils.GetMethod(type, "System.Object", "(System.String,System.Object[])"); if (executeMethod == null || !executeMethod.IsStatic || executeMethod.Body == null) continue; var decrypterType = FindMethodsDecrypterType(type); if (decrypterType == null) continue; resourceDecrypter.DecryptMethod = FindDecryptMethod(decrypterType); methodsDecrypterCreator = type; methodsDecrypter = decrypterType; decryptExecuteMethod = executeMethod; return; } }
public override void InputValues(LayerTypes layer, FieldTypes field, int[] diceNumbers) { if (_isAnnounced) { if (field == _announcedField) { Layers[layer].InputValues(field, diceNumbers); if (field == FieldTypes.ONE) { Layers[LayerTypes.MIDDLE].InputValues(field, diceNumbers); } _isAnnounced = false; } else { throw new InaccessibleFieldException("Posted unavailable field."); } } else if (Layers[layer].IsFieldFilled(field)) { throw new FieldIsFilledException("The field is already filled."); } else { _isAnnounced = true; _announcedField = field; } }
public Field(string fieldName, string valueBefore, string valueAfter, FieldTypes fieldType) { FieldName = fieldName; ValueBefore = valueBefore; ValueAfter = valueAfter; FieldType = fieldType; }
public void AddFieldType(System.Xml.XmlNode node) { // add field type name the mapping var scName = Sitecore.Xml.XmlUtil.GetAttribute("sitecoreFieldTypeName", node); var umlName = Sitecore.Xml.XmlUtil.GetAttribute("umlFieldTypeName", node); FieldTypes.Add(scName, umlName); // add the umlFieldTypeName to the aliases map to enable case-insensitive matches UmlFieldTypeAliases.Add(umlName, scName); // add the aliases to the alias map var umlAliases = Sitecore.Xml.XmlUtil.GetAttribute("umlAliases", node); if (string.IsNullOrEmpty(umlAliases)) { return; } var aliases = umlAliases .Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries); foreach (var alias in aliases) { UmlFieldTypeAliases.Add(alias, scName); } }
public CamlFilter(Search.SearchFilter searchFilter) { this.FieldName = searchFilter.FieldName; this.FieldType = searchFilter.FieldType; this.FilterType = searchFilter.FilterType; this.FilterValue = searchFilter.FilterValue; }
private FieldTypes[][] GenerateBaseTable(int rows, int columns, int mineCount) { var gameTable = new FieldTypes[rows][]; var minedFields = Enumerable .Range(0, rows) .Select(row => Enumerable.Range(0, columns).Select(col => new { Row = row, Column = col })) .SelectMany(pairs => pairs) .Select(pair => new { pair.Row, pair.Column, Order = _randomNumberProvider.GetRandomNumber() }) .OrderBy(pairWithOrder => pairWithOrder.Order) .Take(mineCount) .ToList(); for (var row = 0; row < rows; ++row) { gameTable[row] = new FieldTypes[columns]; for (var col = 0; col < columns; ++col) { gameTable[row][col] = FieldTypes.Empty; } } foreach (var minedField in minedFields) { gameTable[minedField.Row][minedField.Column] = FieldTypes.Mined; } return(gameTable); }
public static string GetDescription(this FieldTypes value) { var enumType = typeof(FieldTypes); var field = enumType.GetField(value.ToString()); var attribute = field.GetCustomAttribute <DescriptionAttribute>(); return(attribute?.Description ?? value.ToString()); }
public void SetField(string name, object value, Type type) { curve.FireBeforeChange(BGCurve.EventPointField); FieldTypes.SetField(curve, type, name, value, PrivateValuesForFields); curve.FireChange(curve.UseEventsArgs ? BGCurveChangedArgs.GetInstance(Curve, this, BGCurve.EventPointField) : null, sender: this); }
public static string getCheckBoxValue(string sVal, string CheckedValue, string UnCheckedValue, FieldTypes Type) { if (sVal.Length == 0) { return ToSQL(UnCheckedValue, Type); } else { return ToSQL(CheckedValue, Type); } }
public override void InputValues(LayerTypes layer, FieldTypes field, int[] diceNumbers) { Layers[layer].InputValues(field, diceNumbers); if (field == FieldTypes.ONE) { Layers[LayerTypes.MIDDLE].InputValues(field, diceNumbers); } }
public Field(int x, int y) { this.x = x; this.y = y; this.type = FieldTypes.Path; this.connection = null; this.hitbox = new Rectangle(x * Data.BlockSize, y * Data.BlockSize, Data.BlockSize, Data.BlockSize); this.spawner = null; }
public Field(int x, int y, FieldTypes type, Field Connection) { this.x = x; this.y = y; this.type = type; this.connection = Connection; this.hitbox = new Rectangle(x * Data.BlockSize, y * Data.BlockSize, Data.BlockSize, Data.BlockSize); this.spawner = null; }
public void InputValues(FieldTypes field, int[] diceNumbers) { if (IsFieldFilled(field)) { throw new FieldIsFilledException("The field is already filled."); } else { Fields[field].SetValue(diceNumbers); } }
public int GetFieldValue(FieldTypes field) { if (IsFieldFilled(field)) { return Fields[field].Value; } else { throw new FieldIsEmptyException("Field is empty."); } }
bool CheckFields(IList<FieldDef> fields) { if (fields.Count != 3) return false; var fieldTypes = new FieldTypes(fields); if (fieldTypes.Count("System.Boolean") != 1) return false; if (fieldTypes.Count("System.Object") == 2) return true; return fieldTypes.Count("System.Reflection.Assembly") == 1 && fieldTypes.Count("System.String[]") == 1; }
// GlobalFuncs Event begin // GlobalFuncs Event end public static string ToSQL(string Param, FieldTypes Type) { if (Param == null || Param.Length == 0) { return "Null"; } else { string str = Quote(Param); if (Type == FieldTypes.Number) { return str.Replace(',','.'); } else { return "\'" + str + "\'"; } } }
public static MoreOfAKindField GetField(FieldTypes fieldType) { switch (fieldType) { case FieldTypes.TRIS: return new TrisField(); case FieldTypes.POKER: return new PokerField(); case FieldTypes.YAMB: return new YambField(); default: throw new NonExistingFieldException(""); } }
public bool EnterDiceValue(IViewTableForm frmTableDisplay, IConfirmForm frmConfirm, ColumnTypes column, LayerTypes layer, FieldTypes field) { if (_currentDiceThrow == DiceThrow.FIRST && !_turnEnded) { frmTableDisplay.DisplayMsg(Color.Red, _msg[4]); return false; } else { if (ValidEntering(frmConfirm, column)) { try { YambTable.GetInstance().InputValue(column, layer, field, _diceRoller.Dices, _currentDiceThrow); if (column == ColumnTypes.ANNOUNCEMENT) { AnnouncementActions(frmTableDisplay, field); } else { NextTurn(); frmTableDisplay.EndOfTurnActions(); } if (YambTable.GetInstance().IsTableFull()) { frmTableDisplay.GameFinished(); } } catch (YambException) { frmTableDisplay.DisplayMsg(Color.Red, _msg[5]); return false; } } else { return false; } } return true; }
public static DatabaseType GetType(FieldTypes type) { DatabaseType databastType = null; switch (type) { case FieldTypes.BLOB: databastType = new DatabaseType(SqlDbType.VarBinary, DbType.Binary); break; case FieldTypes.DATETIME: databastType = new DatabaseType(SqlDbType.DateTime, DbType.DateTime); break; case FieldTypes.INT: databastType = new DatabaseType(SqlDbType.Int, DbType.Int32); break; case FieldTypes.TEXT: databastType = new DatabaseType(SqlDbType.VarChar, DbType.String); break; } return databastType; }
private void picBox_rowMaxAnnounce_Click(object sender, EventArgs e) { SaveToTEMP(); announcedField = picBox_rowMaxAnnounce; inputFiledsColumn = ColumnTypes.ANNOUNCEMENT; inputFieldType = FieldTypes.MAX; bool entered = game.EnterDiceValue(this, new frmConfirm(), ColumnTypes.ANNOUNCEMENT, LayerTypes.MIDDLE, FieldTypes.MAX); if (!entered) { ReturnFromTEMP(); } }
public void InputValue(ColumnTypes column, LayerTypes layer, FieldTypes field, int[] diceNumbers, DiceThrow diceThrow) { if (column == ColumnTypes.ANNOUNCEMENT && !_announced) { if (diceThrow == DiceThrow.SECOND) { Columns[column].InputValues(layer, field, diceNumbers); _announced = true; } else { throw new InaccessibleFieldException("The field is unavailable."); } } else if (_announced && column != ColumnTypes.ANNOUNCEMENT) { throw new InaccessibleFieldException("The field is unavailable."); } else { Columns[column].InputValues(layer, field, diceNumbers); _announced = false; } NotifyObservers(); }
public int GetFieldValue(ColumnTypes column, LayerTypes layer, FieldTypes field) { int value = 0; try { value = Columns[column].GetFieldValue(layer, field); } catch (FieldIsEmptyException) { } catch (KeyNotFoundException) { throw new NonExistingFieldException("There is no such field in the selected layer."); } return value; }
StringDecrypterVersion GuessVersion(MethodDef cctor) { var fieldTypes = new FieldTypes(stringsEncodingClass); if (fieldTypes.Exactly(fields2x)) return StringDecrypterVersion.V2; if (cctor == null) return StringDecrypterVersion.V1; if (fieldTypes.Exactly(fields3x)) return StringDecrypterVersion.V3; return StringDecrypterVersion.Unknown; }
bool couldBeStringDecrypterClass(TypeDefinition type) { var fields = new FieldTypes(type); if (fields.exists("System.Collections.Hashtable") || fields.exists("System.Collections.Generic.Dictionary`2<System.Int32,System.String>") || fields.exactly(fields3x)) { if (DotNetUtils.getMethod(type, ".cctor") == null) return false; } else if (fields.exactly(fields1x) || fields.exactly(fields2x)) { } else return false; var methods = new List<MethodDefinition>(DotNetUtils.getNormalMethods(type)); if (methods.Count != 1) return false; var method = methods[0]; if (!DotNetUtils.isMethod(method, "System.String", "(System.Int32)")) return false; if (!method.IsStatic || !method.HasBody) return false; return true; }
public int GetFieldValue(LayerTypes layer, FieldTypes field) { switch (layer) { case LayerTypes.FIRST: return FLayer.GetValue(((int) field) - 1); case LayerTypes.MIDDLE: return MLayer.GetValue(((int) field) - 6); case LayerTypes.LAST: return LLayer.GetValue(((int) field) - 9); default: throw new YambException(""); } }
List<TypeDef> FindVmHandlerTypes() { var requiredFields = new string[] { null, "System.Collections.Generic.Dictionary`2<System.UInt16,System.Type>", "System.UInt16", }; var cflowDeobfuscator = new CflowDeobfuscator(); foreach (var type in module.Types) { var cctor = type.FindStaticConstructor(); if (cctor == null) continue; requiredFields[0] = type.FullName; var fieldTypes = new FieldTypes(type); if (!fieldTypes.All(requiredFields)) continue; cflowDeobfuscator.Deobfuscate(cctor); var handlers = FindVmHandlerTypes(cctor); if (handlers.Count < NUM_HANDLERS) continue; return handlers; } return null; }
private LayerTypes GetFieldsLayer(FieldTypes field) { int fieldNumberValue = (int)field; if (fieldNumberValue >= 1 && fieldNumberValue <= 6) { return LayerTypes.FIRST; } else if (fieldNumberValue == 7 || fieldNumberValue == 8) { return LayerTypes.MIDDLE; } else { return LayerTypes.LAST; } }
public int GetFieldValue(ColumnTypes column, LayerTypes layer, FieldTypes field) { switch (column) { case ColumnTypes.DOWN: return DownColumn.GetFieldValue(layer, field); case ColumnTypes.UP: return UpColumn.GetFieldValue(layer, field); case ColumnTypes.FREE: return FreeColumn.GetFieldValue(layer, field); case ColumnTypes.ANNOUNCEMENT: return AnnouncementColumn.GetFieldValue(layer, field); default: throw new YambException(""); } }
private void AnnouncementActions(IViewTableForm frmTableDisplay, FieldTypes field) { if (_announced) { _announced = false; _autoValueInput = false; NextTurn(); frmTableDisplay.EndOfTurnActions(); } else { _announcedField = field; _announced = true; _autoValueInput = true; } frmTableDisplay.AnnouncementDisplayActions(_announced); }
//Constructors public SecretField(FieldTypes type, SecretFields secretFieldName) { this.Type = type; this.SecretFieldName = secretFieldName; }
private void ProcessTick(int requestId, FieldTypes field, decimal price, decimal? volume) { var l1Msg = GetLevel1Message(requestId); switch (field) { case FieldTypes.BidPrice: case FieldTypes.BidVolume: l1Msg.TryAdd(Level1Fields.BestBidPrice, price); l1Msg.TryAdd(Level1Fields.BestBidVolume, volume); break; case FieldTypes.AskPrice: case FieldTypes.AskVolume: l1Msg.TryAdd(Level1Fields.BestAskPrice, price); l1Msg.TryAdd(Level1Fields.BestAskVolume, volume); break; case FieldTypes.LastPrice: case FieldTypes.LastVolume: l1Msg.TryAdd(Level1Fields.LastTradePrice, price); l1Msg.TryAdd(Level1Fields.LastTradeVolume, volume); break; case FieldTypes.OpenPrice: l1Msg.TryAdd(Level1Fields.OpenPrice, price); break; case FieldTypes.HighPrice: l1Msg.TryAdd(Level1Fields.HighPrice, price); break; case FieldTypes.LowPrice: l1Msg.TryAdd(Level1Fields.LowPrice, price); break; case FieldTypes.ClosePrice: l1Msg.TryAdd(Level1Fields.ClosePrice, price); break; case FieldTypes.Volume: l1Msg.TryAdd(Level1Fields.Volume, volume); break; case FieldTypes.OpenInterest: l1Msg.TryAdd(Level1Fields.OpenInterest, volume); break; case FieldTypes.OptionHistoricalVolatility: l1Msg.TryAdd(Level1Fields.HistoricalVolatility, price); break; case FieldTypes.OptionImpliedVolatility: l1Msg.TryAdd(Level1Fields.ImpliedVolatility, price); break; case FieldTypes.LastYield: l1Msg.TryAdd(Level1Fields.Yield, price); break; case FieldTypes.CustOptionComputation: break; case FieldTypes.TradeCount: l1Msg.TryAdd(Level1Fields.TradesCount, (int)(volume ?? 0)); break; //default: // throw new InvalidOperationException("Неизвестный тип поля {0} для инструмента {1}.".Put(priceField, security)); } SendOutMessage(l1Msg); }
private void picBox_rowMinUp_Click(object sender, EventArgs e) { SaveToTEMP(); inputFiledsColumn = ColumnTypes.UP; inputFieldType = FieldTypes.MIN; bool entered = game.EnterDiceValue(this, new frmConfirm(), ColumnTypes.UP, LayerTypes.MIDDLE, FieldTypes.MIN); if (!entered) { ReturnFromTEMP(); } }
public ProcessEditRetrieverMock(ProcessEdit process, FieldTypes fieldTypes) { this.LoadProperty(ProcessEditProperty, process); this.LoadProperty(FieldTypesProperty, fieldTypes); }