We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Channels \ BaseTransportHeadersEnumerator

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //==========================================================================
  16. // File: BaseTransportHeaders.cs
  17. //
  18. // Summary: Base class for special-cased transport headers implementations.
  19. //
  20. //==========================================================================
  23. using System;
  24. using System.Collections;
  25. using System.Globalization;
  26. using System.Net;
  29. namespace System.Runtime.Remoting.Channels
  30. {
  31.    
  32.     [Serializable()]
  33.     internal class BaseTransportHeaders : ITransportHeaders
  34.     {
  35.         // IMPORTANT: If a new wellknown header is added, MapHeaderNameToIndex,
  36.         // GetValueFromHeaderIndex, and SetValueFromHeaderIndex methods must
  37.         // be updated (as well as WellknownHeaderCount)!!!
  38.        
  39.         internal const int WellknownHeaderCount = 4;
  40.        
  41.         private object _connectionId;
  42.         // 0) CommonTransportKeys.ConnectionId
  43.         private object _ipAddress;
  44.         // 1) CommonTransportKeys.IPAddress
  45.         private string _requestUri;
  46.         // 2) CommonTransportKeys.RequestUri
  47.         private string _contentType;
  48.         // 3) "Content-Type"
  49.        
  50.         // transport headers structure is for non well-known headers
  51.         private ITransportHeaders _otherHeaders;
  52.        
  53.        
  54.         public BaseTransportHeaders()
  55.         {
  56.             _otherHeaders = null;
  57.         }
  58.        
  59.        
  60.         public string RequestUri {
  61.             get { return _requestUri; }
  62.             set { _requestUri = value; }
  63.         }
  64.         // RequestUri
  65.        
  66.         public string ContentType {
  67.             get { return _contentType; }
  68.             set { _contentType = value; }
  69.         }
  70.         // ContentType
  71.        
  72.         public object ConnectionId {
  73.             set { _connectionId = value; }
  74.         }
  75.        
  76.         public IPAddress IPAddress {
  77.             set { _ipAddress = value; }
  78.         }
  79.        
  80.        
  81.         //
  82.         // ITransportHeaders implementation
  83.         //
  84.        
  85.         public object this[object key]
  86.         {
  87.             get {
  88.                 string strKey = key as string;
  89.                 if (strKey != null) {
  90.                     int index = MapHeaderNameToIndex(strKey);
  91.                     if (index != -1)
  92.                         return GetValueFromHeaderIndex(index);
  93.                 }
  94.                
  95.                 if (_otherHeaders != null)
  96.                     return _otherHeaders[key];
  97.                
  98.                 return null;
  99.             }
  100.             // get
  101.             set {
  102.                 bool bSet = false;
  103.                
  104.                 string strKey = key as string;
  105.                 if (strKey != null) {
  106.                     int index = MapHeaderNameToIndex(strKey);
  107.                     if (index != -1) {
  108.                         SetValueFromHeaderIndex(index, value);
  109.                         bSet = true;
  110.                     }
  111.                 }
  112.                
  113.                 if (!bSet) {
  114.                     if (_otherHeaders == null)
  115.                         _otherHeaders = new TransportHeaders();
  116.                     _otherHeaders[key] = value;
  117.                 }
  118.             }
  119.         }
  120.         // set
  121.         // Object this[Object key]
  122.        
  123.         public IEnumerator GetEnumerator()
  124.         {
  125.             return new BaseTransportHeadersEnumerator(this);
  126.         }
  127.         // GetEnumerator
  128.        
  129.         internal IEnumerator GetOtherHeadersEnumerator()
  130.         {
  131.             if (_otherHeaders == null)
  132.                 return null;
  133.            
  134.             return _otherHeaders.GetEnumerator();
  135.         }
  136.         // GetOtherHeadersEnumerator
  137.        
  138.        
  139.         internal int MapHeaderNameToIndex(string headerName)
  140.         {
  141.             // 0) CommonTransportKeys.ConnectionId
  142.             // 1) CommonTransportKeys.IPAddress
  143.             // 2) CommonTransportKeys.RequestUri
  144.             // 3) "Content-Type"
  145.            
  146.             if (String.Compare(headerName, CommonTransportKeys.ConnectionId, StringComparison.OrdinalIgnoreCase) == 0)
  147.                 return 0;
  148.             else if (String.Compare(headerName, CommonTransportKeys.IPAddress, StringComparison.OrdinalIgnoreCase) == 0)
  149.                 return 1;
  150.             else if (String.Compare(headerName, CommonTransportKeys.RequestUri, StringComparison.OrdinalIgnoreCase) == 0)
  151.                 return 2;
  152.             else if (String.Compare(headerName, "Content-Type", StringComparison.OrdinalIgnoreCase) == 0)
  153.                 return 3;
  154.            
  155.             return -1;
  156.         }
  157.         // MapHeaderNameToIndex
  158.        
  159.         internal string MapHeaderIndexToName(int index)
  160.         {
  161.             // 0) CommonTransportKeys.ConnectionId
  162.             // 1) CommonTransportKeys.IPAddress
  163.             // 2) CommonTransportKeys.RequestUri
  164.             // 3) "Content-Type"
  165.            
  166.             switch (index) {
  167.                 case 0:
  168.                     return CommonTransportKeys.ConnectionId;
  169.                 case 1:
  170.                     return CommonTransportKeys.IPAddress;
  171.                 case 2:
  172.                     return CommonTransportKeys.RequestUri;
  173.                 case 3:
  174.                     return "Content-Type";
  175.                 default:
  176.                    
  177.                     return null;
  178.             }
  179.            
  180.         }
  181.         // MapHeaderNameToIndex
  182.        
  183.         internal object GetValueFromHeaderIndex(int index)
  184.         {
  185.             // NOTE: If this method returns the null, then that indicates the header has no
  186.             // value (i.e. isn't in the "dictionary"). For the purposes of iteration, this
  187.             // means that the header should be skipped.
  188.            
  189.             // 0) CommonTransportKeys.ConnectionId
  190.             // 1) CommonTransportKeys.IPAddress
  191.             // 2) CommonTransportKeys.RequestUri
  192.             // 3) "Content-Type"
  193.            
  194.             switch (index) {
  195.                 case 0:
  196.                     return _connectionId;
  197.                 case 1:
  198.                     return _ipAddress;
  199.                 case 2:
  200.                     return _requestUri;
  201.                 case 3:
  202.                     return _contentType;
  203.                 default:
  204.                    
  205.                     return null;
  206.             }
  207.            
  208.         }
  209.         // MapHeaderIndexToValue
  210.        
  211.         internal void SetValueFromHeaderIndex(int index, object value)
  212.         {
  213.             // NOTE: If this method returns the null, then that indicates the header has no
  214.             // value (i.e. isn't in the "dictionary"). For the purposes of iteration, this
  215.             // means that the header should be skipped.
  216.            
  217.             // 0) CommonTransportKeys.ConnectionId
  218.             // 1) CommonTransportKeys.IPAddress
  219.             // 2) CommonTransportKeys.RequestUri
  220.             // 3) "Content-Type"
  221.            
  222.             switch (index) {
  223.                 case 0:
  224.                     _connectionId = value;
  225.                     break;
  226.                 case 1:
  227.                     _ipAddress = value;
  228.                     break;
  229.                 case 2:
  230.                     _requestUri = (string)value;
  231.                     break;
  232.                 case 3:
  233.                     _contentType = (string)value;
  234.                     break;
  235.                 default:
  236.                    
  237.                    
  238.                     {
  239.                         InternalRemotingServices.RemotingAssert(false, "someone forgot to update this method");
  240.                         break;
  241.                     }
  243.                     break;
  244.                
  245.             }
  246.             // switch (index)
  247.         }
  248.         // MapHeaderIndexToValue
  249.        
  250.        
  251.     }
  252.     // class BaseTransportHeaders
  253.    
  254.    
  255.     internal class BaseTransportHeadersEnumerator : IEnumerator
  256.     {
  257.         private BaseTransportHeaders _headers;
  258.         private bool _bStarted;
  259.         private int _currentIndex;
  260.         private IEnumerator _otherHeadersEnumerator;
  261.        
  262.         public BaseTransportHeadersEnumerator(BaseTransportHeaders headers)
  263.         {
  264.             _headers = headers;
  265.             Reset();
  266.         }
  267.         // BaseTransportHeadersEnumerator
  268.        
  269.         public bool MoveNext()
  270.         {
  271.             if (_currentIndex != -1) {
  272.                 if (_bStarted)
  273.                     _currentIndex++;
  274.                 else
  275.                     _bStarted = true;
  276.                
  277.                 while (_currentIndex != -1) {
  278.                     if (_currentIndex >= BaseTransportHeaders.WellknownHeaderCount) {
  279.                         _otherHeadersEnumerator = _headers.GetOtherHeadersEnumerator();
  280.                         _currentIndex = -1;
  281.                     }
  282.                     else {
  283.                         if (_headers.GetValueFromHeaderIndex(_currentIndex) != null)
  284.                             return true;
  285.                        
  286.                         _currentIndex++;
  287.                     }
  288.                 }
  289.             }
  290.            
  291.             if (_otherHeadersEnumerator != null) {
  292.                 if (!_otherHeadersEnumerator.MoveNext()) {
  293.                     _otherHeadersEnumerator = null;
  294.                     return false;
  295.                 }
  296.                 else
  297.                     return true;
  298.             }
  299.            
  300.             return false;
  301.         }
  302.         // MoveNext
  303.         public void Reset()
  304.         {
  305.             _bStarted = false;
  306.             _currentIndex = 0;
  307.             _otherHeadersEnumerator = null;
  308.         }
  309.         // Reset
  310.         public object Current {
  311.             get {
  312.                 if (!_bStarted)
  313.                     return null;
  314.                
  315.                 if (_currentIndex != -1) {
  316.                     return new DictionaryEntry(_headers.MapHeaderIndexToName(_currentIndex), _headers.GetValueFromHeaderIndex(_currentIndex));
  317.                 }
  318.                
  319.                 if (_otherHeadersEnumerator != null) {
  320.                     return _otherHeadersEnumerator.Current;
  321.                 }
  322.                
  323.                 return null;
  324.             }
  325.         }
  326.         // Current
  327.     }
  328.     // class BaseTransportHeadersEnumerator
  329.    
  330.    
  331.    
  332. }
  333. // namespace System.Runtime.Remoting.Channels

Developer Fusion