public IEnumerable <ITypedMemberDescriptor> Get(Specifier d) { if (_t == null) { yield break; } yield break; #if ENABLE_CSHARP_PROPERTY_PARSING foreach (var p in _t.GetProperties(BindingFlags.Public | BindingFlags.Instance)) { if (!p.CanRead || !p.GetGetMethod(true).IsPublic) { continue; } // we dont support recursion for now ... if (_t == p.PropertyType) { continue; } if (p.PropertyType.IsValueType != d.HasFlag(Specifier.ValueType)) { continue; } yield return(new PropertyMemberDescriptor(p)); } #endif }
public IEnumerable <ITypedMemberDescriptor> Get(Specifier d) { if (_t == null) { yield return(null); } foreach (var field in _t.GetFields()) { if (field.IsStatic) { continue; } if (field.FieldType.IsValueType != d.HasFlag(Specifier.ValueType)) { continue; } if (field.IsPublic && d.HasFlag(Specifier.Public)) { yield return(new FieldMemberDescriptor(field)); } if (!field.IsPublic && d.HasFlag(Specifier.Private)) { yield return(new FieldMemberDescriptor(field)); } } }
public Node(CXCursor cursor, CXCursorKind type, Specifier specifier, string name, string full_name, string value, int line, int column) { m_cursor = cursor; m_kind = type; m_name = name; m_full_name = full_name; m_line = line; m_column = column; m_specifier = specifier; m_childrens = new List <Node>(); }
public bool IsHomogeneous(Specifier type) { foreach (var element in contents) { if (!Shell.Interpreter.Utility.MatchType(element, type)) { return(false); } } return(true); }
public List <Specifier> ParseSpecifiers(List <TokenType> specifierCategory) { List <Specifier> specs = new List <Specifier>(); Specifier spec = TryParseSpecifier(specifierCategory); while (spec != null) { specs.Add(spec); spec = TryParseSpecifier(specifierCategory); } return(specs); }
public bool IsHomogeneous(Specifier type) { foreach (var pair in dict) { if (!Shell.Interpreter.Utility.MatchType(pair.Value, type)) { return(false); } } return(true); }
private void AddFakeMarkets( List <CreateUpdateMarketsCommandSelection> marketsBuilder, Specifier specifier, IList <decimal?> selection, Dictionary <string, TranslationMarket> currentMarkets, string fakeMarketId, long originalMarketId ) { if (!marketGroups.TryGetValue(Convert.ToInt32(selection[0]), out var selectionTypeId)) // index 0 - outcome_id { selectionTypeId = Convert.ToInt32(selection[0]); } var specifiers = specifier == null ? null : new SpecifierCollection(specifier); var currentMarketId = fakeMarketId + (specifier == null ? "" : ":" + specifier.Key + "=" + specifier.Value); var currentSelectionId = fakeMarketId + ":" + selectionTypeId + (specifier == null ? "" : ":" + specifier.Key + "=" + specifier.Value); // adding market to cache currentMarkets.TryAdd( currentSelectionId, new TranslationMarket() { Id = originalMarketId, FakeId = currentMarketId, SelectionId = selectionTypeId, SpecifierValue = specifier?.Value } ); marketsBuilder.Add ( new CreateUpdateMarketsCommandSelection ( marketId: currentMarketId, marketTypeId: originalMarketId.ToString(), selectionId: currentSelectionId, specifiers: specifiers, selectionTypeId: selectionTypeId.ToString(), tradingStatus: TradingStatus.Open, selectionTradingStatus: TradingStatus.Open, value: Round2(selection[1]), probability: null ) ); }
public string Description(bool spellOutWhitespace) { // here be dragons! // keep track of: // - escaped chars // - escape sequences (each having a different description) // - codepoint escapes (belongs into above category but kept separate) // - and actually boring literal matches if (Specifier.Length > 1) { var relevant = Specifier.Substring(1); // skip the damn Backslash at the start if (relevant.Length > 1) // longer sequences { if (relevant.StartsWith("u")) { return(string.Format(AssistantResources.AtomDescription_Literal_UnicodePoint, relevant.Substring(1))); //skip u } if (relevant.StartsWith("x")) { return(string.Format(AssistantResources.AtomDescription_Literal_HexCodepoint, relevant.Substring(1))); // skip x } return(string.Format(AssistantResources.AtomDescription_Literal_OctalCodepoint, relevant)); // no format specifier to skip } if (EscapeLiterals.Contains(relevant[0])) { return(string.Format(AssistantResources.AtomDescription_Literal_EscapedLiteral, relevant)); } if (char.IsDigit(relevant[0])) { return(string.Format(AssistantResources.AtomDescription_Literal_Backreference, relevant)); } return(_escapeDescriptions[relevant[0]]); } if (Specifier.Equals(".")) { return(AssistantResources.AtomDescription_Dot); } return(string.Format(AssistantResources.AtomDescription_Literal_ActualLiteral, spellOutWhitespace && WhitespaceToString.IsFullySpellingOutApplicable(Specifier, out var spelledOutWhiteSpace) ? spelledOutWhiteSpace : Specifier)); }
//============================================================================== /// <summary> /// /// </summary> //============================================================================== private void aggregateValues() { TMainOutputSpecifier Specifier; TDDMLValue requestValue; TDDMLValue outputValue; for (int i = 0; i < FOutputs.Count; i++) { Specifier = (TMainOutputSpecifier)FOutputs[i]; requestValue = FRequests[Specifier.iReqIdx]; outputValue = Specifier.FindValue(requestValue); if (outputValue != null) { aggregateValue(outputValue, Specifier.valTree); } else { throw (new ApplicationException("Output value not found: " + Specifier.sName)); } } }
static bool MatchObj(VerbParameters param, Mob m, Specifier spec) { if (spec == Specifier.Wildcard) return true; if (spec == Specifier.Any) return m != null && m != Mob.None; if (spec == Specifier.Self) return m != null && m.id == param.self.id; if (spec == Specifier.None && (m == null || m == Mob.None)) { return true; } return false; }
public IEnumerable <ITransmitterCommand> Adapt(MessageContext <EventData, TranslationSubscription> context) { var msg = context.Message; var translationState = context.State.PersistableState; var translationId = long.Parse(msg.TranslationId); var lineService = LineService.SportLevel; var marketsBuilder = new List <CreateUpdateMarketsCommandSelection>(); var list = new List <ITransmitterCommand>(); var currentMarkets = new Dictionary <string, TranslationMarket>(); foreach (var market in msg.Extra.Markets) { var fakeMarketId = $"{lineService}:{msg.TranslationId}:{market.Id}"; var specifierKey = adapterConfiguration.Specifiers.Total.Contains(market.Id) ? SpecifierKey.Total : adapterConfiguration.Specifiers.Hcp.Contains(market.Id) ? SpecifierKey.Handicap : adapterConfiguration.Specifiers.Pointnr.Contains(market.Id) ? SpecifierKey.PointNumber : null; // Outcomes if (market.Selections.Any()) { var arr = market.Selections.ToArray(); // Not categorized market with specifiers if (arr.Any(t => t[2].HasValue) && specifierKey == null) { logger.LogWarning($"Uncategorized market with specifiers was detected. MessageId={context.IncomingId}, marketId={market.Id}"); continue; // to next market } Specifier hcpOldSpecifier = null; for (int i = 0; i < arr.Count(); i++) { Specifier specifier = null; var item = arr[i]; if (specifierKey != null) { if (i % 2 == 1 && specifierKey == SpecifierKey.Handicap) { specifier = hcpOldSpecifier; } else { specifier = item[2].HasValue ? GetSpecifier(specifierKey, item[2].Value) : null; } } // Creating markets AddFakeMarkets( marketsBuilder, specifier, item, currentMarkets, fakeMarketId, market.Id ); hcpOldSpecifier = specifier; } } } // Markets to state foreach (var item in currentMarkets) { translationState.Markets.GetOrAdd(item.Key, item.Value); } lock (translationState.Markets) { // Susupensing markets which are left foreach (var fakeId in translationState.Markets.Keys.Except(currentMarkets.Select(t => t.Key))) { var entry = translationState.Markets[fakeId]; marketsBuilder.Add( new CreateUpdateMarketsCommandSelection ( marketId: entry.FakeId, marketTypeId: entry.Id.ToString(), selectionId: fakeId, specifiers: entry.SpecifierValue == null ? null : new SpecifierCollection(GetSpecifier(entry.Id, translationState.Markets[fakeId].SpecifierValue, adapterConfiguration)), selectionTypeId: entry.SelectionId.ToString(), tradingStatus: TradingStatus.Suspended, selectionTradingStatus: TradingStatus.Suspended, value: null, probability: null ) ); } } list.Add( new CreateUpdateMarketsCommand( lineService: lineService, gameEventId: msg.TranslationId.ToString(), receivedOn: context.ReceivedOn, incomingId: context.IncomingId, selections: marketsBuilder.ToImmutableArray(), extraAttributes: null ) ); context.State.SaveState(); return(list); }
public override int GetHashCode() { return(Specifier.GetHashCode()); }
void ParseTypeDefinition(List<INamespaceDeclarationMember> members, List<ITypeDeclarationMember> globalMembers, TokenSet followers, bool isRecord) { var noSpecifiers = new Specifier[0]; var name = this.ParseNameDeclaration(true); var loc = name.SourceLocation; var name0 = name.Name.Value; var mangledName = new VccNameDeclaration(this.GetNameFor("_vcc_math_type_" + name0), loc); var tpMembers = new List<ITypeDeclarationMember>(); var strct = new VccStructDeclaration(mangledName, tpMembers, noSpecifiers, loc); var tp = new VccNamedTypeExpression(new VccSimpleName(mangledName, mangledName.SourceLocation)); UpdateForwardDeclaration(members, strct); if (isRecord) { List<FieldDeclaration>/*?*/ savedSpecificationFields = this.currentSpecificationFields; List<TypeInvariant>/*?*/ savedTypeInvariants = this.currentTypeInvariants; this.currentSpecificationFields = null; this.currentTypeInvariants = null; SourceLocationBuilder sctx = this.GetSourceLocationBuilderForLastScannedToken(); this.ParseRestOfTypeDeclaration(sctx, members, tp.Expression, tpMembers, followers); if (this.currentToken == Token.EndOfFile) { ISourceLocation errorLocation = this.scanner.SourceLocationOfLastScannedToken; this.HandleError(errorLocation, Error.MissingSemicolonAfterStruct, "end-of-file"); } this.SkipTo(followers); this.AssociateTypeWithTypeContract(strct, this.currentSpecificationFields, this.currentTypeInvariants, this.InSpecCode); this.currentSpecificationFields = savedSpecificationFields; this.currentTypeInvariants = savedTypeInvariants; } else { strct.IsAbstractType = true; /* var fld = new FieldDefinition(new List<Specifier>(), 0, VccCompilationHelper.GetBigIntType(nameTable), new VccNameDeclaration(this.GetNameFor("_vcc_dummy"), loc), null, true, loc); tpMembers.Add(fld); */ } var typedefDecl = new TypedefDeclaration(tp, name, loc); this.RegisterTypedef(name.Value, typedefDecl); globalMembers.Add(typedefDecl); }
void ParseDataTypeDefinition(List<INamespaceDeclarationMember> members, List<ITypeDeclarationMember> globalMembers, TokenSet followers) { var noSpecifiers = new Specifier[0]; var name = this.ParseNameDeclaration(true); var loc = name.SourceLocation; var mangledName = new VccNameDeclaration(this.GetNameFor("_vcc_math_type_" + name.Name.Value), loc); var ctornames = new List<FunctionDeclaration>(); var strct = new VccDatatypeDeclaration(mangledName, new List<ITypeDeclarationMember>(), noSpecifiers, ctornames, loc); UpdateForwardDeclaration(members, strct); var tp = new VccNamedTypeExpression(new VccSimpleName(mangledName, mangledName.SourceLocation)); var typedefDecl = new TypedefDeclaration(tp, name, loc); this.RegisterTypedef(name.Value, typedefDecl); globalMembers.Add(typedefDecl); this.Skip(Token.LeftBrace); for (; ; ) { SourceLocationBuilder scCtx = this.GetSourceLocationBuilderForLastScannedToken(); if (this.currentToken != Token.Case) { this.Skip(this.currentToken == Token.RightBrace ? Token.RightBrace : Token.Case); break; } this.Skip(Token.Case); var fname = this.ParseNameDeclaration(true); var parmFollowers = followers | Token.RightBrace | Token.Case | Token.Semicolon; var parms0 = this.ParseParameterList(parmFollowers); this.Skip(Token.RightParenthesis); if (this.currentToken == Token.Semicolon) this.Skip(Token.Semicolon); bool acceptsExtraArguments; var parms1 = this.ConvertToParameterDeclarations(parms0, out acceptsExtraArguments); var specifiers = new[] { this.CreateAttribute("_vcc_internal__is_datatype_option", "", scCtx) }; var fdecl = new FunctionDeclaration(acceptsExtraArguments, specifiers, false, CallingConvention.C, TypeMemberVisibility.Public, tp, fname, null, parms1, true, null, scCtx ); globalMembers.Add(fdecl); ctornames.Add(fdecl); } if (ctornames.Count == 0) this.HandleError(Error.EmptySwitch); //TODO use proper error }