mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 5.4.0.167

Browse Source 
Former-commit-id: 5624ac747d633e885131e8349322922b6a59baaa
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2017-08-21 15:34:15 +00:00
parent e49d6f06c0
commit 536cd135cc
12856 changed files with 563812 additions and 223249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

397
external/api-snapshot/profiles/net_4_x/Mono.Messaging.cs vendored Normal file
View File

@@ -0,0 +1,397 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
[assembly:System.Reflection.AssemblyVersionAttribute("4.0.0.0")]
[assembly:System.CLSCompliantAttribute(true)]
[assembly:System.Diagnostics.DebuggableAttribute((System.Diagnostics.DebuggableAttribute.DebuggingModes)(2))]
[assembly:System.Reflection.AssemblyCompanyAttribute("Mono development team")]
[assembly:System.Reflection.AssemblyCopyrightAttribute("(c) Various Mono authors")]
[assembly:System.Reflection.AssemblyDefaultAliasAttribute("Mono.Messaging.dll")]
[assembly:System.Reflection.AssemblyDescriptionAttribute("Mono.Messaging.dll")]
[assembly:System.Reflection.AssemblyFileVersionAttribute("4.6.57.0")]
[assembly:System.Reflection.AssemblyInformationalVersionAttribute("4.6.57.0")]
[assembly:System.Reflection.AssemblyProductAttribute("Mono Common Language Infrastructure")]
[assembly:System.Reflection.AssemblyTitleAttribute("Mono.Messaging.dll")]
[assembly:System.Resources.NeutralResourcesLanguageAttribute("en-US")]
[assembly:System.Resources.SatelliteContractVersionAttribute("4.0.0.0")]
[assembly:System.Runtime.CompilerServices.CompilationRelaxationsAttribute((System.Runtime.CompilerServices.CompilationRelaxations)(8))]
[assembly:System.Runtime.CompilerServices.RuntimeCompatibilityAttribute(WrapNonExceptionThrows=true)]
[assembly:System.Runtime.InteropServices.ComVisibleAttribute(false)]
namespace Mono.Messaging
{
[System.FlagsAttribute]
[System.SerializableAttribute]
public enum AcknowledgeTypes
{
FullReachQueue = 5,
FullReceive = 14,
NegativeReceive = 8,
None = 0,
NotAcknowledgeReachQueue = 4,
NotAcknowledgeReceive = 12,
PositiveArrival = 1,
PositiveReceive = 2,
}
[System.SerializableAttribute]
public enum Acknowledgment
{
AccessDenied = 32772,
BadDestinationQueue = 32768,
BadEncryption = 32775,
BadSignature = 32774,
CouldNotEncrypt = 32776,
HopCountExceeded = 32773,
None = 0,
NotTransactionalMessage = 32778,
NotTransactionalQueue = 32777,
Purged = 32769,
QueueDeleted = 49152,
QueueExceedMaximumSize = 32771,
QueuePurged = 49153,
ReachQueue = 2,
ReachQueueTimeout = 32770,
Receive = 16384,
ReceiveTimeout = 49154,
}
public partial class CompletedEventArgs : System.EventArgs
{
public CompletedEventArgs(System.IAsyncResult result) { }
public System.IAsyncResult AsyncResult { get { throw null; } set { } }
}
[System.SerializableAttribute]
public delegate void CompletedEventHandler(object sender, Mono.Messaging.CompletedEventArgs e);
public partial class ConcurrentLinkedQueue<T>
{
public ConcurrentLinkedQueue() { }
public T Dequeue() { throw null; }
public void Enqueue(T context) { }
public override string ToString() { throw null; }
}
public partial class ConnectionException : Mono.Messaging.MonoMessagingException
{
public ConnectionException(Mono.Messaging.QueueReference qRef) { }
public ConnectionException(Mono.Messaging.QueueReference qRef, System.Exception e) { }
public Mono.Messaging.QueueReference QRef { get { throw null; } }
}
[System.SerializableAttribute]
public enum CryptographicProviderType
{
Dss = 3,
Fortezza = 4,
MicrosoftExchange = 5,
None = 0,
RsaFull = 1,
RsqSig = 2,
Ssl = 6,
SttAcq = 8,
SttBrnd = 9,
SttIss = 11,
SttMer = 7,
SttRoot = 10,
}
[System.SerializableAttribute]
public enum EncryptionAlgorithm
{
None = 0,
Rc2 = 26114,
Rc4 = 26625,
}
[System.SerializableAttribute]
public enum EncryptionRequired
{
Body = 2,
None = 0,
Optional = 1,
}
[System.SerializableAttribute]
public enum HashAlgorithm
{
Mac = 32773,
Md2 = 32769,
Md4 = 32770,
Md5 = 32771,
None = 0,
Sha = 32772,
}
public partial interface IMessage
{
Mono.Messaging.AcknowledgeTypes AcknowledgeType { get; set; }
Mono.Messaging.Acknowledgment Acknowledgment { get; }
Mono.Messaging.IMessageQueue AdministrationQueue { get; set; }
int AppSpecific { get; set; }
System.DateTime ArrivedTime { get; }
bool AttachSenderId { get; set; }
bool Authenticated { get; }
string AuthenticationProviderName { get; set; }
Mono.Messaging.CryptographicProviderType AuthenticationProviderType { get; set; }
System.IO.Stream BodyStream { get; set; }
int BodyType { get; set; }
System.Guid ConnectorType { get; set; }
string CorrelationId { get; set; }
Mono.Messaging.IMessageQueue DestinationQueue { get; }
byte[] DestinationSymmetricKey { get; set; }
byte[] DigitalSignature { get; set; }
Mono.Messaging.EncryptionAlgorithm EncryptionAlgorithm { get; set; }
byte[] Extension { get; set; }
Mono.Messaging.HashAlgorithm HashAlgorithm { get; set; }
string Id { get; }
bool IsFirstInTransaction { get; }
bool IsLastInTransaction { get; }
string Label { get; set; }
Mono.Messaging.MessageType MessageType { get; }
Mono.Messaging.MessagePriority Priority { get; set; }
bool Recoverable { get; set; }
Mono.Messaging.IMessageQueue ResponseQueue { get; set; }
byte[] SenderCertificate { get; set; }
byte[] SenderId { get; }
long SenderVersion { get; }
System.DateTime SentTime { get; }
string SourceMachine { get; }
System.TimeSpan TimeToBeReceived { get; set; }
System.TimeSpan TimeToReachQueue { get; set; }
string TransactionId { get; }
Mono.Messaging.IMessageQueue TransactionStatusQueue { get; set; }
bool UseAuthentication { get; set; }
bool UseDeadLetterQueue { get; set; }
bool UseEncryption { get; set; }
bool UseJournalQueue { get; set; }
bool UseTracing { get; set; }
void SetDeliveryInfo(Mono.Messaging.Acknowledgment acknowledgment, System.DateTime arrivedTime, Mono.Messaging.IMessageQueue destinationQueue, string id, Mono.Messaging.MessageType messageType, byte[] senderId, long senderVersion, System.DateTime sentTime, string sourceMachine, string transactionId);
}
public partial interface IMessageEnumerator : System.IDisposable
{
Mono.Messaging.IMessage Current { get; }
System.IntPtr CursorHandle { get; }
void Close();
void Dispose(bool disposing);
bool MoveNext();
bool MoveNext(System.TimeSpan timeout);
Mono.Messaging.IMessage RemoveCurrent();
Mono.Messaging.IMessage RemoveCurrent(Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage RemoveCurrent(Mono.Messaging.MessageQueueTransactionType transactionType);
Mono.Messaging.IMessage RemoveCurrent(System.TimeSpan timeout);
Mono.Messaging.IMessage RemoveCurrent(System.TimeSpan timeout, Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage RemoveCurrent(System.TimeSpan timeout, Mono.Messaging.MessageQueueTransactionType transactionType);
}
public partial interface IMessageQueue
{
bool Authenticate { get; set; }
short BasePriority { get; set; }
bool CanRead { get; }
bool CanWrite { get; }
System.Guid Category { get; set; }
System.DateTime CreateTime { get; }
bool DenySharedReceive { get; set; }
Mono.Messaging.EncryptionRequired EncryptionRequired { get; set; }
System.Guid Id { get; }
System.DateTime LastModifyTime { get; }
long MaximumJournalSize { get; set; }
long MaximumQueueSize { get; set; }
Mono.Messaging.QueueReference QRef { get; set; }
System.IntPtr ReadHandle { get; }
System.ComponentModel.ISynchronizeInvoke SynchronizingObject { get; set; }
bool Transactional { get; }
bool UseJournalQueue { get; set; }
System.IntPtr WriteHandle { get; }
event Mono.Messaging.CompletedEventHandler PeekCompleted;
event Mono.Messaging.CompletedEventHandler ReceiveCompleted;
System.IAsyncResult BeginPeek();
System.IAsyncResult BeginPeek(System.TimeSpan timeout);
System.IAsyncResult BeginPeek(System.TimeSpan timeout, object stateObject);
System.IAsyncResult BeginPeek(System.TimeSpan timeout, object stateObject, System.AsyncCallback callback);
System.IAsyncResult BeginReceive();
System.IAsyncResult BeginReceive(System.TimeSpan timeout);
System.IAsyncResult BeginReceive(System.TimeSpan timeout, object stateObject);
System.IAsyncResult BeginReceive(System.TimeSpan timeout, object stateObject, System.AsyncCallback callback);
void Close();
Mono.Messaging.IMessage EndPeek(System.IAsyncResult asyncResult);
Mono.Messaging.IMessage EndReceive(System.IAsyncResult asyncResult);
Mono.Messaging.IMessageEnumerator GetMessageEnumerator();
Mono.Messaging.IMessage Peek();
Mono.Messaging.IMessage Peek(System.TimeSpan timeout);
Mono.Messaging.IMessage PeekByCorrelationId(string correlationId);
Mono.Messaging.IMessage PeekByCorrelationId(string correlationId, System.TimeSpan timeout);
Mono.Messaging.IMessage PeekById(string id);
Mono.Messaging.IMessage PeekById(string id, System.TimeSpan timeout);
void Purge();
Mono.Messaging.IMessage Receive();
Mono.Messaging.IMessage Receive(Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage Receive(Mono.Messaging.MessageQueueTransactionType transactionType);
Mono.Messaging.IMessage Receive(System.TimeSpan timeout);
Mono.Messaging.IMessage Receive(System.TimeSpan timeout, Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage Receive(System.TimeSpan timeout, Mono.Messaging.MessageQueueTransactionType transactionType);
Mono.Messaging.IMessage ReceiveByCorrelationId(string correlationId);
Mono.Messaging.IMessage ReceiveByCorrelationId(string correlationId, Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage ReceiveByCorrelationId(string correlationId, Mono.Messaging.MessageQueueTransactionType transactionType);
Mono.Messaging.IMessage ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout);
Mono.Messaging.IMessage ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout, Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage ReceiveByCorrelationId(string correlationId, System.TimeSpan timeout, Mono.Messaging.MessageQueueTransactionType transactionType);
Mono.Messaging.IMessage ReceiveById(string id);
Mono.Messaging.IMessage ReceiveById(string id, Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage ReceiveById(string id, Mono.Messaging.MessageQueueTransactionType transactionType);
Mono.Messaging.IMessage ReceiveById(string id, System.TimeSpan timeout);
Mono.Messaging.IMessage ReceiveById(string id, System.TimeSpan timeout, Mono.Messaging.IMessageQueueTransaction transaction);
Mono.Messaging.IMessage ReceiveById(string id, System.TimeSpan timeout, Mono.Messaging.MessageQueueTransactionType transactionType);
void Send(Mono.Messaging.IMessage message);
void Send(Mono.Messaging.IMessage message, Mono.Messaging.IMessageQueueTransaction transaction);
void Send(Mono.Messaging.IMessage message, Mono.Messaging.MessageQueueTransactionType transactionType);
void SendPeekCompleted(System.IAsyncResult result);
void SendReceiveCompleted(System.IAsyncResult result);
}
public partial interface IMessageQueueTransaction : System.IDisposable
{
Mono.Messaging.MessageQueueTransactionStatus Status { get; }
void Abort();
void Begin();
void Commit();
}
public partial interface IMessagingProvider
{
Mono.Messaging.IMessage CreateMessage();
Mono.Messaging.IMessageQueue CreateMessageQueue(Mono.Messaging.QueueReference qRef, bool transactional);
Mono.Messaging.IMessageQueueTransaction CreateMessageQueueTransaction();
void DeleteQueue(Mono.Messaging.QueueReference qRef);
bool Exists(Mono.Messaging.QueueReference qRef);
Mono.Messaging.IMessageQueue GetMessageQueue(Mono.Messaging.QueueReference qRef);
Mono.Messaging.IMessageQueue[] GetPublicQueues();
}
public partial class MessageBase : Mono.Messaging.IMessage
{
public MessageBase() { }
public Mono.Messaging.AcknowledgeTypes AcknowledgeType { get { throw null; } set { } }
public Mono.Messaging.Acknowledgment Acknowledgment { get { throw null; } }
public Mono.Messaging.IMessageQueue AdministrationQueue { get { throw null; } set { } }
public int AppSpecific { get { throw null; } set { } }
public System.DateTime ArrivedTime { get { throw null; } }
public bool AttachSenderId { get { throw null; } set { } }
public bool Authenticated { get { throw null; } }
public string AuthenticationProviderName { get { throw null; } set { } }
public Mono.Messaging.CryptographicProviderType AuthenticationProviderType { get { throw null; } set { } }
public System.IO.Stream BodyStream { get { throw null; } set { } }
public int BodyType { get { throw null; } set { } }
public System.Guid ConnectorType { get { throw null; } set { } }
public string CorrelationId { get { throw null; } set { } }
public Mono.Messaging.IMessageQueue DestinationQueue { get { throw null; } }
public byte[] DestinationSymmetricKey { get { throw null; } set { } }
public byte[] DigitalSignature { get { throw null; } set { } }
public Mono.Messaging.EncryptionAlgorithm EncryptionAlgorithm { get { throw null; } set { } }
public byte[] Extension { get { throw null; } set { } }
public Mono.Messaging.HashAlgorithm HashAlgorithm { get { throw null; } set { } }
public string Id { get { throw null; } }
public bool IsFirstInTransaction { get { throw null; } }
public bool IsLastInTransaction { get { throw null; } }
public string Label { get { throw null; } set { } }
public Mono.Messaging.MessageType MessageType { get { throw null; } }
public Mono.Messaging.MessagePriority Priority { get { throw null; } set { } }
public bool Recoverable { get { throw null; } set { } }
public Mono.Messaging.IMessageQueue ResponseQueue { get { throw null; } set { } }
public byte[] SenderCertificate { get { throw null; } set { } }
public byte[] SenderId { get { throw null; } }
public long SenderVersion { get { throw null; } }
public System.DateTime SentTime { get { throw null; } }
public string SourceMachine { get { throw null; } }
public System.TimeSpan TimeToBeReceived { get { throw null; } set { } }
public System.TimeSpan TimeToReachQueue { get { throw null; } set { } }
public string TransactionId { get { throw null; } }
public Mono.Messaging.IMessageQueue TransactionStatusQueue { get { throw null; } set { } }
public bool UseAuthentication { get { throw null; } set { } }
public bool UseDeadLetterQueue { get { throw null; } set { } }
public bool UseEncryption { get { throw null; } set { } }
public bool UseJournalQueue { get { throw null; } set { } }
public bool UseTracing { get { throw null; } set { } }
public void SetDeliveryInfo(Mono.Messaging.Acknowledgment acknowledgment, System.DateTime arrivedTime, Mono.Messaging.IMessageQueue destinationQueue, string id, Mono.Messaging.MessageType messageType, byte[] senderId, long senderVersion, System.DateTime sentTime, string sourceMachine, string transactionId) { }
}
[System.SerializableAttribute]
public enum MessagePriority
{
AboveNormal = 4,
High = 5,
Highest = 7,
Low = 2,
Lowest = 0,
Normal = 3,
VeryHigh = 6,
VeryLow = 1,
}
public abstract partial class MessageQueueBase
{
protected MessageQueueBase() { }
protected abstract Mono.Messaging.IMessageQueue Queue { get; }
public event Mono.Messaging.CompletedEventHandler PeekCompleted { add { } remove { } }
public event Mono.Messaging.CompletedEventHandler ReceiveCompleted { add { } remove { } }
public System.IAsyncResult BeginPeek() { throw null; }
public System.IAsyncResult BeginPeek(System.TimeSpan timeout) { throw null; }
public System.IAsyncResult BeginPeek(System.TimeSpan timeout, object stateObject) { throw null; }
public System.IAsyncResult BeginPeek(System.TimeSpan timeout, object stateObject, System.AsyncCallback callback) { throw null; }
public System.IAsyncResult BeginReceive() { throw null; }
public System.IAsyncResult BeginReceive(System.TimeSpan timeout) { throw null; }
public System.IAsyncResult BeginReceive(System.TimeSpan timeout, object stateObject) { throw null; }
public System.IAsyncResult BeginReceive(System.TimeSpan timeout, object stateObject, System.AsyncCallback callback) { throw null; }
public Mono.Messaging.IMessage EndPeek(System.IAsyncResult asyncResult) { throw null; }
public Mono.Messaging.IMessage EndReceive(System.IAsyncResult asyncResult) { throw null; }
public void SendPeekCompleted(System.IAsyncResult result) { }
public void SendReceiveCompleted(System.IAsyncResult result) { }
}
[System.SerializableAttribute]
public enum MessageQueueTransactionStatus
{
Aborted = 0,
Committed = 1,
Initialized = 2,
Pending = 3,
}
[System.SerializableAttribute]
public enum MessageQueueTransactionType
{
Automatic = 1,
None = 0,
Single = 3,
}
[System.SerializableAttribute]
public enum MessageType
{
Acknowledgment = 1,
Normal = 2,
Report = 3,
}
public partial class MessageUnavailableException : Mono.Messaging.MonoMessagingException
{
public MessageUnavailableException() { }
public MessageUnavailableException(string msg) { }
public MessageUnavailableException(string msg, System.Exception e) { }
}
public partial class MessagingProviderLocator
{
internal MessagingProviderLocator() { }
public static readonly System.TimeSpan InfiniteTimeout;
public static Mono.Messaging.MessagingProviderLocator Instance { get { throw null; } }
public static Mono.Messaging.IMessagingProvider GetProvider() { throw null; }
}
public partial class MonoMessagingException : System.Exception
{
public MonoMessagingException() { }
public MonoMessagingException(string msg) { }
public MonoMessagingException(string msg, System.Exception e) { }
}
public sealed partial class QueueReference
{
public static readonly Mono.Messaging.QueueReference DEFAULT;
public static readonly string LOCALHOST;
public QueueReference(string host, string queue, bool isPrivate) { }
public string Host { get { throw null; } }
public bool IsPrivate { get { throw null; } }
public string Queue { get { throw null; } }
public bool Equals(Mono.Messaging.QueueReference other) { throw null; }
public override bool Equals(object other) { throw null; }
public override int GetHashCode() { throw null; }
public static bool IsPrivateStr(string s) { throw null; }
public static bool operator ==(Mono.Messaging.QueueReference a, Mono.Messaging.QueueReference b) { throw null; }
public static bool operator !=(Mono.Messaging.QueueReference a, Mono.Messaging.QueueReference b) { throw null; }
public static Mono.Messaging.QueueReference Parse(string path) { throw null; }
public static string RemoveLeadingSlashes(string s) { throw null; }
public Mono.Messaging.QueueReference SetHost(string host) { throw null; }
public Mono.Messaging.QueueReference SetQueue(string queue) { throw null; }
public override string ToString() { throw null; }
}
}