/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (InternetContent.IsAccepted(JsonContentTypes, AcceptedContentTypes)) { if (Object is IEnumerable <KeyValuePair <string, object> > ) { Grade = Grade.Ok; return(true); } else if (Object == null || Object is IEnumerable || Object is string || Object is bool || Object is decimal || Object is double || Object is float || Object is int || Object is long || Object is short || Object is byte || Object is uint || Object is ulong || Object is ushort || Object is sbyte || Object is char) { Grade = Grade.Barely; return(true); } } Grade = Grade.NotAtAll; return(false); }
public void LWM2M_TLV_Test_07_Decode_BootstrapInfo() { byte[] Tlv = new byte[] { 0xc8, 0x00, 0x1e, 0x63, 0x6f, 0x61, 0x70, 0x3a, 0x2f, 0x2f, 0x6c, 0x65, 0x73, 0x68, 0x61, 0x6e, 0x2e, 0x65, 0x63, 0x6c, 0x69, 0x70, 0x73, 0x65, 0x2e, 0x6f, 0x72, 0x67, 0x3a, 0x35, 0x36, 0x38, 0x33, 0xc1, 0x01, 0x01, 0xc1, 0x02, 0x03, 0xc0, 0x03, 0xc0, 0x04, 0xc0, 0x05, 0xc1, 0x06, 0x03, 0xc0, 0x07, 0xc0, 0x08, 0xc0, 0x09, 0xc1, 0x0a, 0x6f, 0xc1, 0x0b, 0x01, 0xc1, 0x0c, 0x00 }; object Decoded = InternetContent.Decode(TlvDecoder.ContentType, Tlv, null); Assert.IsNotNull(Decoded); TlvRecord[] Records = Decoded as TlvRecord[]; Assert.IsNotNull(Records); foreach (TlvRecord Record in Records) { Console.Out.WriteLine(Record.ToString()); } }
/// <summary> /// Encodes an object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Encoding">Desired encoding of text. Can be null if no desired encoding is speified.</param> /// <param name="ContentType">Content Type of encoding. Includes information about any text encodings used.</param> /// <returns>Encoded object.</returns> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <exception cref="ArgumentException">If the object cannot be encoded.</exception> public byte[] Encode(object Object, Encoding Encoding, out string ContentType, params string[] AcceptedContentTypes) { SKData Data; bool Dispose = false; byte[] Bin; if (!(Object is SKImage Image)) { if (Object is SKBitmap Bitmap) { Image = SKImage.FromBitmap(Bitmap); Dispose = true; } else { throw new ArgumentException("Object not an image derived from SkiaSharp.SKImage or SkiaSharp.SKBitmap.", nameof(Object)); } } if (InternetContent.IsAccepted("image/png", AcceptedContentTypes)) { Data = Image.Encode(SKEncodedImageFormat.Png, 100); ContentType = "image/png"; } else if (InternetContent.IsAccepted("image/bmp", AcceptedContentTypes)) { Data = Image.Encode(SKEncodedImageFormat.Bmp, 100); ContentType = "image/bmp"; } else if (InternetContent.IsAccepted("image/jpeg", AcceptedContentTypes)) { Data = Image.Encode(SKEncodedImageFormat.Jpeg, 90); ContentType = "image/jpeg"; } else if (InternetContent.IsAccepted("image/gif", AcceptedContentTypes)) { Data = Image.Encode(SKEncodedImageFormat.Gif, 100); ContentType = "image/gif"; } else if (InternetContent.IsAccepted("image/x-icon", AcceptedContentTypes)) { Data = Image.Encode(SKEncodedImageFormat.Ico, 100); ContentType = "image/x-icon"; } else { throw new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object)); } Bin = Data.ToArray(); Data.Dispose(); if (Dispose) { Image.Dispose(); } return(Bin); }
/// <summary> /// Performs the actual conversion. /// </summary> /// <param name="FromContentType">Content type of the content to convert from.</param> /// <param name="From">Stream pointing to binary representation of content.</param> /// <param name="FromFileName">If the content is coming from a file, this parameter contains the name of that file. /// Otherwise, the parameter is the empty string.</param> /// <param name="LocalResourceName">Local resource name of file, if accessed from a web server.</param> /// <param name="URL">URL of resource, if accessed from a web server.</param> /// <param name="ToContentType">Content type of the content to convert to.</param> /// <param name="To">Stream pointing to where binary representation of content is to be sent.</param> /// <param name="Session">Session states.</param> /// <returns>If the result is dynamic (true), or only depends on the source (false).</returns> public bool Convert(string FromContentType, Stream From, string FromFileName, string LocalResourceName, string URL, string ToContentType, Stream To, Variables Session) { string Script; using (StreamReader rd = new StreamReader(From)) { Script = rd.ReadToEnd(); } Expression Exp = new Expression(Script); if (Session is null) { Session = new Variables(); } object Result = Exp.Evaluate(Session); if (!InternetContent.Encodes(Result, out Grade _, out IContentEncoder Encoder, ToContentType)) { throw new NotAcceptableException("Unable to encode objects of type " + Result.GetType().FullName + " to Internet Content Type " + ToContentType); } byte[] Data = Encoder.Encode(Result, Encoding.UTF8, out string _, ToContentType); To.Write(Data, 0, Data.Length); return(true); }
/// <summary> /// Downloads a certificate. /// </summary> /// <param name="AccountLocation">Account location.</param> /// <param name="CertificateLocation">URI of certificate.</param> /// <returns>Certificate chain.</returns> public async Task <X509Certificate2[]> DownloadCertificate(Uri AccountLocation, Uri CertificateLocation) { string ContentType = PemDecoder.ContentType; HttpResponseMessage Response = await this.HttpPost(CertificateLocation, AccountLocation, ContentType, null); Response.EnsureSuccessStatusCode(); byte[] Bin = await Response.Content.ReadAsByteArrayAsync(); if (Response.Headers.TryGetValues("Content-Type", out IEnumerable <string> Values)) { foreach (string s in Values) { ContentType = s; break; } } object Decoded = InternetContent.Decode(ContentType, Bin, CertificateLocation); if (!(Decoded is X509Certificate2[] Certificates)) { throw new Exception("Unexpected response returned. Content-Type: " + ContentType); } return(Certificates); }
/// <summary> /// Gets a resource, using a Uniform Resource Identifier (or Locator). /// </summary> /// <param name="Uri">URI</param> /// <param name="TimeoutMs">Timeout, in milliseconds.</param> /// <param name="Headers">Optional headers. Interpreted in accordance with the corresponding URI scheme.</param> /// <returns>Decoded object.</returns> public async Task <object> GetAsync(Uri Uri, int TimeoutMs, params KeyValuePair <string, string>[] Headers) { using (HttpClient HttpClient = new HttpClient() { Timeout = TimeSpan.FromMilliseconds(TimeoutMs) }) { using (HttpRequestMessage Request = new HttpRequestMessage() { RequestUri = Uri, Method = HttpMethod.Get }) { PrepareHeaders(Request, Headers); HttpResponseMessage Response = await HttpClient.SendAsync(Request); Response.EnsureSuccessStatusCode(); byte[] Bin = await Response.Content.ReadAsByteArrayAsync(); string ContentType = Response.Content.Headers.ContentType.ToString(); object Decoded = InternetContent.Decode(ContentType, Bin, Uri); return(Decoded); } } }
/// <summary> /// Gets a resource, using a Uniform Resource Identifier (or Locator). /// </summary> /// <param name="Uri">URI</param> /// <param name="TimeoutMs">Timeout, in milliseconds. (Default=60000)</param> /// <param name="Headers">Optional headers. Interpreted in accordance with the corresponding URI scheme.</param> /// <exception cref="InvalidOperationException">No <see cref="HttpxProxy"/> set in the HTTPX <see cref="Types"/> module parameter.</exception> /// <exception cref="ArgumentException">If the <paramref name="Uri"/> parameter is invalid.</exception> /// <exception cref="ArgumentException">If the object response be decoded.</exception> /// <exception cref="ConflictException">If an approved presence subscription with the remote entity does not exist.</exception> /// <exception cref="ServiceUnavailableException">If the remote entity is not online.</exception> /// <exception cref="TimeoutException">If the request times out.</exception> /// <exception cref="OutOfMemoryException">If resource too large to decode.</exception> /// <exception cref="IOException">If unable to read from temporary file.</exception> /// <returns>Decoded object.</returns> public async Task <object> GetAsync(Uri Uri, int TimeoutMs, params KeyValuePair <string, string>[] Headers) { KeyValuePair <string, TemporaryFile> Rec = await this.GetTempFileAsync(Uri, TimeoutMs, Headers); string ContentType = Rec.Key; TemporaryFile File = Rec.Value; try { if (File is null) { return(null); } File.Position = 0; if (File.Length > int.MaxValue) { throw new OutOfMemoryException("Resource too large."); } int Len = (int)File.Length; byte[] Bin = new byte[Len]; if (await File.ReadAsync(Bin, 0, Len) != Len) { throw new IOException("Unable to read from file."); } return(InternetContent.Decode(ContentType, Bin, Uri)); } finally { File?.Dispose(); } }
/// <summary> /// Encodes an object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Encoding">Desired encoding of text. Can be null if no desired encoding is speified.</param> /// <param name="ContentType">Content Type of encoding. Includes information about any text encodings used.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>Encoded object.</returns> /// <exception cref="ArgumentException">If the object cannot be encoded.</exception> public byte[] Encode(object Object, Encoding Encoding, out string ContentType, params string[] AcceptedContentTypes) { if (InternetContent.IsAccepted(WsContentTypes, out ContentType, AcceptedContentTypes)) { string s = null; if (Object is Expression Expression) { s = Expression.Script; } else if (Object is string s2) { s = s2; } if (s != null) { if (Encoding is null) { ContentType += "; charset=utf-8"; return(Encoding.UTF8.GetBytes(s)); } else { ContentType += "; charset=" + Encoding.WebName; return(Encoding.GetBytes(s)); } } } throw new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object)); }
/// <summary> /// Evaluates the node, using the variables provided in the <paramref name="Variables"/> collection. /// </summary> /// <param name="Arguments">Function arguments.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Result.</returns> public override IElement Evaluate(IElement[] Arguments, Variables Variables) { Uri Url = new Uri(Arguments[0].AssociatedObjectValue?.ToString()); List <KeyValuePair <string, string> > HeaderList = null; if (Arguments.Length > 1) { object Arg1 = Arguments[1].AssociatedObjectValue; if (Arg1 is IDictionary <string, IElement> Headers) { HeaderList = new List <KeyValuePair <string, string> >(); foreach (KeyValuePair <string, IElement> P in Headers) { HeaderList.Add(new KeyValuePair <string, string>(P.Key, P.Value.AssociatedObjectValue?.ToString())); } } else if (Arg1 is string Accept) { HeaderList = new List <KeyValuePair <string, string> >() { new KeyValuePair <string, string>("Accept", Accept) }; } else { throw new ScriptRuntimeException("Invalid second parameter to Get. Should be either an accept string, or an object with protocol-specific headers or options.", this); } } object Result = InternetContent.GetAsync(Url, HeaderList?.ToArray() ?? new KeyValuePair <string, string> [0]).Result; return(new ObjectValue(Result)); }
/// <summary> /// Encodes an object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Encoding">Desired encoding of text. Can be null if no desired encoding is speified.</param> /// <param name="ContentType">Content Type of encoding. Includes information about any text encodings used.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>Encoded object.</returns> /// <exception cref="ArgumentException">If the object cannot be encoded.</exception> public byte[] Encode(object Object, Encoding Encoding, out string ContentType, params string[] AcceptedContentTypes) { if (InternetContent.IsAccepted(HtmlContentTypes, out ContentType, AcceptedContentTypes)) { string Html = null; if (Object is HtmlDocument HtmlDoc) { Html = HtmlDoc.HtmlText; } else if (Object is string s) { Html = s; } if (Html != null) { if (Encoding == null) { ContentType += "; charset=utf-8"; return(Encoding.UTF8.GetBytes(Html)); } else { ContentType += "; charset=" + Encoding.WebName; return(Encoding.GetBytes(Html)); } } } throw new ArgumentException("Unable to encode object, or content type not accepted.", nameof(Object)); }
/// <summary> /// Executes the GET method on the resource. /// </summary> /// <param name="Request">HTTP Request</param> /// <param name="Response">HTTP Response</param> /// <exception cref="HttpException">If an error occurred when processing the method.</exception> public async Task GET(HttpRequest Request, HttpResponse Response) { string FullPath = this.GetFullPath(Request); if (File.Exists(FullPath)) { DateTime LastModified = File.GetLastWriteTime(FullPath).ToUniversalTime(); CacheRec Rec; Rec = this.CheckCacheHeaders(FullPath, LastModified, Request); string ContentType = InternetContent.GetContentType(Path.GetExtension(FullPath)); Stream f = CheckAcceptable(Request, Response, ref ContentType, out bool Dynamic, FullPath, Request.Header.Resource); Rec.IsDynamic = Dynamic; if (Response.ResponseSent) { return; } await SendResponse(f, FullPath, ContentType, Rec.IsDynamic, Rec.ETag, LastModified, Response, Request); } else { await this.RaiseFileNotFound(FullPath, Request, Response); } }
private object Decode(string FileName) { byte[] Data = File.ReadAllBytes("Data\\" + FileName + ".bin"); string ContentType = File.ReadAllText("Data\\" + FileName + ".txt"); return(InternetContent.Decode(ContentType, Data, null)); }
/// <summary> /// Posts to a resource, using a Uniform Resource Identifier (or Locator). /// </summary> /// <param name="Uri">URI</param> /// <param name="Data">Data to post.</param> /// <param name="TimeoutMs">Timeout, in milliseconds. (Default=60000)</param> /// <param name="Headers">Optional headers. Interpreted in accordance with the corresponding URI scheme.</param> /// <returns>Decoded response.</returns> public virtual async Task <object> PostAsync(Uri Uri, object Data, int TimeoutMs, params KeyValuePair <string, string>[] Headers) { byte[] Bin = InternetContent.Encode(Data, System.Text.Encoding.UTF8, out string ContentType); KeyValuePair <byte[], string> Result = await this.PostAsync(Uri, Bin, ContentType, TimeoutMs, Headers); return(InternetContent.Decode(Result.Value, Result.Key, Uri)); }
/// <summary> /// If the link provided should be embedded in a multi-media construct automatically. /// </summary> /// <param name="Url">Inline link.</param> public override bool EmbedInlineLink(string Url) { string Extension = Path.GetExtension(Url); string ContentType = InternetContent.GetContentType(Extension); return(ContentType.StartsWith("image/")); }
/// <summary> /// Downloads a certificate. /// </summary> /// <param name="CertificateLocation">URI of certificate.</param> /// <returns>Certificate chain.</returns> public async Task <X509Certificate2[]> DownloadCertificate(Uri CertificateLocation) { HttpRequestMessage Request = new HttpRequestMessage(HttpMethod.Get, CertificateLocation); string ContentType = PemDecoder.ContentType; Request.Headers.TryAddWithoutValidation("Accept", ContentType); HttpResponseMessage Response = await this.httpClient.SendAsync(Request); Response.EnsureSuccessStatusCode(); Stream Stream = await Response.Content.ReadAsStreamAsync(); byte[] Bin = await Response.Content.ReadAsByteArrayAsync(); if (Response.Headers.TryGetValues("Content-Type", out IEnumerable <string> Values)) { foreach (string s in Values) { ContentType = s; break; } } object Decoded = InternetContent.Decode(ContentType, Bin, CertificateLocation); if (!(Decoded is X509Certificate2[] Certificates)) { throw new Exception("Unexpected response returned. Content-Type: " + ContentType); } return(Certificates); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="Arguments">Function arguments.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement Evaluate(IElement[] Arguments, Variables Variables) { string ContentType; byte[] Bin; if (Arguments.Length > 1) { if (!(Arguments[1].AssociatedObjectValue is Array A)) { throw new ScriptRuntimeException("Second parameter to Encode should be an array of acceptable content types.", this); } int i, c = A.Length; string[] AcceptedTypes = new string[c]; for (i = 0; i < c; i++) { AcceptedTypes[i] = A.GetValue(i)?.ToString(); } Bin = InternetContent.Encode(Arguments[0].AssociatedObjectValue, System.Text.Encoding.UTF8, out ContentType, AcceptedTypes); } else { Bin = InternetContent.Encode(Arguments[0].AssociatedObjectValue, System.Text.Encoding.UTF8, out ContentType); } return(new ObjectVector(new ObjectValue(Bin), new StringValue(ContentType))); }
/// <summary> /// Decodes data sent in request. /// </summary> /// <returns>Decoded data.</returns> public object DecodeData() { if (this.dataStream is null) { return(null); } long l = this.dataStream.Length; if (l > int.MaxValue) { throw new OutOfMemoryException("Data object too large for in-memory decoding."); } int Len = (int)l; byte[] Data = new byte[Len]; this.dataStream.Position = 0; this.dataStream.Read(Data, 0, Len); HttpFieldContentType ContentType = this.header.ContentType; if (ContentType is null) { return(Data); } return(InternetContent.Decode(ContentType.Type, Data, ContentType.Encoding, ContentType.Fields, new Uri(this.header.GetURL(false, false)))); }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (Object is string) { if (InternetContent.IsAccepted("text/plain", AcceptedContentTypes)) { Grade = Grade.Ok; return(true); } else { foreach (string s in AcceptedContentTypes) { if (s.StartsWith("text/")) { Grade = Grade.Barely; return(true); } } } } Grade = Grade.NotAtAll; return(false); }
/// <summary> /// Evaluates the function on a scalar argument. /// </summary> /// <param name="Argument">Function argument.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement EvaluateScalar(string Argument, Variables Variables) { byte[] Bin = File.ReadAllBytes(Argument); string ContentType = InternetContent.GetContentType(Path.GetExtension(Argument)); object Decoded = InternetContent.Decode(ContentType, Bin, new Uri(Argument)); return(new ObjectValue(Decoded)); }
/// <summary> /// Encodes an object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Encoding">Desired encoding of text. Can be null if no desired encoding is speified.</param> /// <param name="ContentType">Content Type of encoding. Includes information about any text encodings used.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>Encoded object.</returns> /// <exception cref="ArgumentException">If the object cannot be encoded.</exception> public byte[] Encode(object Object, Encoding Encoding, out string ContentType, params string[] AcceptedContentTypes) { if (Object is ReportContent Report && InternetContent.IsAccepted(ContentTypes, AcceptedContentTypes)) { string Boundary = Guid.NewGuid().ToString(); ContentType = ReportCodec.ContentType + "; boundary=\"" + Boundary + "\""; return(FormDataDecoder.Encode(Report.Content, Boundary)); }
/// <summary> /// Returns an object to the client. This method can only be called once per response, and only as the only method that returns a response /// to the client. /// </summary> /// <param name="Object">Object to return. Object will be encoded using Internet Content encoders, as defined in <see cref="Waher.Content"/>.</param> public void Return(object Object) { byte[] Data = InternetContent.Encode(Object, this.encoding, out string ContentType); this.ContentType = ContentType; this.ContentLength = Data.Length; this.Write(Data); }
/// <summary> /// Serializes an object to an array of bytes. /// </summary> /// <param name="Value">Value</param> /// <returns>Binary serialization.</returns> public static byte[] SerializeToBinary(object Value) { if (Value is byte[] Bin) { return(Bin); } else { return(InternetContent.Encode(Value, Encoding.UTF8, out string ContentType)); } }
internal async Task <AcmeResponse> POST(Uri URL, Uri KeyID, params KeyValuePair <string, object>[] Payload) { HttpResponseMessage Response = await this.HttpPost(URL, KeyID, null, Payload); byte[] Bin = await Response.Content.ReadAsByteArrayAsync(); string CharSet = Response.Content.Headers.ContentType?.CharSet; Encoding Encoding; if (string.IsNullOrEmpty(CharSet)) { Encoding = Encoding.UTF8; } else { Encoding = InternetContent.GetEncoding(CharSet); } AcmeResponse AcmeResponse = new AcmeResponse() { Json = Encoding.GetString(Bin), Location = URL, ResponseMessage = Response, Payload = null }; if (Response.Headers.TryGetValues("Location", out IEnumerable <string> Values)) { foreach (string s in Values) { AcmeResponse.Location = new Uri(s); break; } } if (string.IsNullOrEmpty(AcmeResponse.Json)) { AcmeResponse.Payload = null; } else if ((AcmeResponse.Payload = JSON.Parse(AcmeResponse.Json) as IEnumerable <KeyValuePair <string, object> >) is null) { throw new Exception("Unexpected response returned."); } if (Response.IsSuccessStatusCode) { return(AcmeResponse); } else { throw CreateException(AcmeResponse.Payload, Response); } }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if ((Object is SKImage || Object is SKBitmap) && InternetContent.IsAccepted(ContentTypes, AcceptedContentTypes)) { Grade = Grade.Ok; return(true); } else { Grade = Grade.NotAtAll; return(false); } }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (Object is MarkdownDocument && InternetContent.IsAccepted(ContentTypes, AcceptedContentTypes)) { Grade = Grade.Excellent; return(true); } else { Grade = Grade.NotAtAll; return(false); } }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (Object is JwtToken && InternetContent.IsAccepted(ContentType, AcceptedContentTypes)) { Grade = Grade.Perfect; return(true); } else { Grade = Grade.NotAtAll; return(false); } }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (Object is HtmlDocument || (Object is string s && s.TrimEnd().EndsWith("</html>", StringComparison.OrdinalIgnoreCase))) { if (InternetContent.IsAccepted(HtmlContentTypes, AcceptedContentTypes)) { Grade = Grade.Ok; return(true); } } Grade = Grade.NotAtAll; return(false); }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (InternetContent.IsAccepted(CsvContentTypes, AcceptedContentTypes) && (Object is string[][] || Object is IMatrix)) { Grade = Grade.Ok; return(true); } else { Grade = Grade.NotAtAll; return(false); } }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (Object is HtmlDocument) { if (InternetContent.IsAccepted(HtmlContentTypes, AcceptedContentTypes)) { Grade = Grade.Ok; return(true); } } Grade = Grade.NotAtAll; return(false); }
/// <summary> /// If the encoder encodes a given object. /// </summary> /// <param name="Object">Object to encode.</param> /// <param name="Grade">How well the encoder encodes the object.</param> /// <param name="AcceptedContentTypes">Optional array of accepted content types. If array is empty, all content types are accepted.</param> /// <returns>If the encoder can encode the given object.</returns> public bool Encodes(object Object, out Grade Grade, params string[] AcceptedContentTypes) { if (Object is Expression) { if (InternetContent.IsAccepted(WsContentTypes, AcceptedContentTypes)) { Grade = Grade.Excellent; return(true); } } Grade = Grade.NotAtAll; return(false); }