/// <summary>
        /// Constructs a ProtocolReporter
        /// </summary>
        /// <param name="protocol">Protocol to attach to</param>
        public ProtocolReporter(Protocol protocol)
        {
            this.protocol = protocol;
            this.debug = new Debug(protocol.Name);

            this.protocol.AddListener(this);
        }

 public override bool ContainsLayer(Protocol layer)
 {
     if (layer == Protocol.UDP)
         return true;
     else
         return base.ContainsLayer(layer);
 }

        public void Test_CanApprove()
        {
            Procedure procedure = new Procedure();
            Protocol protocol = new Protocol(procedure);
            ProtocolAssignmentStep procedureStep = new ProtocolAssignmentStep(protocol);

            Assert.AreEqual(ProtocolStatus.PN, procedureStep.Protocol.Status);
            Assert.IsFalse(procedureStep.CanApprove);

            protocol.SubmitForApproval();

            Assert.AreEqual(ActivityStatus.SC, procedureStep.State);
            Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
            Assert.IsTrue(procedureStep.CanApprove);

            procedureStep.Start(new Staff());

            Assert.AreEqual(ActivityStatus.IP, procedureStep.State);
            Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
            Assert.IsTrue(procedureStep.CanApprove);

            procedureStep.Suspend();

            Assert.AreEqual(ActivityStatus.SU, procedureStep.State);
            Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
            Assert.IsFalse(procedureStep.CanApprove);

            procedureStep.Complete();

            Assert.AreEqual(ActivityStatus.CM, procedureStep.State);
            Assert.AreEqual(ProtocolStatus.AA, procedureStep.Protocol.Status);
            Assert.IsFalse(procedureStep.CanApprove);

            // TODO : test all other Protocol state conditions
        }

 public static void createProtocol(TreeView tree)
 {
     TreeNodeCollection treeCol = tree.Nodes;
     Protocol prot = new Protocol(treeCol[0].Text, treeCol[0].ImageKey, treeCol[0].SelectedImageKey);
     Block data = null;
     foreach (TreeNode t in treeCol[0].Nodes)
     {
         if (t.Name.Equals("block"))
         {
             data = prot.createBlock(t.Text, t.ImageKey, t.SelectedImageKey);
             createProtocol(t.Nodes, data);
         }
         else
         {
             if(t.Name.Equals("multi"))
             {
             Field f = prot.createField(t.Text, t.Name,  "", t.SelectedImageKey);
             string[] values = t.ImageKey.Split(';');
             foreach(string s in values)
                 {
                     string[] pair = s.Split(':');
                     ((MultiField)f).addKey(pair[0], pair[1]);
                 }
            } else prot.createField(t.Text, t.Name, t.ImageKey, t.SelectedImageKey);
         }
     }
     createXML(prot);
 }

 public void Send(int msgno, MemoryStream stream)
 {
     Protocol protocol = new Protocol();
     protocol.msgno = msgno;
     protocol.stream = stream;
     mSendBuffer.PushBack(protocol);
 }

 public MessageSegment(IChannel connection, Protocol protocol, EndPoint ep, byte[] data)
 {
     Protocol = protocol;
     EndPoint = ep;
     Data = data;
     Connection = connection;
 }

        public void Test_IsPreStep()
        {
            Protocol protocol = new Protocol();
            ConcreteProtocolProcedureStep procedureStep = new ConcreteProtocolProcedureStep(protocol);

            Assert.IsTrue(procedureStep.IsPreStep);
        }

        public override void Update(Protocol.Types.Shortcut shortcut)
        {
            base.Update(shortcut);

            if (shortcut is ShortcutEmote)
                Emote = ObjectDataManager.Instance.Get<Emoticon>((shortcut as ShortcutEmote).emoteId);
        }

		public void Process(string s)
		{
			// split protocol, separator and actual value
			int separatorIndex = s.IndexOf(SEPARATOR);

			if (separatorIndex != -1)
			{
				switch(s.Substring(0, separatorIndex))
				{
					case XML_RPC:
						m_type = Protocol.XmlRpc;
						break;
					case SOAP:
						m_type = Protocol.Soap;
						break;
					case REST:
						m_type = Protocol.Rest;
						break;
                    case UIML:
                        // uiml:// style location
                        m_type = Protocol.Local;
                        m_value = Uiml.Utils.Location.Transform(s);
                        break;
				}

                if (m_value == string.Empty) // only if not already assigned
				    m_value = s.Substring(separatorIndex + SEPARATOR.Length);
			}
			else
			{
				// no separator, thus it's local
				m_type = Protocol.Local;
				m_value = s; // value is the complete string
			}
		}

        public static void OpenDocument(Protocol p, string url)
        {
            string cmd = "";

            url = url.Trim().ToLower();

            if ( url.Length > 0 ) {
                if ( p == Protocol.Email ) {
                    cmd += EmailProtocolPrefix;
                }
                else
                if ( p == Protocol.Http ) {
                    if ( !url.StartsWith( HttpProtocolPrefix ) ) {
                        cmd += HttpProtocolPrefix;
                    }
                }

                cmd += url;
                System.Diagnostics.Process.Start( cmd );
            } else {
                throw new ApplicationException( "Empty url" );
            }

            return;
        }

        public MessageOut(Protocol id)
        {
            data=new MemoryStream();
            writer=new BinaryWriter(data);

            writer.Write((UInt16)id);
        }

 private static ScanNetworkResult ScanEndpoint(CancellationToken userToken, DnsResolverBase resolver, Protocol protocol, IPEndpoint endpoint)
 {
     var status = Ping.PerformPing(endpoint, protocol);
     var hostName = status ? GetHostName(resolver, endpoint) : null;
     var result = new ScanNetworkResult(protocol, endpoint, hostName, status);
     return result;
 }

 public void RemoveRequest(Protocol.Request request)
 {
     lock(_requests)
     {
         _requests.Remove(request.Id);
     }
 }

 public void AddRequest(Protocol.Request request)
 {
     lock(_requests)
     {
         _requests.Add(request.Id, request);
     }
 }

 public void AddMessage(Protocol.IMessage message, Interfaces.IUserAgent user)
 {
     lock (this)
     {
         mQueue.Enqueue(new MessageToken { Message = message, UserAgent = user });
     }
 }

        /// <summary>
        /// Construct an StreamContent from a provided populated OFX object
        /// </summary>
        /// <param name="ofxObject">A populated OFX message with request or response data</param>
        /// <returns>Created StreamContent ready to send with HttpClient.Post</returns>
        public static StreamContent Create(Protocol.OFX ofxObject)
        {
            // Serialized data will be written to a MemoryStream
            var memoryStream = new System.IO.MemoryStream();

            // XMLWriter will be used to encode the data using UTF8Encoding without a Byte Order Marker (BOM)
            var xmlWriter = new System.Xml.XmlTextWriter(memoryStream, new System.Text.UTF8Encoding(false));

            // Write xml processing instruction
            xmlWriter.WriteStartDocument();
            // Our OFX protocol uses a version 2.0.0 header with 2.1.1 protocol body
            xmlWriter.WriteProcessingInstruction("OFX", "OFXHEADER=\"200\" VERSION=\"211\" SECURITY=\"NONE\" OLDFILEUID=\"NONE\" NEWFILEUID=\"NONE\"");

            // Don't include namespaces in the root element
            XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
            ns.Add("", "");

            // Generate XML to the stream
            m_serializer.Serialize(xmlWriter, ofxObject, ns);

            // Flush writer to stream
            xmlWriter.Flush();

            // Position the stream back to the start for reading
            memoryStream.Position = 0;

            // Wrap in our HttpContent-derived class to provide headers and other HTTP encoding information
            return new StreamContent(memoryStream);
        }

 /// <summary>
 /// Constructs a FriendTreeNode
 /// </summary>
 /// <param name="protocol">Associated protocol</param>
 /// <param name="friend">Associated friend</param>
 public FriendTreeNode(Protocol protocol, Friend friend)
 {
     this.protocol = protocol;
     this.friend = friend;
     this.Tag = friend;
     this.Text = friend.DisplayName;
 }

 public CharacterInfomation(int myID, string myName, int myTextureID, Protocol.Type myType)
 {
     setID(myID);
     setName(myName);
     setTextureID(myTextureID);
     setType(myType);
 }

 public LoadBalancerProbe(Protocol protocol, string path, int? port)
 {
     //TODO: Validate params
     this.Protocol = protocol;
     this.Path = path;
     this.Port = port;
 }

 public void Read (TProtocol iprot)
 {
   TField field;
   iprot.ReadStructBegin();
   while (true)
   {
     field = iprot.ReadFieldBegin();
     if (field.Type == TType.Stop) { 
       break;
     }
     switch (field.ID)
     {
       case 1:
         if (field.Type == TType.I32) {
           Pid = (Protocol)iprot.ReadI32();
         } else { 
           TProtocolUtil.Skip(iprot, field.Type);
         }
         break;
       default: 
         TProtocolUtil.Skip(iprot, field.Type);
         break;
     }
     iprot.ReadFieldEnd();
   }
   iprot.ReadStructEnd();
 }