Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSConvert.cs URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSConvert.cs?rev=1723221&view=auto ============================================================================== --- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSConvert.cs (added) +++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSConvert.cs Wed Jan 6 02:19:56 2016 @@ -0,0 +1,1475 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +using System; +using System.Collections; +using IBM.XMS; + +namespace Apache.NMS.XMS.Util +{ + /// <summary> + /// This class implements conversion methods between the IBM XMS and + /// the Apache NMS models. + /// </summary> + public class XMSConvert + { + #region IBM XMS to Apache NMS objects conversion + + /// <summary> + /// Converts an IBM XMS connection interface + /// into an NMS connection interface. + /// </summary> + /// <param name="xmsConnection">IBM XMS connection interface.</param> + /// <returns>Apache NMS connection interface.</returns> + public static Apache.NMS.IConnection ToNMSConnection( + IBM.XMS.IConnection xmsConnection) + { + return (xmsConnection != null + ? new Apache.NMS.XMS.Connection(xmsConnection) + : null); + } + + /// <summary> + /// Converts an IBM XMS session interface + /// into an NMS session interface. + /// </summary> + /// <param name="xmsSession">IBM XMS session interface.</param> + /// <returns>Apache NMS session interface.</returns> + public static Apache.NMS.ISession ToNMSSession( + IBM.XMS.ISession xmsSession) + { + return (xmsSession != null + ? new Apache.NMS.XMS.Session(xmsSession) + : null); + } + + /// <summary> + /// Converts an IBM XMS destination interface + /// into an NMS destination interface. + /// </summary> + /// <param name="xmsDestination">XMS destination.</param> + /// <returns>Apache NMS destination interface.</returns> + public static Apache.NMS.IDestination ToNMSDestination( + IBM.XMS.IDestination xmsDestination) + { + return ToNMSDestination(xmsDestination, false); + } + + /// <summary> + /// Converts an IBM XMS destination interface + /// into an NMS destination interface. + /// </summary> + /// <param name="xmsDestination">XMS destination.</param> + /// <param name="isTemporary">Destination is temporary.</param> + /// <returns>Apache NMS destination interface.</returns> + public static Apache.NMS.IDestination ToNMSDestination( + IBM.XMS.IDestination xmsDestination, + bool isTemporary) + { + if(xmsDestination.TypeId == IBM.XMS.DestinationType.Queue) + { + return (isTemporary ? ToNMSTemporaryQueue(xmsDestination) + : ToNMSQueue(xmsDestination)); + } + + if(xmsDestination.TypeId == IBM.XMS.DestinationType.Topic) + { + return (isTemporary ? ToNMSTemporaryTopic(xmsDestination) + : ToNMSTopic(xmsDestination)); + } + + return null; + } + + /// <summary> + /// Converts an IBM XMS queue interface + /// into an NMS queue interface. + /// </summary> + /// <param name="xmsQueue">XMS destination of type + /// <c>DestinationType.Queue</c>.</param> + /// <returns>Apache NMS queue interface.</returns> + public static Apache.NMS.IQueue ToNMSQueue( + IBM.XMS.IDestination xmsQueue) + { + if((xmsQueue != null) && + (xmsQueue.TypeId != IBM.XMS.DestinationType.Queue)) + { throw new ArgumentException( + "Cannot convert IBM XMS destination to NMS destination: invalid destination type id.", + "xmsQueue"); + } + return (xmsQueue != null + ? new Apache.NMS.XMS.Queue(xmsQueue) + : null); + } + + /// <summary> + /// Converts an IBM XMS topic interface + /// into an NMS topic interface. + /// </summary> + /// <param name="xmsTopic">XMS destination of type + /// <c>DestinationType.Topic</c>.</param> + /// <returns>Apache NMS topic interface.</returns> + public static Apache.NMS.ITopic ToNMSTopic( + IBM.XMS.IDestination xmsTopic) + { + if((xmsTopic != null) && + (xmsTopic.TypeId != IBM.XMS.DestinationType.Topic)) + { throw new ArgumentException( + "Cannot convert IBM XMS destination to NMS destination: invalid destination type id.", + "xmsTopic"); + } + return (xmsTopic != null + ? new Apache.NMS.XMS.Topic(xmsTopic) + : null); + } + + /// <summary> + /// Converts an IBM XMS temporary queue interface + /// into an NMS temporary queue interface. + /// </summary> + /// <param name="xmsTemporaryQueue">XMS destination of type + /// <c>DestinationType.Queue</c>.</param> + /// <returns>Apache NMS temporary queue interface.</returns> + // Couldn't find a means to test whether a XMS destination is temporary. + public static Apache.NMS.ITemporaryQueue ToNMSTemporaryQueue( + IBM.XMS.IDestination xmsTemporaryQueue) + { + if((xmsTemporaryQueue != null) && + (xmsTemporaryQueue.TypeId != IBM.XMS.DestinationType.Queue)) + { throw new ArgumentException( + "Cannot convert IBM XMS destination to NMS destination: invalid destination type id.", + "xmsTemporaryQueue"); + } + return (xmsTemporaryQueue != null + ? new Apache.NMS.XMS.TemporaryQueue(xmsTemporaryQueue) + : null); + } + + /// <summary> + /// Converts an IBM XMS temporary topic interface + /// into an NMS temporary topic interface. + /// </summary> + /// <param name="xmsTemporaryTopic">XMS destination of type + /// <c>DestinationType.Topic</c>.</param> + /// <returns>Apache NMS temporary topic interface.</returns> + // Couldn't find a means to test whether a XMS destination is temporary. + public static Apache.NMS.ITemporaryTopic ToNMSTemporaryTopic( + IBM.XMS.IDestination xmsTemporaryTopic) + { + if((xmsTemporaryTopic != null) && + (xmsTemporaryTopic.TypeId != IBM.XMS.DestinationType.Queue)) + { throw new ArgumentException( + "Cannot convert IBM XMS destination to NMS destination: invalid destination type id.", + "xmsTemporaryTopic"); + } + return (xmsTemporaryTopic != null + ? new Apache.NMS.XMS.TemporaryTopic(xmsTemporaryTopic) + : null); + } + + /// <summary> + /// Converts an IBM XMS message producer interface + /// into an NMS message producer interface. + /// </summary> + /// <param name="session">NMS session.</param> + /// <param name="xmsMessageProducer">XMS message producer.</param> + /// <returns>Apache NMS message producer interface.</returns> + public static Apache.NMS.IMessageProducer ToNMSMessageProducer( + Apache.NMS.XMS.Session session, + IBM.XMS.IMessageProducer xmsMessageProducer) + { + return (xmsMessageProducer != null + ? new Apache.NMS.XMS.MessageProducer(session, xmsMessageProducer) + : null); + } + + /// <summary> + /// Converts an IBM XMS message consumer interface + /// into an NMS message consumer interface. + /// </summary> + /// <param name="session">NMS session.</param> + /// <param name="xmsMessageConsumer">XMS message consumer.</param> + /// <returns>Apache NMS message consumer interface.</returns> + public static Apache.NMS.IMessageConsumer ToNMSMessageConsumer( + Apache.NMS.XMS.Session session, + IBM.XMS.IMessageConsumer xmsMessageConsumer) + { + return (xmsMessageConsumer != null + ? new Apache.NMS.XMS.MessageConsumer(session, xmsMessageConsumer) + : null); + } + + /// <summary> + /// Converts an IBM XMS queue browser interface + /// into an NMS queue browser interface. + /// </summary> + /// <param name="xmsQueueBrowser">XMS queue browser.</param> + /// <returns>Apache NMS queue browser interface.</returns> + public static Apache.NMS.IQueueBrowser ToNMSQueueBrowser( + IBM.XMS.IQueueBrowser xmsQueueBrowser) + { + return (xmsQueueBrowser != null + ? new Apache.NMS.XMS.QueueBrowser(xmsQueueBrowser) + : null); + } + + /// <summary> + /// Converts an IBM XMS message + /// into an NMS message. + /// </summary> + /// <param name="xmsMessage">IBM XMS message.</param> + /// <returns>NMS message.</returns> + public static Apache.NMS.IMessage ToNMSMessage(IBM.XMS.IMessage xmsMessage) + { + if(xmsMessage is IBM.XMS.ITextMessage) + { + return ToNMSTextMessage((IBM.XMS.ITextMessage)xmsMessage); + } + + if(xmsMessage is IBM.XMS.IBytesMessage) + { + return ToNMSBytesMessage((IBM.XMS.IBytesMessage)xmsMessage); + } + + if(xmsMessage is IBM.XMS.IStreamMessage) + { + return ToNMSStreamMessage((IBM.XMS.IStreamMessage)xmsMessage); + } + + if(xmsMessage is IBM.XMS.IMapMessage) + { + return ToNMSMapMessage((IBM.XMS.IMapMessage)xmsMessage); + } + + if(xmsMessage is IBM.XMS.IObjectMessage) + { + return ToNMSObjectMessage((IBM.XMS.IObjectMessage)xmsMessage); + } + + return (xmsMessage != null + ? new Apache.NMS.XMS.Message(xmsMessage) + : null); + } + + /// <summary> + /// Converts an IBM XMS text message + /// into an NMS text message. + /// </summary> + /// <param name="xmsTextMessage">IBM XMS text message.</param> + /// <returns>NMS text message.</returns> + public static Apache.NMS.ITextMessage ToNMSTextMessage( + IBM.XMS.ITextMessage xmsTextMessage) + { + return (xmsTextMessage != null + ? new Apache.NMS.XMS.TextMessage(xmsTextMessage) + : null); + } + + /// <summary> + /// Converts an IBM XMS bytes message + /// into an NMS bytes message. + /// </summary> + /// <param name="xmsBytesMessage">IBM XMS bytes message.</param> + /// <returns>NMS bytes message.</returns> + public static Apache.NMS.IBytesMessage ToNMSBytesMessage( + IBM.XMS.IBytesMessage xmsBytesMessage) + { + return (xmsBytesMessage != null + ? new Apache.NMS.XMS.BytesMessage(xmsBytesMessage) + : null); + } + + /// <summary> + /// Converts an IBM XMS stream message + /// into an NMS stream message. + /// </summary> + /// <param name="xmsStreamMessage">IBM XMS stream message.</param> + /// <returns>NMS stream message.</returns> + public static Apache.NMS.IStreamMessage ToNMSStreamMessage( + IBM.XMS.IStreamMessage xmsStreamMessage) + { + return (xmsStreamMessage != null + ? new Apache.NMS.XMS.StreamMessage(xmsStreamMessage) + : null); + } + + /// <summary> + /// Converts an IBM XMS map message + /// into an NMS map message. + /// </summary> + /// <param name="xmsMapMessage">IBM XMS map message.</param> + /// <returns>NMS map message.</returns> + public static Apache.NMS.IMapMessage ToNMSMapMessage( + IBM.XMS.IMapMessage xmsMapMessage) + { + return (xmsMapMessage != null + ? new Apache.NMS.XMS.MapMessage(xmsMapMessage) + : null); + } + + /// <summary> + /// Converts an IBM XMS object message + /// into an NMS object message. + /// </summary> + /// <param name="xmsObjectMessage">IBM XMS object message.</param> + /// <returns>NMS object message.</returns> + public static Apache.NMS.IObjectMessage ToNMSObjectMessage( + IBM.XMS.IObjectMessage xmsObjectMessage) + { + return (xmsObjectMessage != null + ? new Apache.NMS.XMS.ObjectMessage(xmsObjectMessage) + : null); + } + + /// <summary> + /// Converts an IBM XMS message + /// into an NMS primitive map. + /// </summary> + /// <param name="xmsMessage">IBM XMS message.</param> + /// <returns>NMS primitive map.</returns> + public static Apache.NMS.IPrimitiveMap ToMessageProperties( + IBM.XMS.IMessage xmsMessage) + { + return (xmsMessage != null + ? new Apache.NMS.XMS.MessageProperties(xmsMessage) + : null); + } + + #endregion + + #region Apache NMS to IBM XMS objects conversion + + /// <summary> + /// Converts an NMS destination + /// into an IBM XMS destination. + /// </summary> + /// <param name="nmsDestination">NMS destination.</param> + /// <returns>IBM XMS destination.</returns> + public static IBM.XMS.IDestination ToXMSDestination( + Apache.NMS.IDestination nmsDestination) + { + if(nmsDestination is Apache.NMS.XMS.Destination) + { + return ((Apache.NMS.XMS.Destination)nmsDestination).xmsDestination; + } + return null; + } + + #endregion + + #region Property values conversion + + #region Exception handling + + /// <summary> + /// Throws a conversion exception. + /// </summary> + private static void ThrowCantConvertValueException(object value, + string conversionMethod) + { + throw new ArgumentException(string.Format( + "Cannot convert {0} using {1}.", value, conversionMethod), + conversionMethod); + } + + #endregion + + #region Encoding + + /// <summary> + /// Converts an XMS encoding key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Encoding ToEncoding(Int32 inputValue) + { + return (Encoding)inputValue; + } + + /// <summary> + /// Converts an encoding to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSEncoding(Encoding inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Message Type + + /// <summary> + /// Converts an XMS message type key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static MessageType ToMessageType(Int32 inputValue) + { + return (MessageType)inputValue; + } + + /// <summary> + /// Converts a message type to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMessageType(MessageType inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Report Confirm On Arrival + + /// <summary> + /// Converts an XMS "confirm on arrival" key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReportConfirmOnArrival ToReportConfirmOnArrival( + Int32 inputValue) + { + return (ReportConfirmOnArrival)inputValue; + } + + /// <summary> + /// Converts a "confirm on arrival" to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReportConfirmOnArrival( + ReportConfirmOnArrival inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Report Confirm On Delivery + + /// <summary> + /// Converts an XMS "confirm on delivery" key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReportConfirmOnDelivery ToReportConfirmOnDelivery( + Int32 inputValue) + { + return (ReportConfirmOnDelivery)inputValue; + } + + /// <summary> + /// Converts a "confirm on delivery" to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReportConfirmOnDelivery( + ReportConfirmOnDelivery inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Report Exception + + /// <summary> + /// Converts an XMS "report exceptions" key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReportExceptions ToReportExceptions( + Int32 inputValue) + { + return (ReportExceptions)inputValue; + } + + /// <summary> + /// Converts a "report exceptions" to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReportExceptions( + ReportExceptions inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Report Expiration + + /// <summary> + /// Converts an XMS "report expiration" key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReportExpiration ToReportExpiration( + Int32 inputValue) + { + return (ReportExpiration)inputValue; + } + + /// <summary> + /// Converts a "report expiration" to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReportExpiration( + ReportExpiration inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Report Correlation Id + + /// <summary> + /// Converts an XMS "report correlation id." key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReportCorrelationId ToReportCorrelationId( + Int32 inputValue) + { + return (ReportCorrelationId)inputValue; + } + + /// <summary> + /// Converts a "report correlation id." to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReportCorrelationId( + ReportCorrelationId inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Report Message Id + + /// <summary> + /// Converts an XMS "report message id." key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReportMessageId ToReportMessageId( + Int32 inputValue) + { + return (ReportMessageId)inputValue; + } + + /// <summary> + /// Converts a "report message id." to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReportMessageId( + ReportMessageId inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Asynchronous Exceptions + + /// <summary> + /// Converts an XMS asynchronous exceptions handling directive key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static AsynchronousExceptions ToAsynchronousExceptions( + Int32 inputValue) + { + return (AsynchronousExceptions)inputValue; + } + + /// <summary> + /// Converts an asynchronous exceptions handling directive to the + /// equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSAsynchronousExceptions( + AsynchronousExceptions inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Connection Type + + /// <summary> + /// Converts an XMS connection type key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ConnectionType ToConnectionType(Int32 inputValue) + { + return (ConnectionType)inputValue; + } + + /// <summary> + /// Converts a connection type to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSConnectionType(ConnectionType inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Delivery Mode + + /// <summary> + /// Converts an XMS delivery mode key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static DeliveryMode ToDeliveryMode(Int32 inputValue) + { + return (DeliveryMode)inputValue; + } + + /// <summary> + /// Converts a delivery mode to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSDeliveryMode(DeliveryMode inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Priority + + /// <summary> + /// Converts an XMS priority key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Priority ToPriority(Int32 inputValue) + { + return (Priority)inputValue; + } + + /// <summary> + /// Converts a priority to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSPriority(Priority inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Connection Protocol (RTT) + + /// <summary> + /// Converts an RTT connection protocol key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static RTTConnectionProtocol ToRTTConnectionProtocol( + Int32 inputValue) + { + return (RTTConnectionProtocol)inputValue; + } + + /// <summary> + /// Converts an RTT connection protocol to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSRTTConnectionProtocol( + RTTConnectionProtocol inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Multicast (RTT) + + /// <summary> + /// Converts an RTT multicast state key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Multicast ToMulticast(Int32 inputValue) + { + return (Multicast)inputValue; + } + + /// <summary> + /// Converts a multicast state to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMulticast(Multicast inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Broker Version (WMQ) + + /// <summary> + /// Converts a WMQ broker version key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static BrokerVersion ToBrokerVersion(Int32 inputValue) + { + return (BrokerVersion)inputValue; + } + + /// <summary> + /// Converts a broker version to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSBrokerVersion(BrokerVersion inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Reconnect Options (WMQ) + + /// <summary> + /// Converts a WMQ reconnect option key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReconnectOptions ToReconnectOptions(Int32 inputValue) + { + return (ReconnectOptions)inputValue; + } + + /// <summary> + /// Converts a reconnect option to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReconnectOptions(ReconnectOptions inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Connection Mode (WMQ) + + /// <summary> + /// Converts a WMQ connection mode key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ConnectionMode ToConnectionMode(Int32 inputValue) + { + return (ConnectionMode)inputValue; + } + + /// <summary> + /// Converts a connection mode to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSConnectionMode(ConnectionMode inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Fail If Quiesce (WMQ) + + /// <summary> + /// Converts a WMQ yes/no key to the equivalent boolean. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static bool ToFailIfQuiesce(Int32 inputValue) + { + switch(inputValue) + { + case XMSC.WMQ_FIQ_YES: return true; + case XMSC.WMQ_FIQ_NO : return false; + default: + ThrowCantConvertValueException(inputValue, "ToFailIfQuiesce"); + return false; + + } + } + + /// <summary> + /// Converts a WMQ boolean to the equivalent XMS yes/no value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSFailIfQuiesce(bool inputValue) + { + return inputValue ? XMSC.WMQ_FIQ_YES : XMSC.WMQ_FIQ_NO; + } + + #endregion + + #region Message Body (WMQ) + + /// <summary> + /// Converts a WMQ message body key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static MessageBody ToMessageBody(Int32 inputValue) + { + return (MessageBody)inputValue; + } + + /// <summary> + /// Converts a message body to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMessageBody(MessageBody inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Message Context (WMQ) + + /// <summary> + /// Converts a WMQ message context key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static MessageContext ToMessageContext(Int32 inputValue) + { + return (MessageContext)inputValue; + } + + /// <summary> + /// Converts a message context to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMessageContext(MessageContext inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region MQMD Read Enabled (WMQ) + + /// <summary> + /// Converts a WMQ yes/no key to the equivalent boolean. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static bool ToMQMDReadEnabled(Int32 inputValue) + { + return (inputValue != 0); + //switch(inputValue) + //{ + //case XMSC.WMQ_READ_ENABLED_YES: return true; + //case XMSC.WMQ_READ_ENABLED_NO : return false; + //default: + // ThrowCantConvertValueException(inputValue, "ToMQMDReadEnabled"); + // return false; + //} + } + + /// <summary> + /// Converts a WMQ boolean to the equivalent XMS yes/no value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMQMDReadEnabled(bool inputValue) + { + return inputValue ? 1 : 0; + // XMSC.WMQ_READ_ENABLED_YES : XMSC.WMQ_READ_ENABLED_NO; + } + + #endregion + + #region MQMD Write Enabled (WMQ) + + /// <summary> + /// Converts a WMQ yes/no key to the equivalent boolean. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static bool ToMQMDWriteEnabled(Int32 inputValue) + { + return (inputValue != 0); + //switch(inputValue) + //{ + //case XMSC.WMQ_WRITE_ENABLED_YES: return true; + //case XMSC.WMQ_WRITE_ENABLED_NO : return false; + //default: + // ThrowCantConvertValueException(inputValue, "ToMQMDWriteEnabled"); + // return false; + //} + } + + /// <summary> + /// Converts a WMQ boolean to the equivalent XMS yes/no value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMQMDWriteEnabled(bool inputValue) + { + return inputValue ? 1 : 0; + // XMSC.WMQ_WRITE_ENABLED_YES : XMSC.WMQ_WRITE_ENABLED_NO; + } + + #endregion + + #region Asynchronous Puts Allowed (WMQ) + + /// <summary> + /// Converts a WMQ asynchronous puts allowed key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static AsynchronousPutsAllowed ToAsynchronousPutsAllowed( + Int32 inputValue) + { + return (AsynchronousPutsAllowed)inputValue; + } + + /// <summary> + /// Converts a WMQ asynchronous puts allowed to the equivalent + /// XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSAsynchronousPutsAllowed( + AsynchronousPutsAllowed inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Read Ahead Allowed (WMQ) + + /// <summary> + /// Converts a WMQ read ahead allowed key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReadAheadAllowed ToReadAheadAllowed( + Int32 inputValue) + { + return (ReadAheadAllowed)inputValue; + } + + /// <summary> + /// Converts a WMQ read ahead allowed to the equivalent + /// XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReadAheadAllowed( + ReadAheadAllowed inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Read Ahead Close Policy (WMQ) + + /// <summary> + /// Converts a WMQ read ahead close policy key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReadAheadClosePolicy ToReadAheadClosePolicy( + Int32 inputValue) + { + return (ReadAheadClosePolicy)inputValue; + } + + /// <summary> + /// Converts a WMQ read ahead close policy to the equivalent + /// XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReadAheadClosePolicy( + ReadAheadClosePolicy inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Message Selection (WMQ) + + /// <summary> + /// Converts a WMQ message selection key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static MessageSelection ToMessageSelection(Int32 inputValue) + { + return (MessageSelection)inputValue; + } + + /// <summary> + /// Converts a WMQ message selection to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMessageSelection(MessageSelection inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Receive Conversion (WMQ) + + /// <summary> + /// Converts a WMQ receive conversion key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ReceiveConversion ToReceiveConversion(Int32 inputValue) + { + return (ReceiveConversion)inputValue; + } + + /// <summary> + /// Converts a WMQ receive conversion to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSReceiveConversion(ReceiveConversion inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Share Socket Allowed (WMQ) + + /// <summary> + /// Converts a WMQ yes/no key to the equivalent boolean. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static bool ToShareSocketAllowed(Int32 inputValue) + { + switch(inputValue) + { + case XMSC.WMQ_SHARE_CONV_ALLOWED_YES: return true; + case XMSC.WMQ_SHARE_CONV_ALLOWED_NO : return false; + default: + ThrowCantConvertValueException(inputValue, "ShareSocketAllowed"); + return false; + } + } + + /// <summary> + /// Converts a WMQ boolean to the equivalent XMS yes/no value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSShareSocketAllowed(bool inputValue) + { + return inputValue + ? XMSC.WMQ_SHARE_CONV_ALLOWED_YES + : XMSC.WMQ_SHARE_CONV_ALLOWED_NO; + } + + #endregion + + #region Target Client (WMQ) + + /// <summary> + /// Converts a WMQ target client key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static TargetClient ToTargetClient(Int32 inputValue) + { + return (TargetClient)inputValue; + } + + /// <summary> + /// Converts a WMQ target client to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSTargetClient(TargetClient inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Wildcard Format (WMQ) + + /// <summary> + /// Converts a WMQ wildcard format key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static WildcardFormat ToWildcardFormat(Int32 inputValue) + { + return (WildcardFormat)inputValue; + } + + /// <summary> + /// Converts a WMQ wildcard format to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSWildcardFormat(WildcardFormat inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Connection Protocol (WPM) + + /// <summary> + /// Converts a WPM connection protocol key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static WPMConnectionProtocol ToWPMConnectionProtocol( + Int32 inputValue) + { + return (WPMConnectionProtocol)inputValue; + } + + /// <summary> + /// Converts a WPM connection protocol to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSWPMConnectionProtocol( + WPMConnectionProtocol inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Connection Proximity (WPM) + + /// <summary> + /// Converts a WPM connection proximity key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static ConnectionProximity ToConnectionProximity( + Int32 inputValue) + { + return (ConnectionProximity)inputValue; + } + + /// <summary> + /// Converts a WPM connection proximity to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSConnectionProximity( + ConnectionProximity inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Mapping (WPM) + + /// <summary> + /// Converts a WPM mapping key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Mapping ToMapping(Int32 inputValue) + { + return (Mapping)inputValue; + } + + /// <summary> + /// Converts a WPM mapping to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSMapping(Mapping inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Target Significance (WPM) + + /// <summary> + /// Converts a WPM target significance key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static TargetSignificance ToTargetSignificance( + Int32 inputValue) + { + return (TargetSignificance)inputValue; + } + + /// <summary> + /// Converts a WPM target significance to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSTargetSignificance( + TargetSignificance inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #region Target Type (WPM) + + /// <summary> + /// Converts a WPM target type key. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static TargetType ToTargetType(Int32 inputValue) + { + return (TargetType)inputValue; + } + + /// <summary> + /// Converts a WPM target type to the equivalent XMS value. + /// </summary> + /// <param name="inputValue">Input value.</param> + /// <returns>Converted value.</returns> + public static Int32 ToXMSTargetType(TargetType inputValue) + { + return (Int32)inputValue; + } + + #endregion + + #endregion + + #region IBM XMS to Apache NMS enumerations conversion + + /// <summary> + /// Converts an IBM XMS destination type + /// to the equivalent NMS value. + /// </summary> + /// <param name="xmsDestinationType">XMS destination type.</param> + /// <param name="isTemporary">Whether the destination is temporary. + /// </param> + /// <returns>NMS destination type.</returns> + public static DestinationType ToDestinationType( + IBM.XMS.DestinationType xmsDestinationType, bool isTemporary) + { + switch(xmsDestinationType) + { + case IBM.XMS.DestinationType.Queue: + return(isTemporary + ? DestinationType.TemporaryQueue + : DestinationType.Queue); + + case IBM.XMS.DestinationType.Topic: + return(isTemporary + ? DestinationType.TemporaryTopic + : DestinationType.Queue); + + default: + ThrowCantConvertValueException( + xmsDestinationType.ToString(), + "ToDestinationType"); + return DestinationType.Queue; + } + } + + /// <summary> + /// Converts an IBM XMS acknowledgement mode + /// to the equivalent NMS value. + /// </summary> + /// <param name="acknowledgeMode">XMS acknowledgement mode.</param> + /// <returns>NMS acknowledgement mode.</returns> + public static Apache.NMS.AcknowledgementMode ToAcknowledgementMode( + IBM.XMS.AcknowledgeMode acknowledgeMode) + { + Apache.NMS.AcknowledgementMode acknowledge = + Apache.NMS.AcknowledgementMode.AutoAcknowledge; + + switch(acknowledgeMode) + { + case IBM.XMS.AcknowledgeMode.AutoAcknowledge: + acknowledge = Apache.NMS.AcknowledgementMode.AutoAcknowledge; + break; + + case IBM.XMS.AcknowledgeMode.ClientAcknowledge: + acknowledge = Apache.NMS.AcknowledgementMode.ClientAcknowledge; + break; + + case IBM.XMS.AcknowledgeMode.DupsOkAcknowledge: + acknowledge = Apache.NMS.AcknowledgementMode.DupsOkAcknowledge; + break; + + case IBM.XMS.AcknowledgeMode.SessionTransacted: + acknowledge = Apache.NMS.AcknowledgementMode.Transactional; + break; + } + + return acknowledge; + } + + /// <summary> + /// Converts an IBM XMS delivery mode + /// to the equivalent NMS value. + /// </summary> + /// <param name="deliveryMode">XMS delivery mode.</param> + /// <returns>NMS delivery mode.</returns> + public static MsgDeliveryMode ToNMSMsgDeliveryMode( + IBM.XMS.DeliveryMode deliveryMode) + { + if(deliveryMode == IBM.XMS.DeliveryMode.Persistent) + { + return MsgDeliveryMode.Persistent; + } + + if(deliveryMode == IBM.XMS.DeliveryMode.NonPersistent) + { + return MsgDeliveryMode.NonPersistent; + } + + // Hard cast it to the enumeration. + return (MsgDeliveryMode) deliveryMode; + } + + #endregion + + #region Apache NMS to IBM XMS enumerations conversion + + /// <summary> + /// Converts an NMS acknowledgement mode + /// to the equivalent IBM XMS value. + /// </summary> + /// <param name="acknowledge">NMS acknowledgement mode.</param> + /// <returns>IBM XMS acknowledgement mode.</returns> + public static IBM.XMS.AcknowledgeMode ToAcknowledgeMode( + Apache.NMS.AcknowledgementMode acknowledge) + { + IBM.XMS.AcknowledgeMode acknowledgeMode = + (IBM.XMS.AcknowledgeMode)0; + + switch(acknowledge) + { + case Apache.NMS.AcknowledgementMode.AutoAcknowledge: + acknowledgeMode = IBM.XMS.AcknowledgeMode.AutoAcknowledge; + break; + + case Apache.NMS.AcknowledgementMode.ClientAcknowledge: + acknowledgeMode = IBM.XMS.AcknowledgeMode.ClientAcknowledge; + break; + + case Apache.NMS.AcknowledgementMode.DupsOkAcknowledge: + acknowledgeMode = IBM.XMS.AcknowledgeMode.DupsOkAcknowledge; + break; + + case Apache.NMS.AcknowledgementMode.Transactional: + acknowledgeMode = IBM.XMS.AcknowledgeMode.SessionTransacted; + break; + } + + return acknowledgeMode; + } + + /// <summary> + /// Converts an NMS delivery mode + /// to the equivalent IBM XMS value. + /// </summary> + /// <param name="deliveryMode">NMS delivery mode.</param> + /// <returns>IBM XMS delivery mode.</returns> + public static IBM.XMS.DeliveryMode ToJMSDeliveryMode( + MsgDeliveryMode deliveryMode) + { + if(deliveryMode == MsgDeliveryMode.Persistent) + { + return IBM.XMS.DeliveryMode.Persistent; + } + + if(deliveryMode == MsgDeliveryMode.NonPersistent) + { + return IBM.XMS.DeliveryMode.NonPersistent; + } + + // Hard cast it to the enumeration. + return (IBM.XMS.DeliveryMode) deliveryMode; + } + + #endregion + + #region Enumerable adapter + + private class EnumerableAdapter : IEnumerable + { + private readonly IEnumerator enumerator; + public EnumerableAdapter(IEnumerator _enumerator) + { + this.enumerator = _enumerator; + } + + public IEnumerator GetEnumerator() + { + return this.enumerator; + } + } + + public static IEnumerable ToEnumerable(IEnumerator enumerator) + { + return new EnumerableAdapter(enumerator); + } + + #endregion + } +}
Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSEnum.cs URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSEnum.cs?rev=1723221&view=auto ============================================================================== --- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSEnum.cs (added) +++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/Util/XMSEnum.cs Wed Jan 6 02:19:56 2016 @@ -0,0 +1,1167 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; +using System.Collections; +using IBM.XMS; + +namespace Apache.NMS.XMS.Util +{ + +#region Encoding (IBM JMS)* + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_encoding.htm?lang=en +/// <summary> +/// How numerical data in the body of the message is represented when the XMS +/// client forwards the message to its intended destination. +/// </summary> +public enum Encoding +{ + /// <summary> + /// Normal integer encoding. + /// </summary> + IntegerNormal = MQC.MQENC_INTEGER_NORMAL, + + /// <summary> + /// Reversed integer encoding. + /// </summary> + IntegerReversed = MQC.MQENC_INTEGER_REVERSED, + + /// <summary> + /// Normal packed decimal encoding. + /// </summary> + DecimalNormal = MQC.MQENC_DECIMAL_NORMAL, + + /// <summary> + /// Reversed packed decimal encoding. + /// </summary> + DecimalReversed = MQC.MQENC_DECIMAL_REVERSED, + + /// <summary> + /// Normal IEEE floating point encoding. + /// </summary> + FloatIEEENormal = MQC.MQENC_FLOAT_IEEE_NORMAL, + + /// <summary> + /// Reversed IEEE floating point encoding. + /// </summary> + FloatIEEEReversed = MQC.MQENC_FLOAT_IEEE_REVERSED, + + /// <summary> + /// z/OS® architecture floating point encoding. + /// </summary> + FloatS390 = MQC.MQENC_FLOAT_S390, + + /// <summary> + /// Native machine encoding. + /// </summary> + Native = MQC.MQENC_NATIVE +} + +#endregion + +#region Message Type (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_msgtype.htm?lang=en +/// <summary> +/// Message type. +/// </summary> +public enum MessageType +{ + /// <summary> + /// The message is one that does not require a reply. + /// </summary> + Datagram = MQC.MQMT_DATAGRAM, + + /// <summary> + /// The message is one that requires a reply. + /// </summary> + Request = MQC.MQMT_REQUEST, + + /// <summary> + /// The message is a reply message. + /// </summary> + Reply = MQC.MQMT_REPLY, + + /// <summary> + /// The message is a report message. + /// </summary> + Report = MQC.MQMT_REPORT +} + +#endregion + +#region Report Confirm On Arrival (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_rep_coa.htm?lang=en +/// <summary> +/// Request 'confirm on arrival' report messages, specifying how much +/// application data from the original message must be included in a +/// report message. +/// </summary> +public enum ReportConfirmOnArrival +{ + /// <summary> + /// Request 'confirm on arrival' report messages, with no application + /// data from the original message included in a report message. + /// </summary> + NoData = MQC.MQRO_COA, + + /// <summary> + /// Request 'confirm on arrival' report messages, with the first 100 bytes + /// of application data from the original message included in a report + /// message. + /// </summary> + PartialData = MQC.MQRO_COA_WITH_DATA, + + /// <summary> + /// Request 'confirm on arrival' report messages, with all the application + /// data from the original message included in a report message. + /// </summary> + FullData = MQC.MQRO_COA_WITH_FULL_DATA +} + +#endregion + +#region Report Confirm On Delivery (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_rep_cod.htm?lang=en +/// <summary> +/// Request 'confirm on delivery' report messages, specifying how much +/// application data from the original message must be included in a +/// report message. +/// </summary> +public enum ReportConfirmOnDelivery +{ + /// <summary> + /// Request 'confirm on delivery' report messages, with no application + /// data from the original message included in a report message. + /// </summary> + NoData = MQC.MQRO_COD, + + /// <summary> + /// Request 'confirm on delivery' report messages, with the first 100 bytes + /// of application data from the original message included in a report + /// message. + /// </summary> + PartialData = MQC.MQRO_COD_WITH_DATA, + + /// <summary> + /// Request 'confirm on delivery' report messages, with all the application + /// data from the original message included in a report message. + /// </summary> + FullData = MQC.MQRO_COD_WITH_FULL_DATA +} + +#endregion + +#region Report Exception (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_rep_excpt.htm?lang=en +/// <summary> +/// Request exception report messages, specifying how much application data +/// from the original message must be included in a report message. +/// </summary> +public enum ReportExceptions +{ + /// <summary> + /// Request exception report messages, with no application data from the + /// original message included in a report message. + /// </summary> + NoData = MQC.MQRO_COD, + + /// <summary> + /// Request exception report messages, with the first 100 bytes of + /// application data from the original message included in a report + /// message. + /// </summary> + PartialData = MQC.MQRO_COD_WITH_DATA, + + /// <summary> + /// Request exception report messages, with all the application data from + /// the original message included in a report message. + /// </summary> + FullData = MQC.MQRO_COD_WITH_FULL_DATA +} + +#endregion + +#region Report Expiration (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_rep_exprn.htm?lang=en +/// <summary> +/// Request expiration report messages, specifying how much application data +/// from the original message must be included in a report message. +/// </summary> +public enum ReportExpiration +{ + /// <summary> + /// Request expiration report messages, with no application data from the + /// original message included in a report message. + /// </summary> + NoData = MQC.MQRO_EXPIRATION, + + /// <summary> + /// Request expiration report messages, with the first 100 bytes of + /// application data from the original message included in a report + /// message. + /// </summary> + PartialData = MQC.MQRO_EXPIRATION_WITH_DATA, + + /// <summary> + /// Request expiration report messages, with all the application data from + /// the original message included in a report message. + /// </summary> + FullData = MQC.MQRO_EXPIRATION_WITH_FULL_DATA +} + +#endregion + +#region Report Correlation Id (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_rep_pcid.htm?lang=en +/// <summary> +/// Request that the correlation identifier of any report or reply message +/// is the same as the correlation identifier of the original message. +/// </summary> +public enum ReportCorrelationId +{ + /// <summary> + /// Request that the correlation identifier of any report or reply message + /// is the same as the correlation identifier of the original message. + /// </summary> + OriginalCorrelationId = MQC.MQRO_PASS_CORREL_ID, + + /// <summary> + /// Request that the correlation identifier of any report or reply message + /// is the same as the message identifier of the original message. + /// </summary> + OriginalMessageId = MQC.MQRO_COPY_MSG_ID_TO_CORREL_ID +} + +#endregion + +#region Report Message Id (IBM JMS) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prp_jms_ibm_rep_pmid.htm?lang=en +/// <summary> +/// Request that the message identifier of any report or reply message is the +/// same as the message identifier of the original message. +/// </summary> +public enum ReportMessageId +{ + /// <summary> + /// Request that the message identifier of any report or reply message is the same as the message identifier of the original message. + /// </summary> + OriginalMessageId = MQC.MQRO_PASS_MSG_ID, + + /// <summary> + /// Request that a new message identifier is generated for each report or + /// reply message. + /// </summary> + NewMessageId = MQC.MQRO_NEW_MSG_ID +} + +#endregion + +#region Asynchronous Exceptions + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_async_exceptions.htm?lang=en +/// <summary> +/// whether XMS informs an ExceptionListener only when a connection is broken, +/// or when any exception occurs asynchronously to an XMS API call. +/// </summary> +public enum AsynchronousExceptions +{ + /// <summary> + /// Any exception detected asynchronously, outside the scope of a + /// synchronous API call, and all connection broken exceptions are sent + /// to the <c>ExceptionListener</c>. + /// </summary> + All = XMSC.ASYNC_EXCEPTIONS_ALL, + + /// <summary> + /// Only exceptions indicating a broken connection are sent to the + /// <c>ExceptionListener</c>. Any other exceptions occurring during + /// asynchronous processing are not reported to the + /// <c>ExceptionListener</c>, and hence the application is not informed + /// of these exceptions. + /// </summary> + ConnectionBroken = XMSC.ASYNC_EXCEPTIONS_CONNECTIONBROKEN +} + +#endregion + +#region Connection Type + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_connection_type.htm?lang=en +/// <summary> +/// The type of messaging server to which an application connects. +/// </summary> +public enum ConnectionType +{ + /// <summary> + /// A real-time connection to a broker. + /// </summary> + RTT = XMSC.CT_RTT, + + /// <summary> + /// A connection to a WebSphere® MQ queue manager. + /// </summary> + WMQ = XMSC.CT_WMQ, + + /// <summary> + /// A connection to a WebSphere service integration bus. + /// </summary> + WPM = XMSC.CT_WPM +} + +#endregion + +#region Delivery Mode + +/// <summary> +/// The delivery mode of messages sent to the destination. +/// </summary> +public enum DeliveryMode +{ + /// <summary> + /// A message sent to the destination is nonpersistent. The default + /// delivery mode of the message producer, or any delivery mode specified + /// on the Send call, is ignored. If the destination is a WebSphere MQ + /// queue, the value of the queue attribute <c>DefPersistence</c> is also + /// ignored. + /// </summary> + NotPersistent = XMSC.DELIVERY_NOT_PERSISTENT, + + /// <summary> + /// A message sent to the destination is persistent. The default + /// delivery mode of the message producer, or any delivery mode specified + /// on the Send call, is ignored. If the destination is a WebSphere MQ + /// queue, the value of the queue attribute <c>DefPersistence</c> is also + /// ignored. + /// </summary> + Persistent = XMSC.DELIVERY_PERSISTENT, + + /// <summary> + /// A message sent to the destination has the delivery mode specified on + /// the Send call. If the Send call specifies no delivery mode, the default + /// delivery mode of the message producer is used instead. If the + /// destination is a WebSphere MQ queue, the value of the queue attribute + /// <c>DefPersistence</c> is ignored. + /// </summary> + AsApplication = XMSC.DELIVERY_AS_APP, + + /// <summary> + /// If the destination is a WebSphere MQ queue, a message put on the queue + /// has the delivery mode specified by the value of the queue attribute + /// <c>DefPersistence</c>. The default delivery mode of the message + /// producer, or any delivery mode specified on the Send call, is ignored. + /// </summary> + AsDestination = XMSC.DELIVERY_AS_DEST +} + +#endregion + +#region Priority + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_priority.htm?lang=en +/// <summary> +/// The priority of messages sent to the destination. +/// </summary> +public enum Priority +{ + /// <summary> + /// Lowest message priority. + /// </summary> + Lowest = 0, + + /// <summary> + /// Between Low and Lowest message priority. + /// </summary> + VeryLow = 1, + + /// <summary> + /// Low message priority. + /// </summary> + Low = 2, + + /// <summary> + /// Normal message priority. + /// </summary> + Normal = 5, + + /// <summary> + /// Between High and Normal message priority. + /// </summary> + AboveNormal = 6, + + /// <summary> + /// High message priority. + /// </summary> + High = 7, + + /// <summary> + /// Between Highest and High message priority. + /// </summary> + VeryHigh = 8, + + /// <summary> + /// Highest message priority. + /// </summary> + Highest = 9, + + /// <summary> + /// A message sent to the destination has the priority specified on the + /// Send call. If the Send call specifies no priority, the default + /// priority of the message producer is used instead. If the destination + /// is a WebSphere MQ queue, the value of the queue attribute + /// <c>DefPriority</c> is ignored. + /// </summary> + AsApplication = XMSC.PRIORITY_AS_APP, + + /// <summary> + /// If the destination is a WebSphere MQ queue, a message put on the + /// queue has the priority specified by the value of the queue attribute + /// <c>DefPriority</c>. The default priority of the message producer, + /// or any priority specified on the Send call, is ignored. + /// </summary> + AsDestination = XMSC.PRIORITY_AS_DEST +} + +#endregion + +#region Connection Protocol (RTT) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_rtt_conn_prot.htm?lang=en +/// <summary> +/// The communications protocol used for a real-time connection to a broker. +/// </summary> +public enum RTTConnectionProtocol +{ + /// <summary> + /// Real-time connection to a broker over TCP/IP. + /// <c>ConnectionFactory</c> object. + /// </summary> + TCP = XMSC.RTT_CP_TCP +} + +#endregion + +#region Multicast (RTT) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_rtt_multicast.htm?lang=en +/// <summary> +/// The multicast setting for a connection factory or destination. Only a +/// destination that is a topic can have this property. +/// An application uses this property to enable multicast in association with +/// a real-time connection to a broker and, if multicast is enabled, to +/// specify the precise way in which multicast is used to deliver messages +/// from the broker to a message consumer. The property has no effect on how +/// a message producer sends messages to the broker. +/// </summary> +public enum Multicast +{ + /// <summary> + /// Messages are not delivered to a message consumer using WebSphere® MQ + /// Multicast Transport. This value is the default value for a + /// <c>ConnectionFactory</c> object. + /// </summary> + Disabled = XMSC.RTT_MULTICAST_DISABLED, + + /// <summary> + /// Messages are delivered to a message consumer according to the multicast + /// setting for the connection factory associated with the message consumer. + /// The multicast setting for the connection factory is noted at the time + /// that the connection is created. This value is valid only for a + /// <c>Destination</c> object, and is the default value for a + /// <c>Destination</c> object. + /// </summary> + AsConnectionFactory = XMSC.RTT_MULTICAST_ASCF, + + /// <summary> + /// If the topic is configured for multicast in the broker, messages are + /// delivered to a message consumer using WebSphere MQ Multicast Transport. + /// A reliable quality of service is used if the topic is configured for + /// reliable multicast. + /// </summary> + Enabled = XMSC.RTT_MULTICAST_ENABLED, + + /// <summary> + /// If the topic is configured for reliable multicast in the broker, + /// messages are delivered to a message consumer using WebSphere MQ + /// Multicast Transport with a reliable quality of service. If the topic + /// is not configured for reliable multicast, you cannot create a message + /// consumer for the topic. + /// </summary> + Reliable = XMSC.RTT_MULTICAST_RELIABLE, + + /// <summary> + /// If the topic is configured for multicast in the broker, messages are + /// delivered to a message consumer using WebSphere MQ Multicast Transport. + /// A reliable quality of service is not used even if the topic is + /// configured for reliable multicast. + /// </summary> + NotReliable = XMSC.RTT_MULTICAST_NOT_RELIABLE +} + +#endregion + +#region Broker Version (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wmq_brkr_version.htm?lang=en +/// <summary> +/// The type of broker used by the application for a connection or for the +/// destination. Only a destination that is a topic can have this property. +/// </summary> +public enum BrokerVersion +{ + /// <summary> + /// The application is using a WebSphere® MQ Publish/Subscribe broker. + /// </summary> + Version1 = XMSC.WMQ_BROKER_V1, + + /// <summary> + /// The application is using a broker of IBM® Integration Bus. + /// </summary> + Version2 = XMSC.WMQ_BROKER_V2, + + /// <summary> + /// After the broker is migrated, set this property so that RFH2 headers + /// are no longer used. After migration, this property is no longer + /// relevant. + /// </summary> + Unspecified = XMSC.WMQ_BROKER_UNSPECIFIED +} + +#endregion + +#region Reconnect Options (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_rtt_client_reconnect_options.htm?lang=en +/// <summary> +/// Client reconnect options for new connections created by a factory. +/// </summary> +public enum ReconnectOptions +{ + /// <summary> + /// Use the value specified in the <c>mqclient.ini</c> file. Set the value + /// by using the DefRecon property within the Channels stanza. + /// </summary> + AsDefault = XMSC.WMQ_CLIENT_RECONNECT_AS_DEF, + + /// <summary> + /// Reconnect to any of the queue managers specified in the connection name + /// list. + /// </summary> + AnyQueueManager = XMSC.WMQ_CLIENT_RECONNECT, + + /// <summary> + /// Reconnects to the same queue manager that it is originally connected to. + /// It returns <c>MQRC.RECONNECT_QMID_MISMATCH</c> if the queue manager it + /// tries to connect to (specified in the connection name list) has a + /// different QMID to the queue manager originally connected to. + /// </summary> + SameQueueManager = XMSC.WMQ_CLIENT_RECONNECT_Q_MGR, + + /// <summary> + /// Reconnection is disabled. + /// </summary> + Disabled = XMSC.WMQ_CLIENT_RECONNECT_DISABLED +} + +#endregion + +#region Connection Mode (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wmq_conn_mode.htm?lang=en +/// <summary> +/// The mode by which an application connects to a queue manager. +/// </summary> +public enum ConnectionMode +{ + /// <summary> + /// A connection to a queue manager in bindings mode, for optimal performance. This value is the default value for C/C++. + /// </summary> + Bindings = XMSC.WMQ_CM_BINDINGS, + + /// <summary> + /// A connection to a queue manager in client mode, to ensure a fully managed stack. This value is the default value for .NET. + /// </summary> + Client = XMSC.WMQ_CM_CLIENT, + + /// <summary> + /// A connection to a queue manager which forces an unmanaged client stack. + /// </summary> + ClientUnmanaged = XMSC.WMQ_CM_CLIENT_UNMANAGED +} + +#endregion + +#region Encoding (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wmq_encoding.htm?lang=en +// cf. "Encoding (IBM JMS)" + +#endregion + +#region Fail If Quiesce (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wmq_fail_if_quiesce.htm?lang=en +/// <summary> +/// Whether calls to certain methods fail if the queue manager to which the +/// application is connected is in a quiescing state. +/// </summary> +public enum FailIfQuiesce +{ + /// <summary> + /// Calls to certain methods fail if the queue manager is in a quiescing + /// state. When the application detects that the queue manager is + /// quiescing, the application can complete its immediate task and close + /// the connection, allowing the queue manager to stop. + /// </summary> + Yes = XMSC.WMQ_FIQ_YES, + + /// <summary> + /// No method calls fail because the queue manager is in a quiescing + /// state. If you specify this value, the application cannot detect that + /// the queue manager is quiescing. The application might continue to + /// perform operations against the queue manager and therefore prevent + /// the queue manager from stopping. + /// </summary> + No = XMSC.WMQ_FIQ_NO +} + +#endregion + +#region Message Body (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_message_body.htm?lang=en +/// <summary> +/// Whether an XMS application processes the <c>MQRFH2</c> of a WebSphere® +/// MQ message as part of the message payload (that is, as part of the +/// message body). +/// </summary> +public enum MessageBody +{ + /// <summary> + /// Receive: The inbound XMS message type and body are determined by the + /// contents of the <c>MQRFH2</c> (if present) or the <c>MQMD</c> (if there + /// is no <c>MQRFH2</c>) in the received WebSphere MQ message. + /// Send: The outbound XMS message body contains a prepended and + /// auto-generated <c>MQRFH2</c> header based on XMS Message properties and + /// header fields. + /// </summary> + JMS = XMSC.WMQ_MESSAGE_BODY_JMS, + + /// <summary> + /// Receive: The inbound XMS message type is always <c>ByteMessage</c>, + /// irrespective of the contents of received WebSphere MQ message or the + /// format field of the received <c>MQMD</c>. The XMS message body is the + /// unaltered message data returned by the underlying messaging provider + /// API call. The character set and encoding of the data in the message + /// body is determined by the <c>CodedCharSetId</c> and <c>Encoding</c> + /// fields of the <c>MQMD</c>. The format of the data in the message body + /// is determined by the <c>Format</c> field of the <c>MQMD</c>. + /// Send: The outbound XMS message body contains the application payload + /// as-is; and no auto-generated WebSphere MQ header is added to the body. + /// </summary> + MQ = XMSC.WMQ_MESSAGE_BODY_MQ, + + /// <summary> + /// Receive: The XMS client determines a suitable value for this property. + /// On receive path, this value is the <c>WMQ_MESSAGE_BODY_JMS</c> property + /// value. + /// Send: The XMS client determines a suitable value for this property. On + /// send path, this value is the <c>XMSC_WMQ_TARGET_CLIENT</c> property + /// value. + /// </summary> + Unspecified = XMSC.WMQ_MESSAGE_BODY_UNSPECIFIED +} + +#endregion + +#region Message Context (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_mqmd_message_context.htm?lang=en +/// <summary> +/// Determines what level of message context is to be set by the XMS +/// application. The application must be running with appropriate context +/// authority for this property to take effect. +/// </summary> +public enum MessageContext +{ + /// <summary> + /// For outbound messages, the <c>MQOPEN</c> API call and the <c>MQPMO</c> + /// structure specifies no explicit message context options. + /// </summary> + Default = XMSC.WMQ_MDCTX_DEFAULT, + + /// <summary> + /// The <c>MQOPEN</c> API call specifies the message context option + /// <c>MQOO_SET_IDENTITY_CONTEXT</c> and the <c>MQPMO</c> structure + /// specifies <c>MQPMO_SET_IDENTITY_CONTEXT</c>. + /// </summary> + SetIdentity = XMSC.WMQ_MDCTX_SET_IDENTITY_CONTEXT, + + /// <summary> + /// The <c>MQOPEN</c> API call specifies the message context option + /// <c>MQOO_SET_ALL_CONTEXT</c> and the <c>MQPMO</c> structure + /// specifies <c>MQPMO_SET_ALL_CONTEXT</c>. + /// </summary> + SetAll = XMSC.WMQ_MDCTX_SET_ALL_CONTEXT, +} + +#endregion + +#region MQMD Read Enabled (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_mqmd_read_enabled.htm?lang=en +/// <summary> +/// Whether an XMS application can extract the values of MQMD fields or not. +/// </summary> +public enum MQMDReadEnabled +{ + /// <summary> + /// When sending messages, the <c>JMS_IBM_MQMD*</c> properties on a sent + /// message are not updated to reflect the updated field values in the + /// <c>MQMD</c>. + /// When receiving messages, none of the <c>JMS_IBM_MQMD*</c> properties + /// are available on a received message, even if some or all of them are + /// set by the sender. + /// </summary> + No = 0, //XMSC.WMQ_READ_ENABLED_NO, + + /// <summary> + /// When sending messages, all of the <c>JMS_IBM_MQMD*</c> properties on + /// a sent message are updated to reflect the updated field values in the + /// <c>MQMD</c>, including those properties that the sender did not set + /// explicitly. + /// When receiving messages, all of the <c>JMS_IBM_MQMD*</c> properties + /// are available on a received message, including those properties that + /// the sender did not set explicitly. + /// </summary> + Yes = 1 //XMSC.WMQ_READ_ENABLED_YES +} + +#endregion + +#region MQMD Write Enabled (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_mqmd_write_enabled.htm?lang=en +/// <summary> +/// Whether an XMS application can write the values of MQMD fields or not. +/// </summary> +public enum MQMDWriteEnabled +{ + /// <summary> + /// All <c>JMS_IBM_MQMD*</c> properties are ignored and their values are + /// not copied into the underlying <c>MQMD</c> structure. + /// </summary> + No = 0, //XMSC.WMQ_WRITE_ENABLED_NO, + + /// <summary> + /// <c>JMS_IBM_MQMD*</c> properties are processed. Their values are copied + /// into the underlying <c>MQMD</c> structure. + /// </summary> + Yes = 1 //XMSC.WMQ_WRITE_ENABLED_YES +} + +#endregion + +#region Asynchronous Puts Allowed (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_put_async_allowed.htm?lang=en +/// <summary> +/// Whether message producers are allowed to use asynchronous puts to send +/// messages to this destination. +/// </summary> +public enum AsynchronousPutsAllowed +{ + /// <summary> + /// Determine whether asynchronous puts are allowed by referring to the + /// queue or topic definition. + /// </summary> + AsDestination = XMSC.WMQ_PUT_ASYNC_ALLOWED_AS_DEST, + + /// <summary> + /// Determine whether asynchronous puts are allowed by referring to the + /// queue definition. + /// </summary> + AsQueueDefinition = XMSC.WMQ_PUT_ASYNC_ALLOWED_AS_Q_DEF, + + /// <summary> + /// Determine whether asynchronous puts are allowed by referring to the + /// topic definition. + /// </summary> + AsTopicDefinition = XMSC.WMQ_PUT_ASYNC_ALLOWED_AS_TOPIC_DEF, + + /// <summary> + /// Asynchronous puts are not allowed. + /// </summary> + Disabled = XMSC.WMQ_PUT_ASYNC_ALLOWED_DISABLED, + + /// <summary> + /// Asynchronous puts are allowed. + /// </summary> + Enabled = XMSC.WMQ_PUT_ASYNC_ALLOWED_ENABLED +} + +#endregion + +#region Read Ahead Allowed (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_read_ahead_allowed.htm?lang=en +/// <summary> +/// Whether message consumers and queue browsers are allowed to use read ahead +/// to get non-persistent, non-transactional messages from this destination +/// into an internal buffer before receiving them. +/// </summary> +public enum ReadAheadAllowed +{ + /// <summary> + /// Determine whether read ahead is allowed by referring to the queue + /// definition. + /// </summary> + AsQueueDefinition = XMSC.WMQ_READ_AHEAD_ALLOWED_AS_Q_DEF, + + /// <summary> + /// Determine whether read ahead is allowed by referring to the topic + /// definition. + /// </summary> + AsTopicDefinition = XMSC.WMQ_READ_AHEAD_ALLOWED_AS_TOPIC_DEF, + + /// <summary> + /// Determine whether read ahead is allowed by referring to the queue + /// or topic definition. + /// </summary> + AsDestinationDefinition = XMSC.WMQ_READ_AHEAD_ALLOWED_AS_DEST, + + /// <summary> + /// Read ahead is not allowed while consuming or browsing messages. + /// </summary> + Disabled = XMSC.WMQ_READ_AHEAD_ALLOWED_DISABLED, + + /// <summary> + /// Read ahead is allowed. + /// </summary> + Enabled = XMSC.WMQ_READ_AHEAD_ALLOWED_ENABLED +} + +#endregion + +#region Read Ahead Close Policy (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_read_ahead_close_policy.htm?lang=en +/// <summary> +/// This property determines, for messages being delivered to an asynchronous +/// message listener, what happens to messages in the internal read ahead buffer +/// when the message consumer is closed. +/// </summary> +public enum ReadAheadClosePolicy +{ + /// <summary> + /// Only the current message listener invocation completes before returning, + /// potentially leaving messages in the internal read ahead buffer, which + /// are then discarded. + /// </summary> + DeliverCurrent = XMSC.WMQ_READ_AHEAD_DELIVERCURRENT, + + /// <summary> + /// All messages in the internal read ahead buffer are delivered to the + /// application message listener before returning. + /// </summary> + DeliverAll = XMSC.WMQ_READ_AHEAD_DELIVERALL +} + +#endregion + +#region Message Selection (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wmq_mes_selection.htm?lang=en +/// <summary> +/// Determines whether message selection is done by the XMS client or by +/// the broker. +/// </summary> +public enum MessageSelection +{ + /// <summary> + /// Message selection is done by the XMS client. + /// </summary> + Client = XMSC.WMQ_MSEL_CLIENT, + + /// <summary> + /// Message selection is done by the broker. + /// </summary> + Broker = XMSC.WMQ_MSEL_BROKER +} + +#endregion + +#region Receive Conversion (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_receive_conversion.htm?lang=en +/// <summary> +/// Whether data conversion is going to be performed by the queue manager. +/// </summary> +public enum ReceiveConversion +{ + /// <summary> + /// Perform data conversion on the XMS client only. Conversion is always + /// done using codepage 1208. + /// </summary> + Client = XMSC.WMQ_RECEIVE_CONVERSION_CLIENT_MSG, + + /// <summary> + /// Perform data conversion on the queue manager before sending a message + /// to the XMS client. + /// </summary> + QueueManager = XMSC.WMQ_RECEIVE_CONVERSION_QMGR +} + +#endregion + +#region Share Socket Allowed (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_share_conv_allowed.htm?lang=en +/// <summary> +/// Whether a client connection can share its socket with other top-level XMS +/// connections from the same process to the same queue manager, if the channel +/// definitions match. +/// </summary> +public enum ShareSocketAllowed +{ + /// <summary> + /// Connections do not share a socket. + /// </summary> + False = XMSC.WMQ_SHARE_CONV_ALLOWED_NO, + + /// <summary> + /// Connections share a socket. + /// </summary> + True = XMSC.WMQ_SHARE_CONV_ALLOWED_YES +} + +#endregion + +#region Target Client (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wmq_target_client.htm?lang=en +/// <summary> +/// Whether messages sent to the destination contain an <c>MQRFH2</c> header. +/// </summary> +public enum TargetClient +{ + /// <summary> + /// Messages sent to the destination contain an <c>MQRFH2</c> header. + /// Specify this value if the application is sending the messages to + /// another XMS application, a WebSphere® JMS application, or a native + /// WebSphere MQ application that is designed to handle an <c>MQRFH2</c> + /// header. + /// </summary> + JMS = XMSC.WMQ_TARGET_DEST_JMS, + + /// <summary> + /// Messages sent to the destination do not contain an <c>MQRFH2</c> + /// header. Specify this value if the application is sending the messages + /// to a native WebSphere MQ application that is not designed to handle + /// an <c>MQRFH2</c> header. + /// </summary> + MQ = XMSC.WMQ_TARGET_DEST_MQ +} + +#endregion + +#region Wildcard Format (WMQ) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/xmsc_wmq_wildcard_format.htm?lang=en +/// <summary> +/// This property determines which version of wildcard syntax is to be used. +/// </summary> +public enum WildcardFormat +{ + /// <summary> + /// Recognizes the topic level wildcards only i.e. '#' and '+' are treated + /// as wildcards. + /// </summary> + TopicOnly = XMSC.WMQ_WILDCARD_TOPIC_ONLY, + + /// <summary> + /// Recognizes the character wildcards only i.e. '*' and '?' are treated + /// as wildcards. + /// </summary> + CharacterOnly = XMSC.WMQ_WILDCARD_CHAR_ONLY +} + +#endregion + +#region Connection Protocol (WPM) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wpm_conn_prot.htm?lang=en +/// <summary> +/// The communications protocol used for the connection to the messaging +/// engine. +/// </summary> +public enum WPMConnectionProtocol +{ + /// <summary> + /// The connection uses HTTP over TCP/IP. + /// </summary> + HTTP = XMSC.WPM_CP_HTTP, + + /// <summary> + /// The connection uses TCP/IP. + /// </summary> + TCP = XMSC.WPM_CP_TCP +} + +#endregion + +#region Connection Proximity (WPM) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wpm_conn_prox.htm?lang=en +/// <summary> +/// The connection proximity setting for the connection. This property +/// determines how close the messaging engine that the application connects +/// to must be to the bootstrap server. +/// </summary> +public enum ConnectionProximity +{ + /// <summary> + /// Bus. + /// </summary> + Bus, // XMSC.WPM_CONNECTION_PROXIMITY_BUS = "Bus" + + /// <summary> + /// Cluster. + /// </summary> + Cluster, // XMSC.WPM_CONNECTION_PROXIMITY_CLUSTER = "Cluster" + + /// <summary> + /// Host. + /// </summary> + Host, // XMSC.WPM_CONNECTION_PROXIMITY_HOST = "Host" + + /// <summary> + /// Server. + /// </summary> + Server // XMSC.WPM_CONNECTION_PROXIMITY_SERVER = "Server" +} + +#endregion + +#region Mapping (WPM) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wpm_non_pers_m.htm?lang=en +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wpm_pers_m.htm?lang=en +/// <summary> +/// The reliability level of messages that are sent using the connection. +/// </summary> +public enum Mapping +{ + /// <summary> + /// Determined by the default reliability level specified for the queue + /// or topic space in the service integration bus. + /// </summary> + AsDestination = XMSC.WPM_MAPPING_AS_DESTINATION, + + /// <summary> + /// Best effort nonpersistent. + /// </summary> + BestEffortNonPersistent = XMSC.WPM_MAPPING_BEST_EFFORT_NON_PERSISTENT, + + /// <summary> + /// Express nonpersistent. + /// </summary> + ExpressNonPersistent = XMSC.WPM_MAPPING_EXPRESS_NON_PERSISTENT, + + /// <summary> + /// Reliable nonpersistent. + /// </summary> + ReliableNonPersistent = XMSC.WPM_MAPPING_RELIABLE_NON_PERSISTENT, + + /// <summary> + /// Reliable persistent. + /// </summary> + ReliablePersistent = XMSC.WPM_MAPPING_RELIABLE_PERSISTENT, + + /// <summary> + /// Assured persistent. + /// </summary> + AssuredPersistent = XMSC.WPM_MAPPING_ASSURED_PERSISTENT +} + +#endregion + +#region Target Significance (WPM) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wpm_target_signf.htm?lang=en +/// <summary> +/// The significance of the target group of messaging engines. +/// </summary> +public enum TargetSignificance +{ + /// <summary> + /// A messaging engine in the target group is selected if one is available. + /// Otherwise, a messaging engine outside the target group is selected, + /// provided it is in the same service integration bus. + /// </summary> + Preferred, // XMSC.WPM_TARGET_SIGNIFICANCE_PREFERRED = "Preferred" + + /// <summary> + /// The selected messaging engine must be in the target group. If a + /// messaging engine in the target group is not available, the connection + /// process fails. + /// </summary> + Required // XMSC.WPM_TARGET_SIGNIFICANCE_REQUIRED = "Required" +} + +#endregion + +#region Target Type (WPM) + +// http://www-01.ibm.com/support/knowledgecenter/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/prx_wpm_target_type.htm?lang=en +/// <summary> +/// The type of the target group of messaging engines. This property +/// determines the nature of the target group identified by the +/// <c>XMSC_WPM_TARGET_GROUP</c> property. +/// </summary> +public enum TargetType +{ + /// <summary> + /// The name of the target group is the name of a bus member. The target + /// group is all the messaging engines in the bus member. + /// </summary> + BusMember, // XMSC.WPM_TARGET_TYPE_BUSMEMBER = "BusMember" + + /// <summary> + /// The name of the target group is the name of a user-defined group of + /// messaging engines. The target group is all the messaging engines that + /// are registered with the user-defined group. + /// </summary> + Custom, // XMSC.WPM_TARGET_TYPE_CUSTOM = "Custom" + + /// <summary> + /// The name of the target group is the name of a messaging engine. The + /// target group is the specified messaging engine. + /// </summary> + MessagingEngine // XMSC.WPM_TARGET_TYPE_ME = "ME" +} + +#endregion + +} \ No newline at end of file Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/_TODO_.txt URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/_TODO_.txt?rev=1723221&view=auto ============================================================================== --- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/_TODO_.txt (added) +++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/csharp/_TODO_.txt Wed Jan 6 02:19:56 2016 @@ -0,0 +1,29 @@ + ~ BytesMessage.cs // Ajouter commentaires + X Connection.cs + X ConnectionFactory.cs + X ConnectionMetaData.cs + X Destination.cs + X InitialContext.cs + X MapMessage.cs + X Message.cs + ~ MessageConsumer.cs // Ajouter commentaires + ~ MessageProducer.cs // Ajouter commentaires + ~ MessageProperties.cs // Ajouter commentaires + X ObjectMessage.cs + X Queue.cs + ~ QueueBrowser.cs // Ajouter commentaires + ~ Session.cs // Ajouter commentaires + X StreamMessage.cs + X TemporaryQueue.cs + X TemporaryTopic.cs + X TextMessage.cs + X Topic.cs + ? Util\Dispatcher.cs + X Util\ExceptionUtil.cs + X Util\IntrospectionSupport.cs + X Util\UriAttributeAttribute.cs + X Util\XMSConvert.cs + X Util\XMSEnum.cs + + +Temporary Queue / Topic \ No newline at end of file Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/ndoc/NamespaceSummary.xml URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/ndoc/NamespaceSummary.xml?rev=1723221&view=auto ============================================================================== --- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/ndoc/NamespaceSummary.xml (added) +++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/ndoc/NamespaceSummary.xml Wed Jan 6 02:19:56 2016 @@ -0,0 +1,21 @@ +<!-- + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +--> +<namespaces> + <namespace name="XMS"> + The <b>XMS</b> namespace defines the IBM XMS provider API for the .Net Message System (NMS) API, which is an interface to messaging systems rather like JMS is for Java. + </namespace> +</namespaces> Added: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/sandcastle/feedback_content.xml URL: http://svn.apache.org/viewvc/activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/sandcastle/feedback_content.xml?rev=1723221&view=auto ============================================================================== --- activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/sandcastle/feedback_content.xml (added) +++ activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/main/sandcastle/feedback_content.xml Wed Jan 6 02:19:56 2016 @@ -0,0 +1,32 @@ +<content xml:space="preserve"> + + <item id="fb_alias">[email protected]</item> + <item id="fb_product"></item> + <item id="fb_deliverable"></item> + + <item id="fb_subject">Customer%20Feedback</item> + <item id="fb_body">%0\dThank%20you%20for%20your%20feedback.%20The%20developer%20writing%20teams%20use%20your%20feedback%20to%20improve%20documentation.%20While%20we%20are%20reviewing%20your%20feedback,%20we%20may%20send%20you%20e-mail%20to%20ask%20for%20clarification%20or%20feedback%20on%20a%20solution.%20We%20do%20not%20use%20your%20e-mail%20address%20for%20any%20other%20purpose.%0\d</item> + + <item id="fb_headerFeedBack">Send Feedback</item> + + + <!-- feedback values for sandcastle scenario --> + + <item id="feedback_alias"></item> + <item id="feedback_product"></item> + <item id="feedback_deliverable"></item> + <item id="feedback_fileVersion"></item> + <item id="feedback_topicVersion"></item> + <item id="feedback_body"></item> + <item id="feedback_subject"></item> + + <item id="fb_Introduction">We value your feedback. To rate this topic and send feedback about this topic to the documentation team, click a rating, and then click <b>Send Feedback</b>. For assistance with support issues, refer to the technical support information included with the product.</item> + + <item id="fb_Send">Send Feedback</item> + <item id="fb_Poor">Poor</item> + <item id="fb_Excellent">Outstanding</item> + <item id="fb_EnterFeedbackText">To e-mail your feedback, click here:</item> + <item id="fb_Title">Documentation Feedback</item> + <item id="fb_altIcon">Display feedback instructions at the bottom of the page.</item> + +</content> \ No newline at end of file Propchange: activemq/activemq-dotnet/Apache.NMS.XMS/trunk/src/test/csharp/ ------------------------------------------------------------------------------ --- svn:ignore (added) +++ svn:ignore Wed Jan 6 02:19:56 2016 @@ -0,0 +1 @@ +CommonAssemblyInfo.cs
