protected override void Process(IMessage input, Action<IMessage> continueWith, Action<FlowRuntimeException> unhandledException)
 {
     if (input is ActivationMessage)
         _continueWith = continueWith;
     else
         _translator.Process_local_output(input);
 }

 ///<summary>
 /// Creates a TS.
 /// <param name="message">The Message to which this Type belongs</param>
 /// <param name="description">The description of this type</param>
 ///</summary>
 public TS(IMessage message, string description)
     : base(message, description)
 {
     data = new IType[2];
     data[0] = new TSComponentOne(message,"Time of an event");
     data[1] = new ST(message,"Degree of precision");
 }

        // NMS Message                       AMQP Message
        // ================================  =================
        // string          NMSCorrelationID  string     CorrelationId
        // MsgDeliveryMode NMSDeliveryMode   bool       Durable
        // IDestination    NMSDestination
        // string          MNSMessageId      string     MessageId
        // MsgPriority     NMSPriority       byte       Priority
        // bool            NMSRedelivered    bool       Redelivered
        // IDestination    NMSReplyTo        Address    ReplyTo
        // DateTime        NMSTimestamp
        // TimeSpan        NMSTimeToLive     Duration   Ttl
        // string          NMSType           string     ContentType
        // IPrimitiveMap   Properties        Dictionary Properties
        //                                   string     Subject
        //                                   string     UserId
        //
        public virtual Message ToAmqpMessage(IMessage message)
        {
            Message amqpMessage = CreateAmqpMessage(message);

            if (null != message.NMSCorrelationID)
            {
                amqpMessage.CorrelationId = message.NMSCorrelationID;
            }
            amqpMessage.Durable = (message.NMSDeliveryMode == MsgDeliveryMode.Persistent);
            if (null != message.NMSMessageId)
            {
                amqpMessage.MessageId = message.NMSMessageId;
            }
            amqpMessage.Priority = ToAmqpMessagePriority(message.NMSPriority);
            amqpMessage.Redelivered = message.NMSRedelivered;
            if (null != message.NMSReplyTo)
            {
                amqpMessage.ReplyTo = ToAmqpAddress(message.NMSReplyTo);
            }

            if (message.NMSTimeToLive != TimeSpan.Zero)
            {
                amqpMessage.Ttl = ToQpidDuration(message.NMSTimeToLive);
            }

            if (null != message.NMSType)
            {
                amqpMessage.ContentType = message.NMSType;
            }

            amqpMessage.Properties = FromNmsPrimitiveMap(message.Properties);

            // TODO: NMSDestination, Amqp.Subect, Amqp.UserId
            return amqpMessage;
        }

        public override IMessage Invoke(IMessage msg)
        {
            var mcm = msg as IMethodCallMessage;
            if (mcm == null)
                return null;

            if (IsEqualsCall(mcm))
                return ReturnValue(HandleEquals(mcm), mcm);

            if (IsGetHashCodeCall(mcm))
                return ReturnValue(GetHashCode(), mcm);

            if (IsGetTypeCall(mcm))
                return ReturnValue(GetProxiedType(), mcm);

            if (IsToStringCall(mcm))
            {
                var type = GetProxiedType();
                var hashCode = GetHashCode();
                var value = string.Format("RemotingMock_{0}<{1}>", hashCode, type.Name);

                return ReturnValue(value, mcm);
            }

            var invocation = new RemotingInvocation(this, mcm);
            interceptor.Intercept(invocation);

            return ReturnValue(invocation.ReturnValue, invocation.Arguments, mcm);
        }

 protected override void HandleRequestMessage(IMessage message, ReplyMessageHolder replyHolder)
 {
     object result = SplitMessage(message);
     if(result == null) {
         return;
     }
     object correlationId = message.Headers.Id;
     if(result is ICollection) {
         ICollection items = (ICollection)result;
         int sequenceNumber = 0;
         int sequenceCount = items.Count;
         foreach(object item in items) {
             AddReply(replyHolder, item, correlationId, ++sequenceNumber, sequenceCount);
         }
     }
     else if(result.GetType().IsArray) {
         object[] items = (object[])result;
         int sequenceNumber = 0;
         int sequenceSize = items.Length;
         foreach(object item in items) {
             AddReply(replyHolder, item, correlationId, ++sequenceNumber, sequenceSize);
         }
     }
     else {
         AddReply(replyHolder, result, correlationId, 1, 1);
     }
 }

	///<summary>
	/// Creates a PTA.
	/// <param name="message">The Message to which this Type belongs</param>
	/// <param name="description">The description of this type</param>
	///</summary>
	public PTA(IMessage message, string description) : base(message, description){
		data = new IType[4];
		data[0] = new IS(message, 147,"Policy Type");
		data[1] = new IS(message, 193,"Amount Class");
		data[2] = new NM(message,"Money or Percentage Quantity");
		data[3] = new MOP(message,"Money or Percentage");
	}

		public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
						 object state,
						 IMessage msg,
						 ITransportHeaders headers)
		{
			return null;
		}

		public Stream GetRequestStream(IMessage requestMsg, ITransportHeaders requestHeaders)
		{
			// parameters validation
			if (requestHeaders == null)
				throw new ArgumentNullException("requestHeaders");

			IMethodCallMessage methodCall = requestMsg as IMethodCallMessage;
			if (methodCall == null)
				throw new NotSupportedException();

			if (_connection != null)
			{
				// close connection as it is probably not valid
				_connection.Close();
			}

			// get connection from the cache
			_connection = _connectionCache.GetConnection(_channelUri);

			try
			{
				// return stream for writing request
				return _connection.GetRequestStream(methodCall, requestHeaders);
			}
			catch
			{
				// close connection as it is probably not valid
				_connection.Close();
				_connection = null;
				throw;
			}
		}

 public static ErrorReply For(IMessage message)
 {
     return new ErrorReply
     {
         ReplyFor = message.Id
     };
 }

        void IMutateOutgoingTransportMessages.MutateOutgoing(IMessage[] messages, TransportMessage transportMessage)
        {
            if (transportMessage.Headers.ContainsKey(WindowsIdentityName))
                transportMessage.Headers.Remove(WindowsIdentityName);

            transportMessage.Headers.Add(WindowsIdentityName, Thread.CurrentPrincipal.Identity.Name);
        }

 public void DispatchReplyMessage(IMessage msg)
 {
     if (this._replySink != null)
     {
         this._replySink.SyncProcessMessage(msg);
     }
 }

 public Stream GetResponseStream (IServerResponseChannelSinkStack sinkStack,
                                  object state,
                                  IMessage msg,
                                  ITransportHeaders headers)
 {
   throw new NotImplementedException();
 }

        public Result Post(IMessage message)
        {
            try
            {
                var request = WebRequest.Create(message.Url) as HttpWebRequest;
                request.Method = "POST";

                foreach (string key in message.Headers.Keys)
                {
                    var value = message.Headers[key];

                    if (key == "content-type")
                    {
                        request.ContentType = value;
                        continue;
                    }

                    request.Headers.Add(key, value);
                }

                request.Headers.Add("submitted", this.TimeProvider.GetEpochInMilliSeconds(DateTimeKind.Utc).ToString(CultureInfo.InvariantCulture));

                return this.RequestAndRespond(request, message.Body);
            }
            catch (Exception)
            {
                return Result.PermanentError;
            }
        }

 public UiMessage(IMessage message, Contact contact)
 {
     Address = message.Address;
     Text = message.Text;
     TimeStamp = message.TimeStamp;
     Contact = contact;
 }

	///<summary>
	/// Creates a QSC.
	/// <param name="message">The Message to which this Type belongs</param>
	/// <param name="description">The description of this type</param>
	///</summary>
	public QSC(IMessage message, string description) : base(message, description){
		data = new IType[4];
		data[0] = new ST(message,"Name of field");
		data[1] = new ID(message, 0,"Relational operator");
		data[2] = new ST(message,"Value");
		data[3] = new ID(message, 0,"Relational conjunction");
	}

 ///<summary>
 /// Creates a VR.
 /// <param name="message">The Message to which this Type belongs</param>
 /// <param name="description">The description of this type</param>
 ///</summary>
 public VR(IMessage message, string description)
     : base(message, description)
 {
     data = new IType[2];
     data[0] = new ST(message,"First Data Code Value");
     data[1] = new ST(message,"Last Data Code Value");
 }

        /// <summary>Indicates whether the current object is equal to another object of the same type.</summary>
        /// <param name="other">An object to compare with this object.</param>
        /// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns>
        public bool Equals(IMessage other)
        {
            bool result = other.DateTime == DateTime && other.From == From && other.To == To
                && other.MessageText == MessageText;

            return result;
        }

 public void Broadcast(IMessage message)
 {
     if (IsEnabled)
     {
         ThreadPool.QueueUserWorkItem(SendTweet, message.GetMessage(140));
     }
 }

	///<summary>
	/// Creates a SN.
	/// <param name="message">The Message to which this Type belongs</param>
	/// <param name="description">The description of this type</param>
	///</summary>
	public SN(IMessage message, string description) : base(message, description){
		data = new IType[4];
		data[0] = new ST(message,"Comparator");
		data[1] = new NM(message,"Num1");
		data[2] = new ST(message,"Separator or suffix");
		data[3] = new NM(message,"Num2");
	}

        public void Process(IMessage message)
        {
            if (IsFlowInputMessage(message))
            {
                // parent/flow.port => flow/.port
                var output = new Message(Port.Build(message.Port.OperationName, "", message.Port.Name), message.Data, message.CorrelationId)
                {
                    Causalities = message.Causalities,
                    FlowStack = message.FlowStack
                };

                if (message.Port.Path != "") output.FlowStack.Push(message.Port.Path);

                Result(output);
            }
            else
            {
                // flow/.port => parent/flow.port
                var parentFlowname = "";
                if (!message.FlowStack.IsEmpty) parentFlowname = message.FlowStack.Pop();

                var output = new Message(Port.Build(parentFlowname, Create_operation_name(message), message.Port.Name), message.Data, message.CorrelationId)
                {
                    Causalities = message.Causalities,
                    FlowStack = message.FlowStack
                };

                Result(output);
            }
        }