/// <summary> /// Get all posts. This is rate-limited to once every 60 seconds and will return a 429 error if you exceed that /// </summary> /// <param name="Tags"></param> /// <param name="Start">Offset to start from - default is 0</param> /// <param name="Results">Number of posts to return - default is all</param> /// <param name="FromDate">Return only bookmarks created after this time</param> /// <param name="ToDate">Return only bookmarks created before this time</param> /// <param name="ChangedMeta">Include the "meta" attribute in the response</param> /// <returns>A list of Posts</returns> public async Task <IRestResponse <List <Post> > > GetAllPostsAsync(List <Tag> Tags = null, int?Start = null, int?Results = null, DateTime?FromDate = null, DateTime?ToDate = null, bool ChangedMeta = false) { RestRequest getPostsReq = new RestRequest("/posts/all"); getPostsReq.RequestFormat = DataFormat.Json; if (Tags != null) { getPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("tag", Tags)); } if (Start.HasValue) { getPostsReq.AddParameter("start", Start); } if (Results.HasValue) { getPostsReq.AddParameter("results", Results); } if (FromDate.HasValue) { getPostsReq.AddParameter("fromdt", FromDate); } if (ToDate.HasValue) { getPostsReq.AddParameter("todt", ToDate); } return(await ExecuteAsync <List <Post> >(getPostsReq)); }
private void ProcessDateFilter(Property property, DateTime?datetime) { if (datetime != null) { AddPipelineFilter(property, ParameterHelpers.DateToString(datetime.Value), false); } }
private DateTime?GetDateTime(Property property) { var val = GetFilterValue(property); if (val == null) { return(null); } return(ParameterHelpers.StringToDate(val.ToString())); }
public void TestValueToGet() { //var stringParam = ParameterHelpers.ValueToGetArgument("string", "string"); var boolParam = ParameterHelpers.ValueToGetArgument("didThisWork", true); var dateTimeParam = ParameterHelpers.ValueToGetArgument("letsParty", new DateTime(1999, 12, 31)); var tags = new List <Tag>(); tags.Add(new Tag("something")); tags.Add(new Tag("else")); var tagParam = ParameterHelpers.ValueToGetArgument("tags", tags); Assert.AreEqual(boolParam.ToString(), "didThisWork=yes"); Assert.AreEqual(dateTimeParam.ToString(), "letsParty=1999-12-31T00:00:00Z"); Assert.AreEqual(tagParam.ToString(), "tags=something else"); }
private static void MustBeInASaneOrder(SyntaxNodeAnalysisContext syntaxNodeAnalysisContext) { if (syntaxNodeAnalysisContext.Node is not ParameterListSyntax parameterList) { return; } var parameters = parameterList.Parameters.Select((parameter, index) => new { Parameter = parameter, Index = index, FullTypeName = ParameterHelpers.GetFullTypeName( syntaxNodeAnalysisContext: syntaxNodeAnalysisContext, parameterSyntax: parameter) }) .ToArray(); List <string> matchedEndings = new(); foreach (string parameterType in PreferredEndingOrdering.Reverse()) { var matchingParameter = Array.Find(array: parameters, match: x => x.FullTypeName == parameterType); if (matchingParameter == null) { continue; } if (matchingParameter.Parameter.Modifiers.Any(pm => pm.IsKind(SyntaxKind.ThisKeyword))) { // Ignore parameters that are extension methods - they have to be the first parameter continue; } matchedEndings.Add(parameterType); int parameterIndex = matchingParameter.Index; int requiredParameterIndex = parameters.Length - matchedEndings.Count; if (parameterIndex != requiredParameterIndex) { syntaxNodeAnalysisContext.ReportDiagnostic(Diagnostic.Create(descriptor: Rule, matchingParameter.Parameter.GetLocation(), matchingParameter.Parameter.Identifier.Text, requiredParameterIndex + 1)); } } }
private DateTime?GetDateTime(Property property) { var val = GetFilterValue(property); if (val == null) { return(null); } if (val is DateTime) { return((DateTime?)val); } //We're retrieving a DateTime we serialized previously return(ParameterHelpers.StringToDate(val.ToString())); }
private void EnsureAttributesExist(TypeCompilationState compilationState) { var moduleBuilder = compilationState.ModuleBuilderOpt; if (moduleBuilder is null) { return; } if (RefKind == RefKind.RefReadOnly) { moduleBuilder.EnsureIsReadOnlyAttributeExists(); } ParameterHelpers.EnsureIsReadOnlyAttributeExists(moduleBuilder, Parameters); if (moduleBuilder.Compilation.ShouldEmitNativeIntegerAttributes()) { if (ReturnType.ContainsNativeIntegerWrapperType()) { moduleBuilder.EnsureNativeIntegerAttributeExists(); } ParameterHelpers.EnsureNativeIntegerAttributeExists(moduleBuilder, Parameters); } ParameterHelpers.EnsureLifetimeAnnotationAttributeExists(moduleBuilder, Parameters); if (compilationState.Compilation.ShouldEmitNullableAttributes(this)) { if (ShouldEmitNullableContextValue(out _)) { moduleBuilder.EnsureNullableContextAttributeExists(); } if (ReturnTypeWithAnnotations.NeedsNullableAttribute()) { moduleBuilder.EnsureNullableAttributeExists(); } } ParameterHelpers.EnsureNullableAttributeExists(moduleBuilder, this, Parameters); }
/// <summary> /// Get posts - filtered by URL, tags or date /// </summary> /// <param name="Tags">A list of up to 3 tags</param> /// <param name="CreatedDate">Return posts created on this date</param> /// <param name="URL">Return the post with this URL</param> /// <param name="ChangedMeta">Include the "meta" attribute in the response</param> /// <returns>A list of Post objects</returns> public async Task <IRestResponse <List <Post> > > GetPostsAsync(List <Tag> Tags = null, DateTime?CreatedDate = null, string URL = null, bool ChangedMeta = false) { RestRequest GetPostsReq = new RestRequest("/posts/get"); if (Tags != null) { GetPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("tags", Tags)); } if (CreatedDate.HasValue) { GetPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("dt", CreatedDate.Value)); } if (URL != null) { GetPostsReq.AddParameter("url", URL); } GetPostsReq.AddParameter(ParameterHelpers.ValueToGetArgument("meta", ChangedMeta)); return(await ExecuteAsync <List <Post> >(GetPostsReq)); }
protected override ReadOnlyArray <ParameterSymbol> MakeParameters( Binder binder, DelegateDeclarationSyntax syntax, DiagnosticBag diagnostics) { SyntaxToken extensionMethodThis; SyntaxToken arglistToken; var parameters = ParameterHelpers.MakeParameters(binder, this, syntax.ParameterList, true, out extensionMethodThis, out arglistToken, diagnostics); if (arglistToken.Kind == SyntaxKind.ArgListKeyword) { // This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn. // error CS1669: __arglist is not valid in this context diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken)); } return(parameters); }
public void SystemInfo_Software_PropertiesMapCorrectly() { var name = "\"Name\""; var vendor = "\"Vendor\""; var version = "1.2"; var date = "\"2017-05-23-00-00-00\""; var size = "1234"; var displayName = "\"DisplayName\""; var obj = GetSystemInfoResponse <DeviceSoftwareInfo>( SystemInfoItem.SoftwareItem(name, vendor, version, date, size, displayName) ); AssertAreEqual(name, obj.Name); AssertAreEqual(vendor, obj.Vendor); AssertAreEqual(Version.Parse(version), obj.Version); AssertAreEqual(ParameterHelpers.StringToDate(date.Trim('"')), obj.InstallDate); AssertAreEqual(Convert.ToInt32(size), obj.Size); AssertAreEqual(displayName, obj.DisplayName); }
/// <summary> /// Adds a post based on the querystring we pass /// </summary> /// <param name="newPost">The post to add</param> /// <returns>PinboardResponse</returns> public async Task <IRestResponse <PinboardResponse> > AddPostAsync(Post newPost) { RestRequest AddPostRequest = new RestRequest("/posts/add"); if (newPost.Href != null) { AddPostRequest.AddParameter("url", newPost.Href); } if (newPost.Description != null) { AddPostRequest.AddParameter("description", newPost.Description); } if (newPost.Extended != null) { AddPostRequest.AddParameter("extended", newPost.Extended); } if (newPost.Tag != null) { AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("tags", newPost.Tag)); } if (newPost.CreationTime.HasValue) { AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("dt", newPost.CreationTime)); } if (newPost.Replace != null) { AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("replace", newPost.Replace)); } if (newPost.Shared != null) { AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("shared", newPost.Shared)); } if (newPost.ToRead != null) { AddPostRequest.AddParameter(ParameterHelpers.ValueToGetArgument("toread", newPost.ToRead)); } return(await ExecuteAsync <PinboardResponse>(AddPostRequest)); }
// An anonymous function can be of the form: // // delegate { } (missing parameter list) // delegate (int x) { } (typed parameter list) // x => ... (type-inferred parameter list) // (x) => ... (type-inferred parameter list) // (x, y) => ... (type-inferred parameter list) // ( ) => ... (typed parameter list) // (ref int x) => ... (typed parameter list) // (int x, out int y) => ... (typed parameter list) // // and so on. We want to canonicalize these various ways of writing the signatures. // // If we are in the first case then the name, modifier and type arrays are all null. // If we have a parameter list then the names array is non-null, but possibly empty. // If we have types then the types array is non-null, but possibly empty. // If we have no modifiers then the modifiers array is null; if we have any modifiers // then the modifiers array is non-null and not empty. private UnboundLambda AnalyzeAnonymousFunction( AnonymousFunctionExpressionSyntax syntax, BindingDiagnosticBag diagnostics) { Debug.Assert(syntax != null); Debug.Assert(syntax.IsAnonymousFunction()); ImmutableArray <string> names = default; ImmutableArray <RefKind> refKinds = default; ImmutableArray <DeclarationScope> scopes = default; ImmutableArray <TypeWithAnnotations> types = default; RefKind returnRefKind = RefKind.None; TypeWithAnnotations returnType = default; ImmutableArray <SyntaxList <AttributeListSyntax> > parameterAttributes = default; var namesBuilder = ArrayBuilder <string> .GetInstance(); ImmutableArray <bool> discardsOpt = default; SeparatedSyntaxList <ParameterSyntax>?parameterSyntaxList = null; bool hasSignature; if (syntax is LambdaExpressionSyntax lambdaSyntax) { checkAttributes(syntax, lambdaSyntax.AttributeLists, diagnostics); } switch (syntax.Kind()) { default: case SyntaxKind.SimpleLambdaExpression: // x => ... hasSignature = true; var simple = (SimpleLambdaExpressionSyntax)syntax; namesBuilder.Add(simple.Parameter.Identifier.ValueText); break; case SyntaxKind.ParenthesizedLambdaExpression: // (T x, U y) => ... // (x, y) => ... hasSignature = true; var paren = (ParenthesizedLambdaExpressionSyntax)syntax; if (paren.ReturnType is { } returnTypeSyntax) { (returnRefKind, returnType) = BindExplicitLambdaReturnType(returnTypeSyntax, diagnostics); } parameterSyntaxList = paren.ParameterList.Parameters; CheckParenthesizedLambdaParameters(parameterSyntaxList.Value, diagnostics); break; case SyntaxKind.AnonymousMethodExpression: // delegate (int x) { } // delegate { } var anon = (AnonymousMethodExpressionSyntax)syntax; hasSignature = anon.ParameterList != null; if (hasSignature) { parameterSyntaxList = anon.ParameterList !.Parameters; } break; } var isAsync = syntax.Modifiers.Any(SyntaxKind.AsyncKeyword); var isStatic = syntax.Modifiers.Any(SyntaxKind.StaticKeyword); if (parameterSyntaxList != null) { var hasExplicitlyTypedParameterList = true; var typesBuilder = ArrayBuilder <TypeWithAnnotations> .GetInstance(); var refKindsBuilder = ArrayBuilder <RefKind> .GetInstance(); var scopesBuilder = ArrayBuilder <DeclarationScope> .GetInstance(); var attributesBuilder = ArrayBuilder <SyntaxList <AttributeListSyntax> > .GetInstance(); // In the batch compiler case we probably should have given a syntax error if the // user did something like (int x, y)=>x+y -- but in the IDE scenario we might be in // this case. If we are, then rather than try to make partial deductions from the // typed formal parameters, simply bail out and treat it as an untyped lambda. // // However, we still want to give errors on every bad type in the list, even if one // is missing. int underscoresCount = 0; foreach (var p in parameterSyntaxList.Value) { if (p.Identifier.IsUnderscoreToken()) { underscoresCount++; } checkAttributes(syntax, p.AttributeLists, diagnostics); if (p.Default != null) { Error(diagnostics, ErrorCode.ERR_DefaultValueNotAllowed, p.Default.EqualsToken); } if (p.IsArgList) { Error(diagnostics, ErrorCode.ERR_IllegalVarArgs, p); continue; } var typeSyntax = p.Type; TypeWithAnnotations type = default; var refKind = RefKind.None; var scope = DeclarationScope.Unscoped; if (typeSyntax == null) { hasExplicitlyTypedParameterList = false; } else { type = BindType(typeSyntax, diagnostics); ParameterHelpers.CheckParameterModifiers(p, diagnostics, parsingFunctionPointerParams: false, parsingLambdaParams: true); refKind = ParameterHelpers.GetModifiers(p.Modifiers, out _, out _, out _, out scope); } namesBuilder.Add(p.Identifier.ValueText); typesBuilder.Add(type); refKindsBuilder.Add(refKind); scopesBuilder.Add(scope); attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default);
private BoundLambda ReallyBind(NamedTypeSymbol delegateType) { var invokeMethod = DelegateInvokeMethod(delegateType); RefKind refKind; var returnType = DelegateReturnType(invokeMethod, out refKind); LambdaSymbol lambdaSymbol; Binder lambdaBodyBinder; BoundBlock block; var diagnostics = DiagnosticBag.GetInstance(); // when binding for real (not for return inference), there is still // a good chance that we could reuse a body of a lambda previously bound for // return type inference. var cacheKey = ReturnInferenceCacheKey.Create(delegateType, IsAsync); BoundLambda returnInferenceLambda; if (_returnInferenceCache.TryGetValue(cacheKey, out returnInferenceLambda) && returnInferenceLambda.InferredFromSingleType) { lambdaSymbol = returnInferenceLambda.Symbol; if ((object)LambdaSymbol.InferenceFailureReturnType != lambdaSymbol.ReturnType && lambdaSymbol.ReturnType == returnType && lambdaSymbol.RefKind == refKind) { lambdaBodyBinder = returnInferenceLambda.Binder; block = returnInferenceLambda.Body; diagnostics.AddRange(returnInferenceLambda.Diagnostics); goto haveLambdaBodyAndBinders; } } lambdaSymbol = new LambdaSymbol( binder.Compilation, binder.ContainingMemberOrLambda, _unboundLambda, cacheKey.ParameterTypes, cacheKey.ParameterRefKinds, refKind, returnType, diagnostics); lambdaBodyBinder = new ExecutableCodeBinder(_unboundLambda.Syntax, lambdaSymbol, ParameterBinder(lambdaSymbol, binder)); if (lambdaSymbol.RefKind == CodeAnalysis.RefKind.RefReadOnly) { binder.Compilation.EnsureIsReadOnlyAttributeExists(diagnostics, lambdaSymbol.DiagnosticLocation, modifyCompilationForRefReadOnly: false); } ParameterHelpers.EnsureIsReadOnlyAttributeExists(lambdaSymbol.Parameters, diagnostics, modifyCompilationForRefReadOnly: false); block = BindLambdaBody(lambdaSymbol, lambdaBodyBinder, diagnostics); ((ExecutableCodeBinder)lambdaBodyBinder).ValidateIteratorMethods(diagnostics); ValidateUnsafeParameters(diagnostics, cacheKey.ParameterTypes); haveLambdaBodyAndBinders: bool reachableEndpoint = ControlFlowPass.Analyze(binder.Compilation, lambdaSymbol, block, diagnostics); if (reachableEndpoint) { if (DelegateNeedsReturn(invokeMethod)) { // Not all code paths return a value in {0} of type '{1}' diagnostics.Add(ErrorCode.ERR_AnonymousReturnExpected, lambdaSymbol.DiagnosticLocation, this.MessageID.Localize(), delegateType); } else { block = FlowAnalysisPass.AppendImplicitReturn(block, lambdaSymbol); } } if (IsAsync && !ErrorFacts.PreventsSuccessfulDelegateConversion(diagnostics)) { if ((object)returnType != null && // Can be null if "delegateType" is not actually a delegate type. returnType.SpecialType != SpecialType.System_Void && !returnType.IsNonGenericTaskType(binder.Compilation) && !returnType.IsGenericTaskType(binder.Compilation)) { // Cannot convert async {0} to delegate type '{1}'. An async {0} may return void, Task or Task<T>, none of which are convertible to '{1}'. diagnostics.Add(ErrorCode.ERR_CantConvAsyncAnonFuncReturns, lambdaSymbol.DiagnosticLocation, lambdaSymbol.MessageID.Localize(), delegateType); } } if (IsAsync) { Debug.Assert(lambdaSymbol.IsAsync); SourceOrdinaryMethodSymbol.ReportAsyncParameterErrors(lambdaSymbol.Parameters, diagnostics, lambdaSymbol.DiagnosticLocation); } var result = new BoundLambda(_unboundLambda.Syntax, block, diagnostics.ToReadOnlyAndFree(), lambdaBodyBinder, delegateType, inferReturnType: false) { WasCompilerGenerated = _unboundLambda.WasCompilerGenerated }; return(result); }
protected string LogDate(DateTime date) { return(ParameterHelpers.DateToString(date)); }
private static string GetTime(DateTime dateTime) { return(ParameterHelpers.DateToString(dateTime)); }
private DateTime GetDate(Parameter parameter) { return(ParameterHelpers.StringToDate(this[parameter].ToString())); }
private void SetDate(Parameter parameter, DateTime value) { this[parameter] = ParameterHelpers.DateToString(value); }
private void SetDateTime(Property property, DateTime?value) { SetFilterValue(property, value == null ? null : ParameterHelpers.DateToString(value.Value)); }
internal virtual DateTime FormatDate(string value) { return(ParameterHelpers.StringToDate(value)); }