public void WithSingleValueInCollection()
        {
            var source = new[] {42}.GetEnumerator().WithHasCurrent();

            Assert.IsTrue(source.MoveNext());
            Assert.IsTrue(source.HasCurrent);
            Assert.AreEqual(42, source.Current);

            Assert.IsFalse(source.MoveNext());
            Assert.IsFalse(source.HasCurrent);
        }
        public List(System.Collections.IEnumerator nodes)
        {
            Items = new List<ListItem>();

            while (nodes.MoveNext())
            {
                Items.Add(new ListItem(nodes.Current as XElement));
            }
        }
        public void WithMultipleValuesInCollection()
        {
            var source = new[] {12, 42, 2001}.GetEnumerator().WithHasCurrent();

            Assert.IsTrue(source.MoveNext());
            Assert.IsTrue(source.HasCurrent);
            Assert.AreEqual(12, source.Current);

            Assert.IsTrue(source.MoveNext());
            Assert.IsTrue(source.HasCurrent);
            Assert.AreEqual(42, source.Current);

            Assert.IsTrue(source.MoveNext());
            Assert.IsTrue(source.HasCurrent);
            Assert.AreEqual(2001, source.Current);

            Assert.IsFalse(source.MoveNext());
            Assert.IsFalse(source.HasCurrent);
        }
Example #4
0
 protected virtual bool InitializeProperties(System.Collections.IEnumerator enumerator, bool preInit = false)
 {
     bool result = true;
       while (enumerator.MoveNext() && result)
       {
     PropertyInfo current = enumerator.Current as PropertyInfo;
     ConfigureAttribute configAttribute = (current.GetCustomAttribute(typeof(ConfigureAttribute)) as ConfigureAttribute);
     if (preInit && (configAttribute != null) && configAttribute.PreInit)
       result = InitializeProperty(enumerator.Current as PropertyInfo);
     else if (((!preInit) && (configAttribute == null)) || ((configAttribute!=null) && (!configAttribute.PreInit)))
       result = InitializeProperty(enumerator.Current as PropertyInfo);
       }
       return result;
 }
Example #5
0
    public void InitCharSelect()
    {
        background.SetActive(true);
        var charTypes = new[]
        {
            CharTypeEnum.Killer,
            CharTypeEnum.Theif,
            CharTypeEnum.Religious,
            CharTypeEnum.King,
            CharTypeEnum.Merchant,
            CharTypeEnum.Wizard,
            CharTypeEnum.Builder,
            CharTypeEnum.Warrior,
        }.GetEnumerator();
        charTypes.MoveNext();

        var nextCharPosX = gameObject.transform.position.x - (GetComponent<Renderer>().bounds.size.x / 4);
        foreach (var character in this.charactersToSpawn)
        {
            var charPos = gameObject.transform.position;
            charPos.x += nextCharPosX;
            nextCharPosX += 1.7f;
            var characterObj = Instantiate(
                        character,
                        charPos,
                        gameObject.transform.rotation) as GameObject;

            var charScript = characterObj.GetComponent(typeof(CharacterScript)) as CharacterScript;
            charScript.isSelected = false;
            charScript.isPlayed = false;

            charScript.SetCharType((CharTypeEnum)charTypes.Current);
            charTypes.MoveNext();

            this.charsObjs.Add(characterObj);
        }
    }
Example #6
0
 public void WaitUntilReturnsTheResultOfTheFirstFunctionIfTheSecondFunctionReturnsTrue()
 {
     var enumerator = new [] {1, 3, 4, 5}.GetEnumerator();
     Func<int> getNextItem = () =>
     {
         enumerator.MoveNext();
         return (int)enumerator.Current;
     };
     var result = Wait.Until(() => getNextItem(), item => item%2 == 0, 100.Milliseconds());
     Assert.AreEqual(4, result);
 }
Example #7
0
 /// <summary>
 /// Convenience method for logging an iterator.
 /// </summary>
 /// <param name="label">  String logged before/after the items in the iterator </param>
 /// <param name="iter">   Each next() is toString()ed and logged on it's own line. If iter is null this is logged differnetly then an empty iterator. </param>
 /// <param name="stream"> Stream to log messages to. </param>
 public static void DumpIterator(string label, System.Collections.IEnumerator iter, TextWriter stream)
 {
     stream.WriteLine("*** BEGIN " + label + " ***");
     if (null == iter)
     {
         stream.WriteLine(" ... NULL ...");
     }
     else
     {
         while (iter.MoveNext())
         {
             stream.WriteLine(iter.Current.ToString());
         }
     }
     stream.WriteLine("*** END " + label + " ***");
 }
Example #8
0
		/// <summary>
		/// Determines whether two IDictionaryEnumerator instances are equals.
		/// </summary>
		/// <param name="source">The first IDictionaryEnumerator to compare.</param>
		/// <param name="target">The second IDictionaryEnumerator to compare.</param>
		/// <returns>Return true if the first IDictionaryEnumerator contains the same values as the second IDictionaryEnumerator, otherwise return false.</returns>
		public static bool EqualsSupport(System.Collections.IDictionaryEnumerator source, System.Collections.IDictionaryEnumerator target )
		{
			while(source.MoveNext() && target.MoveNext())
				if (source.Key.Equals(target.Key))
					if(source.Value.Equals(target.Value))
						return true;
			return false;
		}
Example #9
0
 public void Append(System.Collections.Generic.IEnumerator<char> input)
 {
     while (input.MoveNext())
     {
         char current = input.Current;
         if (current == ' ')
             this.AppendWhitespace();
         else if (input.MoveNext())
             this.Append(current, input.Current);
     }
 }
