internal ExtensionCacheValue(object[] value, Type type, MatchType matchType)
 {
     _value = value;
     _type = type;
     _matchType = matchType;
     _filterOnly = true;
 }

 public LiveMatch()
 {
     matchType = MatchType.General;
     InitializeComponent();
     HelpComboDisplay(cmbTeamA);
     HelpComboDisplay(cmbTeamB);
 }

		internal ExtensionCacheValue(object[] value, Type type, MatchType matchType)
		{
			[email protected] = value;
			this.type = type;
			this.matchType = matchType;
			this.filterOnly = true;
		}

 public MessageReceiverRegistration(DeviceAddress source, DeviceAddress destination, MessageReceiver callback, MatchType match)
 {
     Source = source;
     Destination = destination;
     Callback = callback;
     Match = match;
 }

 public SearchResult(MovieId id, string title, int year, MediaType type, MatchType match)
 {
     this.id = id;
     this.title = title;
     this.year = year;
     this.type = type;
     this.match = match;
 }

 public ReturnStruct(int start, int end, MatchType type)
     : this()
 {
     if (start < 0 || end < start)
         throw new ArgumentException("Invalid index parameters");
     Start = start;
     End = end;
     Type = type;
 }

 private static object GetValue(MatchType key, string value)
 {
     switch (key)
     {
         case MatchType.Number:
             return Double.Parse(value);
         default:
             return value;
     }
 }

 public CheckBufferState(byte[] buffer, DiskFile diskFile, string fileName, int blockSize, Dictionary<uint, FileVerificationEntry> hashFull, MatchType matchType, int offset, int overlap)
 {
     this.buffer = buffer;
     this.diskFile = diskFile;
     this.fileName = fileName;
     this.blockSize = blockSize;
     this.hashFull = hashFull;
     this.matchType = matchType;
     this.offset = offset;
     this.overlap = overlap;
 }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName, string roles, MatchType RoleMatchType, object route)
        {
            bool valid = UserFunctions.IsUserInRole(roles, RoleMatchType);

            var link = new MvcHtmlString(string.Empty);
            if (valid)
            {
                link = htmlHelper.ActionLink(linkText, actionName, controllerName, route,null);
            }
            return link;
        }

		public void BadLogonCount(int badLogonCount, MatchType match)
		{
			if (this.badLogonCountVal != null)
			{
				this.badLogonCountVal.Match = match;
				this.badLogonCountVal.Value = badLogonCount;
			}
			else
			{
				this.badLogonCountVal = new QbeMatchType((object)badLogonCount, match);
			}
			this.badLogonCountChanged = true;
		}

		public void AccountLockoutTime(DateTime lockoutTime, MatchType match)
		{
			if (this.lockoutTimeVal != null)
			{
				this.lockoutTimeVal.Match = match;
				this.lockoutTimeVal.Value = lockoutTime;
			}
			else
			{
				this.lockoutTimeVal = new QbeMatchType((object)lockoutTime, match);
			}
			this.lockoutTimeChanged = true;
		}

		public void AccountExpirationDate(DateTime expirationTime, MatchType match)
		{
			if (this.expirationTimeVal != null)
			{
				this.expirationTimeVal.Match = match;
				this.expirationTimeVal.Value = expirationTime;
			}
			else
			{
				this.expirationTimeVal = new QbeMatchType((object)expirationTime, match);
			}
			this.expirationTimeChanged = true;
		}

 private void AssertFailureHandling(TestRunFailureSpecialHandling specialHandling, 
     string expectedMessage, 
     MatchType expectedMessageType, 
     string expectedStackTrace,
     MatchType expectedStackTraceType,
     int expectedretryCount)
 {
     Assert.That(specialHandling.FailureMessage, Is.EqualTo(expectedMessage));
     Assert.That(specialHandling.FailureStackTrace, Is.EqualTo(expectedStackTrace));
     Assert.That(specialHandling.FailureMessageType, Is.EqualTo(expectedMessageType));
     Assert.That(specialHandling.FailureStackTraceType, Is.EqualTo(expectedStackTraceType));
     Assert.That(specialHandling.RetryCount, Is.EqualTo(expectedretryCount));
 }

        public static int[] FindNewsArticlesContaining(NewsItem[] newsItems, string[] terms, MatchType searchOperator)
        {
            List<int> foundItemsIndexes = new List<int>();

            for(int i = 0; i < newsItems.Length; i++)
            {
                if (newsItems[i].Search(terms, searchOperator))
                {
                    foundItemsIndexes.Add(i);
                }
            }

            return foundItemsIndexes.ToArray();
        }

        public bool Search(string[] terms, MatchType matchType)
        {
            int count = 0;

            foreach (string term in terms)
            {
                if (this.rawItem.Contains(term))
                {
                    count++;
                }
            }

            if (matchType.Equals(MatchType.And) && count.Equals(terms.Length)) return true;
            if (matchType.Equals(MatchType.Or) && ((count > 0) && (count <= terms.Length))) return true;
            return false;
        }

 public Match(string seed, IEnumerable<string> accountIds, int lobby, MatchType matchType, LogOnService logOnService)
 {
     _lobby = lobby;
       _matchType = matchType;
       _logOnService = logOnService;
       _shuffler = new WallGenerator(seed);
       _firstOyaIndex = _shuffler.GetWall(0).First().Id % 4;
       var playerIndex = 0;
       foreach (var player in accountIds)
       {
     _players.Add(player, new PlayerStatus(playerIndex));
     playerIndex += 1;
       }
       _stateMachine = new StateMachine(new PlayersConnectingState(this));
       _stateMachine.Finished += OnFinished;
 }

        protected bool Compare(MatchType matchType, string matchString, string name)
        {
            switch (matchType)
            {
                case MatchType.Any: return true;
                case MatchType.Contains: return name.Contains(matchString);
                case MatchType.StartsWith: return name.Contains(matchString);
                case MatchType.Exact: return String.Compare(name, matchString) == 0;
                case MatchType.Except: return String.Compare(name, matchString) != 0;
                case MatchType.NotContains: return !name.Contains(matchString);
                case MatchType.NotStartsWith: return !name.Contains(matchString);

                case MatchType.Exclude: return !matchString.Contains(name);

                default: return false;
            }
        }

 public void EnterQueue(string accountId, int lobby, MatchType matchType)
 {
     var nextFour = new List<string>();
       lock (_queue)
       {
     _queue.Add(accountId);
     if (_queue.Count == 4)
     {
       nextFour.AddRange(_queue);
       _queue.Clear();
     }
       }
       if (nextFour.Count == 4)
       {
     CreateNewMatch(nextFour, lobby, matchType);
       }
 }

            public FilteredAssert(string messageOrRegex, int bugNumber, MatchType matchType, HandlingOption assertHandlingOption, params string[] stackFrames)
            {
                if (matchType == MatchType.Exact)
                {
                    Message = messageOrRegex;
                    MessageRegex = null;
                }
                else
                {
                    Message = null;
                    MessageRegex = new Regex(messageOrRegex, AssertMessageRegexOptions);
                }


                StackFrames = stackFrames;
                BugNumber = bugNumber;
                Handler = assertHandlingOption;
            }

 public void AccountExpirationDate(DateTime expirationTime, MatchType match)
 {
     if (expirationTime == null)
     {
         _expirationTimeChanged = false;
         _expirationTimeVal = null;
     }
     else
     {
         if (null == _expirationTimeVal)
             _expirationTimeVal = new QbeMatchType(expirationTime, match);
         else
         {
             _expirationTimeVal.Match = match;
             _expirationTimeVal.Value = expirationTime;
         }
         _expirationTimeChanged = true;
     }
 }