--- Smdn.Net.Pop3.Client-1.91-netstandard2.0.apilist.cs 2019-01-30 03:03:34.438020354 +0900
+++ Smdn.Net.Pop3.Client-2.0alpha1-netstandard2.0.apilist.cs 2019-01-30 03:03:37.221974490 +0900
@@ -1,1001 +1,936 @@
-// Smdn.Net.Pop3.Client-1.91 (netstandard2.0)
+// Smdn.Net.Pop3.Client-2.0alpha1 (netstandard2.0)
// Name: Smdn.Net.Pop3.Client
// TargetFramework: .NETStandard,Version=v2.0
-// AssemblyVersion: 1.91.0.0
-// InformationalVersion: 1.91 (netstandard2.0)
+// AssemblyVersion: 2.0.0.0
+// InformationalVersion: 2.0alpha1 (netstandard2.0)
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Runtime.Serialization;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Smdn.IO.Streams.LineOriented;
using Smdn.Net.Connection;
using Smdn.Net.MessageAccessProtocols;
using Smdn.Net.Pop3;
using Smdn.Net.Pop3.Client;
using Smdn.Net.Pop3.Protocol;
using Smdn.Net.Pop3.Protocol.DataStructures;
using Smdn.Net.Pop3.Protocol.Session;
using Smdn.Net.Pop3.Protocol.Strings;
using Smdn.Net.Pop3.Protocol.Transmission;
using Smdn.Net.Pop3.Urls;
using Smdn.Security.Authentication.Sasl.Client;
using Smdn.Text;
namespace Smdn.Net.Pop3 {
[Serializable]
public class PopException : Exception {
protected PopException(SerializationInfo info, StreamingContext context) {}
public PopException() {}
public PopException(string message) {}
public PopException(string message, Exception innerException) {}
}
}
namespace Smdn.Net.Pop3.Client {
public class PopClient : IDisposable {
public PopClient() {}
public PopClient(PopClientProfile profile) {}
public PopClient(Uri authority) {}
- public PopClient(string host) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, bool securePort, string userName) {}
- public PopClient(string host, int port) {}
- public PopClient(string host, int port, bool securePort) {}
- public PopClient(string host, int port, bool securePort, string userName) {}
- public PopClient(string host, int port, bool securePort, string userName, string authType) {}
- public PopClient(string host, int port, bool securePort, string userName, string authType, int timeout) {}
+ public PopClient(string host, int port = -1, bool securePort = false, string userName = null, string authType = null, int timeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool useTlsIfAvailable = true, IEnumerable<string> usingSaslMechanisms = null, bool allowInsecureLogin = false, bool allowStandardLogin = true, bool allowAllowApopLogin = true) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, int port, string userName) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, int port, string userName, string authType) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public PopClient(string host, string userName) {}
public bool DeleteAfterRetrieve { get; set; }
public bool IsBusy { get; }
public bool IsConnected { get; }
public bool IsSecureSession { get; }
public long MessageCount { get; }
public PopClientProfile Profile { get; }
public int ReceiveTimeout { get; set; }
public int SendTimeout { get; set; }
- public PopCapabilitySet ServerCapabilities { get; }
+ public IReadOnlyStringSet<PopCapability> ServerCapabilities { get; }
public int Timeout { get; set; }
public long TotalSize { get; }
- public IAsyncResult BeginConnect(ICredentialsByHost credentials) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public IAsyncResult BeginConnect(ICredentialsByHost credentials, AsyncCallback asyncCallback, object asyncState) {}
- public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback, AsyncCallback asyncCallback, object asyncState) {}
- public IAsyncResult BeginConnect(SaslClientMechanism authMechanism) {}
+ public IAsyncResult BeginConnect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, AsyncCallback asyncCallback, object asyncState) {}
- public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback, AsyncCallback asyncCallback, object asyncState) {}
- public IAsyncResult BeginConnect(string password) {}
+ public IAsyncResult BeginConnect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public IAsyncResult BeginConnect(string password, AsyncCallback asyncCallback, object asyncState) {}
- public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStreamCallback, AsyncCallback asyncCallback, object asyncState) {}
+ public IAsyncResult BeginConnect(string password, UpgradeConnectionStreamCallback createSslStream = null, AsyncCallback asyncCallback = null, object asyncState = null) {}
public void CancelDelete() {}
public Task CancelDeleteAsync() {}
- public void Connect(ICredentialsByHost credentials) {}
- public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
- public void Connect(SaslClientMechanism authMechanism) {}
- public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
- public void Connect(string password) {}
- public void Connect(string password, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public void Connect(string password, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
- public Task ConnectAsync(ICredentialsByHost credentials) {}
- public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
- public Task ConnectAsync(SaslClientMechanism authMechanism) {}
- public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
- public Task ConnectAsync(string password) {}
- public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStreamCallback) {}
- public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken) {}
- public void Disconnect() {}
- public void Disconnect(bool logout) {}
- public IEnumerable<TResult> DownloadAllMessagesAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
- public IEnumerable<TResult> DownloadAllMessagesAs<TResult>(Converter<Stream, TResult> converter) {}
- public static TResult[] DownloadAllMessagesAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
- public static TResult[] DownloadAllMessagesAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
+ public void Connect(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
+ public void Connect(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
+ public void Connect(string password, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
+ public Task ConnectAsync(ICredentialsByHost credentials, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
+ public Task ConnectAsync(SaslClientMechanism authMechanism, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
+ public Task ConnectAsync(string password, UpgradeConnectionStreamCallback createSslStream = null, CancellationToken cancellationToken = default) {}
+ public void Disconnect(bool logout = false) {}
+ public IReadOnlyList<TResult> DownloadAllMessagesAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
+ public IReadOnlyList<TResult> DownloadAllMessagesAs<TResult>(Converter<Stream, TResult> converter) {}
+ public static IReadOnlyList<TResult> DownloadAllMessagesAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
+ public static IReadOnlyList<TResult> DownloadAllMessagesAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
public Task<IReadOnlyList<TResult>> DownloadAllMessagesAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public Task<IReadOnlyList<TResult>> DownloadAllMessagesAsAsync<TResult>(Converter<Stream, TResult> converter) {}
- public IEnumerable<string> DownloadAllMessagesAsText(Encoding encoding) {}
- public static string[] DownloadAllMessagesAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
+ public IReadOnlyList<string> DownloadAllMessagesAsText(Encoding encoding) {}
+ public static IReadOnlyList<string> DownloadAllMessagesAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
public Task<IReadOnlyList<string>> DownloadAllMessagesAsTextAsync(Encoding encoding) {}
- public FileInfo[] DownloadAllMessagesToDirectory(string directory) {}
- public static FileInfo[] DownloadAllMessagesToDirectory(Uri popUrl, string password, bool deleteAfterDownload, string directory) {}
+ public IReadOnlyList<FileInfo> DownloadAllMessagesToDirectory(string directory) {}
+ public static IReadOnlyList<FileInfo> DownloadAllMessagesToDirectory(Uri popUrl, string password, bool deleteAfterDownload, string directory) {}
public Task<IReadOnlyList<FileInfo>> DownloadAllMessagesToDirectoryAsync(string directory) {}
- public FileInfo[] DownloadAllMessagesToFiles(Func<PopMessage, string> selectFileName) {}
- public static FileInfo[] DownloadAllMessagesToFiles(Uri popUrl, string password, bool deleteAfterDownload, Func<PopMessage, string> selectFileName) {}
+ public IReadOnlyList<FileInfo> DownloadAllMessagesToFiles(Func<PopMessage, string> selectFileName) {}
+ public static IReadOnlyList<FileInfo> DownloadAllMessagesToFiles(Uri popUrl, string password, bool deleteAfterDownload, Func<PopMessage, string> selectFileName) {}
public Task<IReadOnlyList<FileInfo>> DownloadAllMessagesToFilesAsync(Func<PopMessage, string> selectFileName) {}
public TResult DownloadFirstMessageAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public TResult DownloadFirstMessageAs<TResult>(Converter<Stream, TResult> converter) {}
public static TResult DownloadFirstMessageAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
public static TResult DownloadFirstMessageAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
public Task<TResult> DownloadFirstMessageAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public Task<TResult> DownloadFirstMessageAsAsync<TResult>(Converter<Stream, TResult> converter) {}
public byte[] DownloadFirstMessageAsByteArray() {}
public static byte[] DownloadFirstMessageAsByteArray(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<byte[]> DownloadFirstMessageAsByteArrayAsync() {}
public Stream DownloadFirstMessageAsStream() {}
public static Stream DownloadFirstMessageAsStream(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<Stream> DownloadFirstMessageAsStreamAsync() {}
public static string DownloadFirstMessageAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
public string DownloadFirstMessageAsText(Encoding encoding) {}
public Task<string> DownloadFirstMessageAsTextAsync(Encoding encoding) {}
public FileInfo DownloadFirstMessageToFile(string path) {}
public static FileInfo DownloadFirstMessageToFile(Uri popUrl, string password, bool deleteAfterDownload, string path) {}
public Task<FileInfo> DownloadFirstMessageToFileAsync(string path) {}
public TResult DownloadLastMessageAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public TResult DownloadLastMessageAs<TResult>(Converter<Stream, TResult> converter) {}
public static TResult DownloadLastMessageAs<T, TResult>(Uri popUrl, string password, bool deleteAfterDownload, Func<Stream, T, TResult> read, T arg) {}
public static TResult DownloadLastMessageAs<TResult>(Uri popUrl, string password, bool deleteAfterDownload, Converter<Stream, TResult> converter) {}
public Task<TResult> DownloadLastMessageAsAsync<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public Task<TResult> DownloadLastMessageAsAsync<TResult>(Converter<Stream, TResult> converter) {}
public byte[] DownloadLastMessageAsByteArray() {}
public static byte[] DownloadLastMessageAsByteArray(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<byte[]> DownloadLastMessageAsByteArrayAsync() {}
public Stream DownloadLastMessageAsStream() {}
public static Stream DownloadLastMessageAsStream(Uri popUrl, string password, bool deleteAfterDownload) {}
public Task<Stream> DownloadLastMessageAsStreamAsync() {}
public static string DownloadLastMessageAsText(Uri popUrl, string password, bool deleteAfterDownload, Encoding encoding) {}
public string DownloadLastMessageAsText(Encoding encoding) {}
public Task<string> DownloadLastMessageAsTextAsync(Encoding encoding) {}
public FileInfo DownloadLastMessageToFile(string path) {}
public static FileInfo DownloadLastMessageToFile(Uri popUrl, string password, bool deleteAfterDownload, string path) {}
public Task<FileInfo> DownloadLastMessageToFileAsync(string path) {}
public TResult DownloadMessageAs<T, TResult>(long messageNumber, Func<Stream, T, TResult> read, T arg) {}
public TResult DownloadMessageAs<TResult>(long messageNumber, Converter<Stream, TResult> converter) {}
public Task<TResult> DownloadMessageAsAsync<T, TResult>(long messageNumber, Func<Stream, T, TResult> read, T arg) {}
public Task<TResult> DownloadMessageAsAsync<TResult>(long messageNumber, Converter<Stream, TResult> converter) {}
public byte[] DownloadMessageAsByteArray(long messageNumber) {}
public Task<byte[]> DownloadMessageAsByteArrayAsync(long messageNumber) {}
public Stream DownloadMessageAsStream(long messageNumber) {}
public Task<Stream> DownloadMessageAsStreamAsync(long messageNumber) {}
public string DownloadMessageAsText(long messageNumber, Encoding encoding) {}
public Task<string> DownloadMessageAsTextAsync(long messageNumber, Encoding encoding) {}
public FileInfo DownloadMessageToFile(long messageNumber, string path) {}
public Task<FileInfo> DownloadMessageToFileAsync(long messageNumber, string path) {}
public void EndConnect(IAsyncResult asyncResult) {}
- public PopMessage GetFirstMessage() {}
- public PopMessage GetFirstMessage(bool getUniqueId) {}
- public Task<PopMessage> GetFirstMessageAsync() {}
+ public PopMessage GetFirstMessage(bool getUniqueId = false) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<PopMessage> GetFirstMessageAsync(CancellationToken cancellationToken) {}
- public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId) {}
- public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId, CancellationToken cancellationToken) {}
- public PopMessage GetLastMessage() {}
- public PopMessage GetLastMessage(bool getUniqueId) {}
- public Task<PopMessage> GetLastMessageAsync() {}
+ public Task<PopMessage> GetFirstMessageAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
+ public PopMessage GetLastMessage(bool getUniqueId = false) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<PopMessage> GetLastMessageAsync(CancellationToken cancellationToken) {}
- public Task<PopMessage> GetLastMessageAsync(bool getUniqueId) {}
- public Task<PopMessage> GetLastMessageAsync(bool getUniqueId, CancellationToken cancellationToken) {}
- public PopMessage GetMessage(long messageNumber) {}
- public PopMessage GetMessage(long messageNumber, bool getUniqueId) {}
+ public Task<PopMessage> GetLastMessageAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
+ public PopMessage GetMessage(long messageNumber, bool getUniqueId = false) {}
public PopMessage GetMessage(string uniqueId) {}
- public Task<PopMessage> GetMessageAsync(long messageNumber) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<PopMessage> GetMessageAsync(long messageNumber, CancellationToken cancellationToken) {}
- public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId) {}
- public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId, CancellationToken cancellationToken) {}
- public Task<PopMessage> GetMessageAsync(string uniqueId) {}
- public Task<PopMessage> GetMessageAsync(string uniqueId, CancellationToken cancellationToken) {}
+ public Task<PopMessage> GetMessageAsync(long messageNumber, bool getUniqueId = false, CancellationToken cancellationToken = default) {}
+ public Task<PopMessage> GetMessageAsync(string uniqueId, CancellationToken cancellationToken = default) {}
public static long GetMessageCount(Uri popUrl, string password) {}
- public IEnumerable<PopMessage> GetMessages() {}
- public IEnumerable<PopMessage> GetMessages(bool getUniqueId) {}
- public Task<IReadOnlyList<PopMessage>> GetMessagesAsync() {}
+ public IReadOnlyList<PopMessage> GetMessages(bool getUniqueId = false) {}
+ [Obsolete("省略可能な引数を取るバージョンのメソッドオーバーロードを使用してください/Use method version that takes optional parameters")]
public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(CancellationToken cancellationToken) {}
- public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId) {}
- public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId, CancellationToken cancellationToken) {}
+ public Task<IReadOnlyList<PopMessage>> GetMessagesAsync(bool getUniqueId = false, CancellationToken cancellationToken = default) {}
public void KeepAlive() {}
public Task KeepAliveAsync() {}
public void Logout() {}
void IDisposable.Dispose() {}
public override string ToString() {}
public void UpdateStatus() {}
public Task UpdateStatusAsync() {}
}
[Serializable]
public class PopClientProfile :
ICloneable,
IPopSessionProfile,
ISerializable
{
protected PopClientProfile(SerializationInfo info, StreamingContext context) {}
public PopClientProfile() {}
public PopClientProfile(Uri authority) {}
- public PopClientProfile(string host) {}
- public PopClientProfile(string host, bool securePort, string userName) {}
- public PopClientProfile(string host, int port) {}
- public PopClientProfile(string host, int port, bool securePort) {}
- public PopClientProfile(string host, int port, bool securePort, string userName) {}
- public PopClientProfile(string host, int port, bool securePort, string userName, string authType) {}
- public PopClientProfile(string host, int port, bool securePort, string userName, string authType, int timeout) {}
- public PopClientProfile(string host, int port, string userName) {}
- public PopClientProfile(string host, int port, string userName, string authType) {}
- public PopClientProfile(string host, string userName) {}
+ public PopClientProfile(string host, int port = -1, bool securePort = false, string userName = null, string authType = null, int timeout = -1, int sendTimeout = -1, int receiveTimeout = -1, bool useTlsIfAvailable = true, IEnumerable<string> usingSaslMechanisms = null, bool allowInsecureLogin = false, bool allowStandardLogin = true, bool allowApopLogin = true) {}
public bool AllowApopLogin { get; set; }
public bool AllowInsecureLogin { get; set; }
public bool AllowStandardLogin { get; set; }
public string AuthType { get; set; }
public Uri Authority { get; }
public string Host { get; set; }
public int Port { get; set; }
public int ReceiveTimeout { get; set; }
public bool SecurePort { get; set; }
public int SendTimeout { get; set; }
ICredentialsByHost IPopSessionProfile.Credentials { get; }
+ IReadOnlyList<string> IPopSessionProfile.UsingSaslMechanisms { get; }
public int Timeout { get; set; }
public bool UseTlsIfAvailable { get; set; }
public string UserName { get; set; }
- public string[] UsingSaslMechanisms { get; set; }
+ public IList<string> UsingSaslMechanisms { get; }
public PopClientProfile Clone() {}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
+ public void SetUsingSaslMechanisms(IEnumerable<string> mechanisms) {}
object ICloneable.Clone() {}
}
public sealed class PopMessage {
public PopClient Client { get; }
public bool IsMarkedAsDeleted { get; }
public long Length { get; }
public long MessageNumber { get; }
public string UniqueId { get; }
public string GetUniqueId() {}
public Task<string> GetUniqueIdAsync() {}
public void MarkAsDeleted() {}
public Task MarkAsDeletedAsync() {}
public Stream OpenRead() {}
public Stream OpenRead(int maxLines) {}
public Task<Stream> OpenReadAsync() {}
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken) {}
public Task<Stream> OpenReadAsync(CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(int maxLines) {}
public Task<Stream> OpenReadAsync(int maxLines, CancellationToken cancellationToken) {}
public Task<Stream> OpenReadAsync(int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<Stream> OpenReadAsync(int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public StreamReader OpenText() {}
public StreamReader OpenText(Encoding encoding) {}
public StreamReader OpenText(Encoding encoding, int maxLines) {}
public StreamReader OpenText(int maxLines) {}
public Task<StreamReader> OpenTextAsync() {}
public Task<StreamReader> OpenTextAsync(Encoding charset) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<StreamReader> OpenTextAsync(int maxLines) {}
public byte[] ReadAllBytes() {}
public byte[] ReadAllBytes(int maxLines) {}
public Task<byte[]> ReadAllBytesAsync() {}
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken) {}
public Task<byte[]> ReadAllBytesAsync(CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(int maxLines) {}
public Task<byte[]> ReadAllBytesAsync(int maxLines, CancellationToken cancellationToken) {}
public Task<byte[]> ReadAllBytesAsync(int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<byte[]> ReadAllBytesAsync(int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public string[] ReadAllLines() {}
public string[] ReadAllLines(Encoding encoding) {}
public string[] ReadAllLines(Encoding encoding, int maxLines) {}
public string[] ReadAllLines(int maxLines) {}
public Task<string[]> ReadAllLinesAsync() {}
public Task<string[]> ReadAllLinesAsync(Encoding charset) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<string[]> ReadAllLinesAsync(int maxLines) {}
public string ReadAllText() {}
public string ReadAllText(Encoding encoding) {}
public string ReadAllText(Encoding encoding, int maxLines) {}
public string ReadAllText(int maxLines) {}
public Task<string> ReadAllTextAsync() {}
public Task<string> ReadAllTextAsync(Encoding charset) {}
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines) {}
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken) {}
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(Encoding charset, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<string> ReadAllTextAsync(int maxLines) {}
public TResult ReadAs<T, TResult>(Func<Stream, T, TResult> read, T arg) {}
public TResult ReadAs<T, TResult>(int maxLines, Func<Stream, T, TResult> read, T arg) {}
public TResult ReadAs<T1, T2, T3, T4, TResult>(Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
public TResult ReadAs<T1, T2, T3, T4, TResult>(int maxLines, Func<Stream, T1, T2, T3, T4, TResult> read, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {}
public TResult ReadAs<T1, T2, T3, TResult>(Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
public TResult ReadAs<T1, T2, T3, TResult>(int maxLines, Func<Stream, T1, T2, T3, TResult> read, T1 arg1, T2 arg2, T3 arg3) {}
public TResult ReadAs<T1, T2, TResult>(Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
public TResult ReadAs<T1, T2, TResult>(int maxLines, Func<Stream, T1, T2, TResult> read, T1 arg1, T2 arg2) {}
public TResult ReadAs<TResult>(Converter<Stream, TResult> converter) {}
public TResult ReadAs<TResult>(Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(Encoding encoding, Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(Encoding encoding, int maxLines, Converter<StreamReader, TResult> converter) {}
public TResult ReadAs<TResult>(int maxLines, Converter<Stream, TResult> converter) {}
public TResult ReadAs<TResult>(int maxLines, Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<Stream, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(Encoding charset, int maxLines, Converter<StreamReader, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter) {}
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, CancellationToken cancellationToken) {}
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<Stream, TResult> converter, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task<TResult> ReadAsAsync<TResult>(int maxLines, Converter<StreamReader, TResult> converter) {}
public IEnumerable<string> ReadLines() {}
public IEnumerable<string> ReadLines(Encoding encoding) {}
public IEnumerable<string> ReadLines(Encoding encoding, int maxLines) {}
public IEnumerable<string> ReadLines(int maxLines) {}
public void Save(string path) {}
public void Save(string path, int maxLines) {}
public Task SaveAsync(string path) {}
public Task SaveAsync(string path, CancellationToken cancellationToken) {}
public Task SaveAsync(string path, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task SaveAsync(string path, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task SaveAsync(string path, int maxLines) {}
public Task SaveAsync(string path, int maxLines, CancellationToken cancellationToken) {}
public Task SaveAsync(string path, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task SaveAsync(string path, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public override string ToString() {}
public bool TryGetUniqueId(out string uniqueId) {}
public void WriteTo(BinaryWriter writer) {}
public void WriteTo(BinaryWriter writer, int maxLines) {}
public void WriteTo(Stream stream) {}
public void WriteTo(Stream stream, int maxLines) {}
public Task WriteToAsync(BinaryWriter writer) {}
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken) {}
public Task WriteToAsync(BinaryWriter writer, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, int maxLines) {}
public Task WriteToAsync(BinaryWriter writer, int maxLines, CancellationToken cancellationToken) {}
public Task WriteToAsync(BinaryWriter writer, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(BinaryWriter writer, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(Stream stream) {}
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken) {}
public Task WriteToAsync(Stream stream, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, int maxLines) {}
public Task WriteToAsync(Stream stream, int maxLines, CancellationToken cancellationToken) {}
public Task WriteToAsync(Stream stream, int maxLines, CancellationToken cancellationToken, IProgress<PopMessageRetrieveProgressInfo> progress) {}
public Task WriteToAsync(Stream stream, int maxLines, IProgress<PopMessageRetrieveProgressInfo> progress) {}
}
[Serializable]
public class PopMessageDeletedException : PopProtocolViolationException {
protected PopMessageDeletedException(SerializationInfo info, StreamingContext context) {}
public PopMessageDeletedException() {}
public PopMessageDeletedException(long messageNumber) {}
public PopMessageDeletedException(string message, long messageNumber) {}
public long MessageNumber { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class PopMessageNotFoundException : PopException {
protected PopMessageNotFoundException(SerializationInfo info, StreamingContext context) {}
public PopMessageNotFoundException() {}
public PopMessageNotFoundException(long messageNumber) {}
public PopMessageNotFoundException(string uniqueId) {}
public long MessageNumber { get; }
public string UniqueId { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
public static class PopSslConnection {
public static LocalCertificateSelectionCallback ClientCertificateSelectionCallback { get; set; }
public static X509Certificate2Collection ClientCertificates { get; }
public static RemoteCertificateValidationCallback DangerousAcceptAnyServerCertificateValidator { get; }
public static SslProtocols EnabledSslProtocols { get; set; }
public static RemoteCertificateValidationCallback ServerCertificateValidationCallback { get; set; }
}
public struct PopMessageRetrieveProgressInfo {
public PopMessageRetrieveProgressInfo(long retrievedOctetCount, long retrievedLineCount, long totalOctetCount, CancellationToken cancellationToken) {}
public CancellationToken CancellationToken { get; }
public int ProgressPercentage { get; }
public long RetrievedLineCount { get; }
public long RetrievedOctetCount { get; }
public long TotalOctetCount { get; }
public override string ToString() {}
}
}
namespace Smdn.Net.Pop3.Protocol {
- public interface IPopExtension {
- PopCapability RequiredCapability { get; }
- }
-
public static class ApopDigest {
public static string Calculate(ByteString timestamp, ByteString sharedSecret) {}
public static string Calculate(string timestamp, string sharedSecret) {}
}
[Serializable]
public class PopAuthenticationException : PopErrorResponseException {
protected PopAuthenticationException(SerializationInfo info, StreamingContext context) {}
public PopAuthenticationException() {}
public PopAuthenticationException(PopCommandResult result) {}
}
public sealed class PopAuthenticationMechanism :
PopStringEnum,
- IPopExtension
+ IEquatable<PopAuthenticationMechanism>
{
- public static readonly PopStringEnumSet<PopAuthenticationMechanism> AllMechanisms; // = "+APOP, KERBEROS_V4, CRAM-MD5, OTP, SKEY, PLAIN, SECURID, DIGEST-MD5, 9798-U-RSA-SHA1-ENC, 9798-M-RSA-SHA1-ENC, 9798-U-DSA-SHA1, 9798-M-DSA-SHA1, 9798-U-ECDSA-SHA1, 9798-M-ECDSA-SHA1, EXTERNAL, ANONYMOUS, GSSAPI, KERBEROS_V5, NTLM, LOGIN, *"
public static readonly PopAuthenticationMechanism Anonymous; // = "ANONYMOUS"
public static readonly PopAuthenticationMechanism Apop; // = "+APOP"
public static readonly PopAuthenticationMechanism CRAMMD5; // = "CRAM-MD5"
public static readonly PopAuthenticationMechanism DigestMD5; // = "DIGEST-MD5"
public static readonly PopAuthenticationMechanism External; // = "EXTERNAL"
public static readonly PopAuthenticationMechanism Gssapi; // = "GSSAPI"
public static readonly PopAuthenticationMechanism IsoIec9798_M_DSA_SHA1; // = "9798-M-DSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_M_ECDSA_SHA1; // = "9798-M-ECDSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_M_RSA_SHA1_ENC; // = "9798-M-RSA-SHA1-ENC"
public static readonly PopAuthenticationMechanism IsoIec9798_U_DSA_SHA1; // = "9798-U-DSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_U_ECDSA_SHA1; // = "9798-U-ECDSA-SHA1"
public static readonly PopAuthenticationMechanism IsoIec9798_U_RSA_SHA1_ENC; // = "9798-U-RSA-SHA1-ENC"
public static readonly PopAuthenticationMechanism KerberosV4; // = "KERBEROS_V4"
public static readonly PopAuthenticationMechanism KerberosV5; // = "KERBEROS_V5"
public static readonly PopAuthenticationMechanism Login; // = "LOGIN"
public static readonly PopAuthenticationMechanism NTLM; // = "NTLM"
public static readonly PopAuthenticationMechanism OTP; // = "OTP"
public static readonly PopAuthenticationMechanism Plain; // = "PLAIN"
public static readonly PopAuthenticationMechanism SKey; // = "SKEY"
public static readonly PopAuthenticationMechanism SecureID; // = "SECURID"
public static readonly PopAuthenticationMechanism SelectAppropriate; // = "*"
- public PopAuthenticationMechanism(string mechanismName) {}
- public PopAuthenticationMechanism(string mechanismName, PopCapability requiredCapability) {}
+ public PopAuthenticationMechanism(string mechanismName, PopCapability requiredCapability = null) {}
+ public static IReadOnlyStringSet<PopAuthenticationMechanism> AllMechanisms { get; }
public PopCapability RequiredCapability { get; }
- public static PopAuthenticationMechanism GetKnownOrCreate(string mechanismName) {}
+ public bool Equals(PopAuthenticationMechanism other) {}
+ public override bool Equals(object obj) {}
+ public override int GetHashCode() {}
+ public static bool operator == (PopAuthenticationMechanism x, PopAuthenticationMechanism y) {}
+ public static bool operator != (PopAuthenticationMechanism x, PopAuthenticationMechanism y) {}
}
[Serializable]
- public sealed class PopCapability : PopStringEnum {
- public static readonly PopCapabilitySet AllCapabilities; // = "TOP, USER, SASL, RESP-CODES, LOGIN-DELAY, PIPELINING, EXPIRE, UIDL, IMPLEMENTATION, STLS, AUTH-RESP-CODE, UTF8, LANG, SASL KERBEROS_V4, SASL CRAM-MD5, SASL OTP, SASL SKEY, SASL PLAIN, SASL SECURID, SASL DIGEST-MD5, SASL 9798-U-RSA-SHA1-ENC, SASL 9798-M-RSA-SHA1-ENC, SASL 9798-U-DSA-SHA1, SASL 9798-M-DSA-SHA1, SASL 9798-U-ECDSA-SHA1, SASL 9798-M-ECDSA-SHA1, SASL EXTERNAL, SASL ANONYMOUS, SASL GSSAPI, SASL KERBEROS_V5, SASL NTLM, SASL LOGIN"
+ public sealed class PopCapability :
+ PopStringEnum,
+ IEquatable<PopCapability>
+ {
public static readonly PopCapability AuthRespCode; // = "AUTH-RESP-CODE"
public static readonly PopCapability Expire; // = "EXPIRE"
public static readonly PopCapability Implementation; // = "IMPLEMENTATION"
public static readonly PopCapability Lang; // = "LANG"
public static readonly PopCapability LoginDelay; // = "LOGIN-DELAY"
public static readonly PopCapability Pipelining; // = "PIPELINING"
public static readonly PopCapability RespCodes; // = "RESP-CODES"
public static readonly PopCapability Sasl; // = "SASL"
public static readonly PopCapability Stls; // = "STLS"
public static readonly PopCapability Top; // = "TOP"
public static readonly PopCapability Uidl; // = "UIDL"
public static readonly PopCapability User; // = "USER"
public static readonly PopCapability Utf8; // = "UTF8"
public PopCapability(string tag, params string[] arguments) {}
- public string[] Arguments { get; }
+ public static IReadOnlyStringSet<PopCapability> AllCapabilities { get; }
+ public IReadOnlyList<string> Arguments { get; }
public string Tag { get; }
public override string Value { get; }
+ public bool ContainsAllArguments(IEnumerable<string> arguments) {}
public bool ContainsAllArguments(params string[] arguments) {}
- public override string ToString() {}
+ public bool Equals(PopCapability other) {}
+ public override bool Equals(object obj) {}
+ public override int GetHashCode() {}
+ public static bool operator == (PopCapability x, PopCapability y) {}
+ public static bool operator != (PopCapability x, PopCapability y) {}
}
- public class PopCapabilitySet : PopStringEnumSet<PopCapability> {
- public static readonly PopCapabilitySet ReadOnlyEmpty; // = ""
-
- public PopCapabilitySet() {}
- public PopCapabilitySet(IEnumerable<PopCapability> caps) {}
- public PopCapabilitySet(bool readOnly, IEnumerable<PopCapability> caps) {}
-
- public PopCapability FindByTag(PopCapability capability) {}
- public PopCapability FindByTag(string tag) {}
- public bool IsCapable(IPopExtension extension) {}
- public bool IsCapable(PopCapability requiredCapability) {}
+ public static class PopCapabilitySetExtensions {
+ public static PopCapability FindByTag(this IReadOnlyStringSet<PopCapability> capabilities, PopCapability capability) {}
+ public static PopCapability FindByTag(this IReadOnlyStringSet<PopCapability> capabilities, string tag) {}
+ public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopCapability requiredCapability) {}
+ public static bool IsCapable(this IReadOnlyStringSet<PopCapability> capabilities, PopStringEnum feature) {}
}
[Serializable]
public class PopConnectionException : PopException {
protected PopConnectionException(SerializationInfo info, StreamingContext context) {}
public PopConnectionException() {}
public PopConnectionException(string message) {}
public PopConnectionException(string message, Exception innerException) {}
}
public static class PopDefaultPorts {
public const int Pop = 110;
public const int Pops = 995;
}
[Serializable]
public class PopErrorResponseException : PopInvalidOperationException {
protected PopErrorResponseException(SerializationInfo info, StreamingContext context) {}
public PopErrorResponseException() {}
public PopErrorResponseException(PopCommandResult result) {}
- public PopErrorResponseException(string message, Exception innerException) {}
public PopErrorResponseException(string message, PopCommandResult result) {}
public PopCommandResult Result { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class PopIncapableException : PopInvalidOperationException {
protected PopIncapableException(SerializationInfo info, StreamingContext context) {}
public PopIncapableException() {}
public PopIncapableException(PopCapability requiredCapability) {}
public PopIncapableException(string message) {}
public PopIncapableException(string message, Exception innerException) {}
public PopIncapableException(string message, PopCapability requiredCapability) {}
public PopCapability RequiredCapability { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public abstract class PopInvalidOperationException : PopException {
protected PopInvalidOperationException() {}
protected PopInvalidOperationException(SerializationInfo info, StreamingContext context) {}
protected PopInvalidOperationException(string message) {}
protected PopInvalidOperationException(string message, Exception innerException) {}
}
[Serializable]
public class PopNoAppropriateAuthMechanismException : PopException {
protected PopNoAppropriateAuthMechanismException(SerializationInfo info, StreamingContext context) {}
public PopNoAppropriateAuthMechanismException() {}
public PopNoAppropriateAuthMechanismException(string message) {}
public PopNoAppropriateAuthMechanismException(string message, Exception innerException) {}
}
- public static class PopOctets {
- public const byte CloseBracket = 93;
- public const byte OpenBracket = 91;
- public const byte Period = 46;
- }
-
[Serializable]
public class PopProtocolViolationException : PopInvalidOperationException {
protected PopProtocolViolationException(SerializationInfo info, StreamingContext context) {}
public PopProtocolViolationException() {}
public PopProtocolViolationException(string message) {}
public PopProtocolViolationException(string message, Exception innerException) {}
}
[Serializable]
- public sealed class PopResponseCode : PopStringEnum {
- public static readonly PopStringEnumSet<PopResponseCode> AllCodes; // = "LOGIN-DELAY, IN-USE, SYS/TEMP, SYS/PERM, AUTH"
+ public sealed class PopResponseCode :
+ PopStringEnum,
+ IEquatable<PopResponseCode>
+ {
public static readonly PopResponseCode Auth; // = "AUTH"
public static readonly PopResponseCode InUse; // = "IN-USE"
public static readonly PopResponseCode LoginDelay; // = "LOGIN-DELAY"
public static readonly PopResponseCode SysPerm; // = "SYS/PERM"
public static readonly PopResponseCode SysTemp; // = "SYS/TEMP"
- public static PopResponseCode GetKnownOrCreate(string code) {}
+ public static IReadOnlyStringSet<PopResponseCode> AllCodes { get; }
+
+ public bool Equals(PopResponseCode other) {}
+ public override bool Equals(object obj) {}
+ public override int GetHashCode() {}
+ public static bool operator == (PopResponseCode x, PopResponseCode y) {}
+ public static bool operator != (PopResponseCode x, PopResponseCode y) {}
}
[Serializable]
public class PopUpgradeConnectionException : PopConnectionException {
protected PopUpgradeConnectionException(SerializationInfo info, StreamingContext context) {}
public PopUpgradeConnectionException() {}
public PopUpgradeConnectionException(string message) {}
public PopUpgradeConnectionException(string message, Exception innerException) {}
}
}
namespace Smdn.Net.Pop3.Protocol.DataStructures {
public struct PopDropListing {
public static readonly PopDropListing Empty; // = "{MessageCount=0, SizeInOctets=0}"
public PopDropListing(long messageCount, long sizeInOctets) {}
public long MessageCount { get; }
public long SizeInOctets { get; }
public override string ToString() {}
}
public struct PopScanListing : IEquatable<long> {
public static readonly PopScanListing Invalid; // = "{MessageNumber=0, SizeInOctets=0}"
public PopScanListing(long messageNumber, long sizeInOctets) {}
public long MessageNumber { get; }
public long SizeInOctets { get; }
public bool Equals(long other) {}
public override string ToString() {}
}
public struct PopUniqueIdListing :
IEquatable<long>,
IEquatable<string>
{
public static readonly PopUniqueIdListing Invalid; // = "{MessageNumber=0, UniqueId=}"
public PopUniqueIdListing(long messageNumber, string uniqueId) {}
public long MessageNumber { get; }
public string UniqueId { get; }
public bool Equals(long other) {}
public bool Equals(string other) {}
public override string ToString() {}
}
}
namespace Smdn.Net.Pop3.Protocol.Session {
public interface IPopSessionProfile {
bool AllowApopLogin { get; }
bool AllowInsecureLogin { get; }
bool AllowStandardLogin { get; }
Uri Authority { get; }
ICredentialsByHost Credentials { get; }
int ReceiveTimeout { get; }
int SendTimeout { get; }
int Timeout { get; }
bool UseTlsIfAvailable { get; }
- string[] UsingSaslMechanisms { get; }
+ IReadOnlyList<string> UsingSaslMechanisms { get; }
}
public enum PopSessionState : int {
Authorization = 1,
NotConnected = 0,
Transaction = 2,
Update = 3,
}
- public sealed class PopSession : IDisposable {
- public PopSession(string host, int port = 110, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback = null) {}
+ public sealed class PopSession :
+ IConnectionInfo,
+ IDisposable
+ {
+ public PopSession(string host, int port = 110, int transactionTimeout = -1, int sendTimeout = -1, int receiveTimeout = -1, UpgradeConnectionStreamCallback createAuthenticatedStream = null) {}
public bool ApopAvailable { get; }
public Uri Authority { get; }
- public IConnectionInfo ConnectionInfo { get; }
public bool HandlesIncapableAsException { get; set; }
public bool IsDisposed { get; }
public bool IsSecureConnection { get; }
public bool IsTransactionProceeding { get; }
public int ReceiveTimeout { get; set; }
public int SendTimeout { get; set; }
- public PopCapabilitySet ServerCapabilities { get; }
+ public IReadOnlyStringSet<PopCapability> ServerCapabilities { get; }
+ string IConnectionInfo.Host { get; }
+ int IConnectionInfo.Port { get; }
public PopSessionState State { get; }
public string Timestamp { get; }
public int TransactionTimeout { get; set; }
- public PopCommandResult Apop(ICredentialsByHost credentials) {}
- public PopCommandResult Apop(ICredentialsByHost credentials, string username) {}
- public PopCommandResult Auth(ICredentialsByHost credentials, PopAuthenticationMechanism authenticationMechanism) {}
- public PopCommandResult Auth(ICredentialsByHost credentials, string username, PopAuthenticationMechanism authenticationMechanism, CancellationToken cancellationToken = default) {}
+ public PopCommandResult Apop(ICredentialsByHost credentials, string username = null) {}
+ public PopCommandResult Auth(PopAuthenticationMechanism authenticationMechanism, ICredentialsByHost credentials, string username = null, CancellationToken cancellationToken = default) {}
public PopCommandResult Auth(SaslClientMechanism specificAuthenticationMechanism, CancellationToken cancellationToken = default) {}
public PopCommandResult Capa() {}
- public PopCommandResult Capa(out PopCapabilitySet capabilities) {}
+ public PopCommandResult Capa(out IReadOnlyStringSet<PopCapability> capabilities) {}
public PopCommandResult Dele(long messageNumber) {}
public void Disconnect(bool logout = true) {}
- public PopCommandResult GenericCommand(string command, bool isResponseMultiline, out PopResponse[] responses, params string[] arguments) {}
+ public PopCommandResult GenericCommand(string command, bool isResponseMultiline, out IReadOnlyList<PopResponse> responses, params string[] arguments) {}
public PopCommandResult GenericCommand(string command, bool isResponseMultiline, params string[] arguments) {}
- public PopCommandResult GenericCommand(string command, out PopResponse[] responses, params string[] arguments) {}
+ public PopCommandResult GenericCommand(string command, out IReadOnlyList<PopResponse> responses, params string[] arguments) {}
public PopCommandResult GenericCommand(string command, params string[] arguments) {}
- public PopCommandResult List(int expectedResultCount, out List<PopScanListing> scanListings) {}
public PopCommandResult List(long messageNumber, out PopScanListing scanListing) {}
- public PopCommandResult List(out List<PopScanListing> scanListings) {}
- public PopCommandResult Login(ICredentialsByHost credentials) {}
- public PopCommandResult Login(ICredentialsByHost credentials, string username) {}
+ public PopCommandResult ListAll(out List<PopScanListing> scanListings, int expectedResultCount = 0) {}
+ public PopCommandResult Login(ICredentialsByHost credentials, string username = null) {}
public PopCommandResult Login(string username, string password) {}
public PopCommandResult NoOp() {}
public PopCommandResult Pass(ICredentialsByHost credentials) {}
public PopCommandResult Pass(string password) {}
public PopCommandResult Quit() {}
public PopCommandResult Retr(long messageNumber, ref Stream messageStream) {}
public PopCommandResult Rset() {}
public PopCommandResult Stat(out PopDropListing dropListing) {}
- public PopCommandResult Stls(UpgradeConnectionStreamCallback createAuthenticatedStreamCallback, bool reissueCapability = false) {}
+ public PopCommandResult Stls(UpgradeConnectionStreamCallback createAuthenticatedStream, bool reissueCapability = false) {}
void IDisposable.Dispose() {}
public override string ToString() {}
public PopCommandResult Top(long messageNumber, int lines, ref Stream messageStream) {}
- public PopCommandResult Uidl(int expectedResultCount, out List<PopUniqueIdListing> uniqueIdListings) {}
public PopCommandResult Uidl(long messageNumber, out PopUniqueIdListing uniqueIdListing) {}
- public PopCommandResult Uidl(out List<PopUniqueIdListing> uniqueIdListings) {}
+ public PopCommandResult UidlAll(out List<PopUniqueIdListing> uniqueIdListings, int expectedResultCount = 0) {}
public PopCommandResult User(ICredentialsByHost credentials) {}
public PopCommandResult User(string username) {}
}
public static class PopSessionCreator {
- public static PopCommandResult CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken, out PopSession session) {}
- public static PopCommandResult CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, out PopSession session) {}
- public static PopSession CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStreamCallback, CancellationToken cancellationToken = default) {}
+ public static PopCommandResult CreateSession(out PopSession session, IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
+ public static PopSession CreateSession(IPopSessionProfile profile, SaslClientMechanism authMechanismSpecified, UpgradeConnectionStreamCallback createSslStream, CancellationToken cancellationToken = default) {}
}
}
namespace Smdn.Net.Pop3.Protocol.Strings {
[Serializable]
- public abstract class PopStringEnum :
- IEquatable<PopStringEnum>,
- IStringEnum
- {
- internal protected PopStringEnum(string @value) {}
+ public abstract class PopStringEnum : IStringEnum {
+ protected PopStringEnum(string @value) {}
public virtual string Value { get; }
- protected static PopStringEnumSet<TStringEnum> CreateDefinedConstantsSet<TStringEnum>() where TStringEnum : PopStringEnum {}
public bool Equals(IStringEnum other) {}
- public bool Equals(string other) {}
public override bool Equals(object obj) {}
- public virtual bool Equals(PopStringEnum other) {}
- protected static IEnumerable<TStringEnum> GetDefinedConstants<TStringEnum>() where TStringEnum : PopStringEnum {}
+ public virtual bool Equals(string other) {}
public override int GetHashCode() {}
public override string ToString() {}
- public static bool operator == (PopStringEnum x, PopStringEnum y) {}
- public static explicit operator string(PopStringEnum str) {}
- public static bool operator != (PopStringEnum x, PopStringEnum y) {}
- }
-
- public class PopStringEnumSet<TStringEnum> : StringEnumSet<TStringEnum> where TStringEnum : PopStringEnum {
- public PopStringEnumSet() {}
- public PopStringEnumSet(IEnumerable<TStringEnum> values) {}
}
}
namespace Smdn.Net.Pop3.Protocol.Transmission {
public interface IPopDataResponse {
ByteString Data { get; }
}
- public enum PopCommandResultCode : int {
- ConnectionError = 450,
- Default = 999,
- Error = 400,
- InternalError = 401,
- Ok = 200,
- RequestDone = 250,
- RequestError = 402,
- ResponseError = 500,
- SocketTimeout = 408,
- UpgradeError = 426,
- }
-
public enum PopStatusIndicator : int {
- Negative = 1,
- Positive = 0,
- Undefined = 2,
+ Negative = -1,
+ Positive = 1,
+ Undefined = 0,
}
public sealed class PopCommand {
- public PopCommand(string command) {}
- public PopCommand(string command, params string[] parameters) {}
-
public string Command { get; }
- public string[] Parameters { get; }
+ public IReadOnlyList<string> Parameters { get; }
+ public static PopCommand Create(string command, params string[] parameters) {}
+ public static PopCommand CreateCancelResponse() {}
+ public static PopCommand CreateContinuation(string parameter) {}
public override string ToString() {}
}
[Serializable]
public class PopCommandResult : ISerializable {
internal protected PopCommandResult(SerializationInfo info, StreamingContext context) {}
- public PopCommandResult() {}
- public PopCommandResultCode Code { get; }
public string Description { get; }
- public bool Failed { get; }
- public virtual IEnumerable<PopResponse> ReceivedResponses { get; internal protected set; }
- public string ResponseText { get; }
- public string ResultText { get; }
+ public virtual bool IsConcludedByClientSide { get; }
+ public virtual bool IsSuccess { get; }
+ public IReadOnlyList<PopResponse> ReceivedResponses { get; }
public PopStatusResponse StatusResponse { get; }
- public bool Succeeded { get; }
public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {}
public PopStatusResponse GetResponseCode(PopResponseCode code) {}
+ public bool IsResponseStatus(PopStatusIndicator status) {}
public override string ToString() {}
- public static explicit operator bool(PopCommandResult r) {}
}
public sealed class PopCommandSender {
public PopCommandSender(LineOrientedBufferedStream baseStream) {}
public void Send(PopCommand command) {}
}
public sealed class PopConnection : ConnectionBase {
- public PopConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStreamCallback) {}
+ public PopConnection(string host, int port, int millisecondsTimeout, UpgradeConnectionStreamCallback createAuthenticatedStream) {}
- public DateTime LastSentTime { get; }
public static TraceSource TraceSource { get; }
protected override LineOrientedBufferedStream CreateBufferedStream(Stream stream) {}
protected override Exception CreateConnectException(string message, Exception innerException) {}
protected override Exception CreateUpgradeStreamException(string message, Exception innerException) {}
public void SendCommand(PopCommand command) {}
public bool TryReceiveLine(Stream stream, out int receivedLineLength) {}
public PopResponse TryReceiveResponse() {}
}
[Serializable]
public sealed class PopContinuationRequest : PopResponse {
public ByteString Base64Text { get; }
public override string ToString() {}
}
[Serializable]
public sealed class PopFollowingResponse :
PopResponse,
IPopDataResponse
{
ByteString IPopDataResponse.Data { get; }
public ByteString Text { get; }
public override string ToString() {}
}
[Serializable]
- public class PopFormatException : FormatException {
+ public abstract class PopFormatException : FormatException {
+ protected PopFormatException() {}
protected PopFormatException(SerializationInfo info, StreamingContext context) {}
- public PopFormatException() {}
- public PopFormatException(string message) {}
- public PopFormatException(string message, Exception innerException) {}
+ protected PopFormatException(string message) {}
+ protected PopFormatException(string message, Exception innerException) {}
}
[Serializable]
public class PopMalformedResponseException : PopFormatException {
protected PopMalformedResponseException(SerializationInfo info, StreamingContext context) {}
public PopMalformedResponseException() {}
public PopMalformedResponseException(string message) {}
public PopMalformedResponseException(string message, Exception innerException) {}
public PopMalformedResponseException(string message, string causedResponse) {}
public string CausedResponse { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public class PopMalformedTextException : PopFormatException {
protected PopMalformedTextException(SerializationInfo info, StreamingContext context) {}
public PopMalformedTextException() {}
public PopMalformedTextException(ByteString causedText) {}
public PopMalformedTextException(string message) {}
public PopMalformedTextException(string message, ByteString causedText) {}
public PopMalformedTextException(string message, Exception innerException) {}
public ByteString CausedText { get; }
public override void GetObjectData(SerializationInfo info, StreamingContext context) {}
}
[Serializable]
public abstract class PopResponse {
- internal protected PopResponse() {}
}
public static class PopResponseParser {
public static PopCapability FromCapa(PopFollowingResponse response) {}
public static string FromGreetingBanner(PopStatusResponse response) {}
public static PopScanListing FromList(PopFollowingResponse response) {}
public static PopScanListing FromList(PopStatusResponse response) {}
public static PopDropListing FromStat(PopStatusResponse response) {}
public static PopUniqueIdListing FromUidl(PopFollowingResponse response) {}
public static PopUniqueIdListing FromUidl(PopStatusResponse response) {}
}
public sealed class PopResponseReceiver {
public PopResponseReceiver(LineOrientedBufferedStream baseStream) {}
public bool HandleAsMultiline { get; set; }
public bool ReceiveLine(Stream stream, out int length) {}
public PopResponse ReceiveResponse() {}
}
[Serializable]
public sealed class PopResponseText {
public PopResponseCode Code { get; }
public ByteString Text { get; }
public string GetTextAsString() {}
public override string ToString() {}
}
[Serializable]
public sealed class PopStatusResponse :
PopResponse,
IPopDataResponse
{
public PopResponseText ResponseText { get; }
ByteString IPopDataResponse.Data { get; }
public PopStatusIndicator Status { get; }
public string Text { get; }
public override string ToString() {}
}
[Serializable]
public sealed class PopTerminationResponse : PopResponse {
+ public override string ToString() {}
}
public static class PopTextParser {
public static PopCapability ToCapability(ByteString[] texts) {}
public static PopDropListing ToDropListing(ByteString messageCount, ByteString sizeInOctets) {}
public static long ToMessageNumber(ByteString text) {}
public static long ToNumber(ByteString text) {}
public static PopScanListing ToScanListing(ByteString messageNumber, ByteString sizeInOctets) {}
public static string ToString(ByteString text) {}
public static PopUniqueIdListing ToUniqueIdListing(ByteString messageNumber, ByteString uniqueId) {}
}
}
namespace Smdn.Net.Pop3.Urls {
public class PopStyleUriParser : GenericUriParser {
public PopStyleUriParser() {}
protected static void CheckUriScheme(Uri uri) {}
public static PopAuthenticationMechanism GetAuthType(Uri uri) {}
public static string GetAuthority(Uri uri) {}
public static string GetStrongAuthority(Uri uri) {}
public static string GetUser(Uri uri) {}
protected override void InitializeAndValidate(Uri uri, out UriFormatException parsingError) {}
}
public static class PopUri {
public static readonly string UriSchemePop = "pop";
public static readonly string UriSchemePops = "pops";
public static int GetDefaultPortFromScheme(Uri uri) {}
public static int GetDefaultPortFromScheme(string scheme) {}
public static bool IsPop(Uri uri) {}
public static void RegisterParser() {}
}
public class PopUriBuilder :
ICloneable,
IEquatable<PopUriBuilder>,
IEquatable<Uri>
{
public PopUriBuilder() {}
public PopUriBuilder(Uri uri) {}
public PopUriBuilder(bool popsScheme, string host) {}
public PopUriBuilder(bool popsScheme, string host, int port) {}
public PopUriBuilder(bool popsScheme, string host, int port, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(bool popsScheme, string host, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(string host, int port) {}
public PopUriBuilder(string host, int port, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(string host, string userName, PopAuthenticationMechanism authType) {}
public PopUriBuilder(string uri) {}
public PopAuthenticationMechanism AuthType { get; set; }
public string Host { get; set; }
public int Port { get; set; }
public string Scheme { get; set; }
public Uri Uri { get; }
public string UserName { get; set; }
public PopUriBuilder Clone() {}
public bool Equals(PopUriBuilder other) {}
public bool Equals(Uri other) {}
public override bool Equals(object obj) {}
public override int GetHashCode() {}
object ICloneable.Clone() {}
public override string ToString() {}
}
}