Example #10
0
        /// <summary> Uses a filterIterator to create a string representation of a filter.
        /// 
        /// </summary>
        /// <param name="itr">Iterator of filter components
        /// </param>
        /// <param name="filter">Buffer to place a string representation of the filter
        /// </param>
        /// <seealso cref="FilterIterator">
        /// </seealso>
        private static void stringFilter(System.Collections.IEnumerator itr, System.Text.StringBuilder filter)
        {
            int op = - 1;
            filter.Append('(');
            while (itr.MoveNext())
            {
                System.Object filterpart = itr.Current;
                if (filterpart is System.Int32)
                {
                    op = ((System.Int32) filterpart);
                    switch (op)
                    {

                        case AND:
                            filter.Append('&');
                            break;

                        case OR:
                            filter.Append('|');
                            break;

                        case NOT:
                            filter.Append('!');
                            break;

                        case EQUALITY_MATCH:  {
                                filter.Append((System.String) itr.Current);
                                filter.Append('=');
                                sbyte[] value_Renamed = (sbyte[]) itr.Current;
                                filter.Append(byteString(value_Renamed));
                                break;
                            }

                        case GREATER_OR_EQUAL:  {
                                filter.Append((System.String) itr.Current);
                                filter.Append(">=");
                                sbyte[] value_Renamed = (sbyte[]) itr.Current;
                                filter.Append(byteString(value_Renamed));
                                break;
                            }

                        case LESS_OR_EQUAL:  {
                                filter.Append((System.String) itr.Current);
                                filter.Append("<=");
                                sbyte[] value_Renamed = (sbyte[]) itr.Current;
                                filter.Append(byteString(value_Renamed));
                                break;
                            }

                        case PRESENT:
                            filter.Append((System.String) itr.Current);
                            filter.Append("=*");
                            break;

                        case APPROX_MATCH:
                            filter.Append((System.String) itr.Current);
                            filter.Append("~=");
                            sbyte[] value_Renamed2 = (sbyte[]) itr.Current;
                            filter.Append(byteString(value_Renamed2));
                            break;

                        case EXTENSIBLE_MATCH:
                            System.String oid = (System.String) itr.Current;

                            filter.Append((System.String) itr.Current);
                            filter.Append(':');
                            filter.Append(oid);
                            filter.Append(":=");
                            filter.Append((System.String) itr.Current);
                            break;

                        case SUBSTRINGS:  {
                                filter.Append((System.String) itr.Current);
                                filter.Append('=');
                                bool noStarLast = false;
                                while (itr.MoveNext())
                                {
                                    op = ((System.Int32) itr.Current);
                                    switch (op)
                                    {

                                        case INITIAL:
                                            filter.Append((System.String) itr.Current);
                                            filter.Append('*');
                                            noStarLast = false;
                                            break;

                                        case ANY:
                                            if (noStarLast)
                                                filter.Append('*');
                                            filter.Append((System.String) itr.Current);
                                            filter.Append('*');
                                            noStarLast = false;
                                            break;

                                        case FINAL:
                                            if (noStarLast)
                                                filter.Append('*');
                                            filter.Append((System.String) itr.Current);
                                            break;
                                        }
                                }
                                break;
                            }
                        }
                }
                else if (filterpart is System.Collections.IEnumerator)
                {
                    stringFilter((System.Collections.IEnumerator) filterpart, filter);
                }
            }
            filter.Append(')');
        }
Example #11
0
        private string BuildQueryString(System.Collections.IDictionaryEnumerator ienum)
        {
            string query = string.Empty;
            Hashtable hsh = new Hashtable();
            string qname = string.Empty;
            string val = string.Empty;

            while (ienum.MoveNext())
            {
                qname = (ienum.Value as LocationQueryString).QueryName;
                val  = (ienum.Value as LocationQueryString).Name;
                if (hsh.ContainsKey(qname))
                {
                    hsh[qname] = hsh[qname] + " " + val;
                }
                else
                {
                    hsh[qname] = val;
                }
            }
            System.Collections.IDictionaryEnumerator qenum = hsh.GetEnumerator();

            while (qenum.MoveNext())
            {
                query = query + string.Format("&{0}={1}", qenum.Key.ToString(), qenum.Value.ToString());
            }
            return query;
        }
 private bool TryMoveNext(System.Collections.IEnumerator en)
 {
     try
     {
         return en.MoveNext();
     }
     catch
     {
         return false;
     }
 }
Example #13
0
 private Object getFirst(System.Collections.IEnumerator ie)
 {
     if (!ie.MoveNext())
     {
         return null;
     }
     else
     {
         return ie.Current;
     }
 }
Example #14
0
 private X86Instruction DisEnumerator_TakeNext(System.Collections.Generic.IEnumerator<X86Instruction> e)
 {
     e.MoveNext();
     return e.Current;
 }
Example #15
0
 private void CommitPhones(System.Collections.IEnumerator e, Charp.SuccessDelegate success, Charp.ErrorDelegate error)
 {
     if (e.MoveNext ()) {
         PhoneEditor editor = (PhoneEditor) e.Current;
         editor.Commit (delegate (object data, Charp.CharpCtx ctx) {
             CommitPhones (e, success, error);
         }, error);
     } else {
         System.Collections.IEnumerator e2 = vboxEmails.GetEnumerator ();
         e2.Reset ();
         CommitEmails (e2, success, error);
     }
 }
Example #16
0
 private void CommitEmails(System.Collections.IEnumerator e, Charp.SuccessDelegate success, Charp.ErrorDelegate error)
 {
     if (e.MoveNext ()) {
         EmailEditor editor = (EmailEditor) e.Current;
         editor.Commit (delegate (object data, Charp.CharpCtx ctx) {
             CommitEmails (e, success, error);
         }, error);
     } else {
         success (null, null);
     }
 }