internal RestCollection(IEnumerator enumerator)
        {
            if (enumerator == null)
                this._inner = new object[0];
            else
            {
                ArrayList list = new ArrayList();
                //try
                //{
                //    object o = enumerator.Current;
                //    list.Add(o);
                //}
                //catch (InvalidOperationException)
                //{
                //    // Just means there's no current object
                //}

                while (enumerator.MoveNext())
                {
                    list.Add(enumerator.Current);
                }
                this._inner = list;
                _count = _inner.Count-1;
            }
        }

 /// <summary>
 /// Initializes a new instance of the EnumeratorProxy class.
 /// </summary>
 /// <param name="wrapperScope">The wrapper scope.</param>
 /// <param name="underlyingImplementation">The underlying implementation of the proxy.</param>
 public EnumeratorProxy(IWrapperScope wrapperScope, System.Collections.IEnumerator underlyingImplementation)
 {
     ExceptionUtilities.CheckArgumentNotNull(wrapperScope, "wrapperScope");
     ExceptionUtilities.CheckArgumentNotNull(underlyingImplementation, "underlyingImplementation");
     
     this.Scope = wrapperScope;
     this.underlyingImplementation = underlyingImplementation;
 }

 private System.Collections.IEnumerator CurrentIterator()
 {
     if (_currentIterator == null)
     {
         _currentIterator = _delegate.GetEnumerator();
         _status = Enumerator_Status.RESET;
     }
     return _currentIterator;
 }

        public void VisitAll(params System.Collections.IEnumerable[] m)
        {
            // initialize
            int n = m.Length;
            int j;
            System.Collections.IEnumerator[] a = new System.Collections.IEnumerator[n + 1];

            for (j = 1; j <= n; j++)
            {
                a[j] = m[j - 1].GetEnumerator();
                a[j].MoveNext();
            }

            a[0] = m[0].GetEnumerator();
            a[0].MoveNext();

            for (; ; )
            {
                switch (this.RunMode)
                {
                    case RunModeEnum.SelectClauses:
                        VisitTableColumns(a);
                        break;

                    case RunModeEnum.CurrentRow:
                        VisitCurrentRow(a);
                        break;

                    case RunModeEnum.Console:
                    default:
                        Visit(a);
                        break;
                }

                // prepare to add one
                j = n;

                // carry if necessary
                while (!a[j].MoveNext())
                {
                    a[j].Reset();
                    a[j].MoveNext();
                    j -= 1;
                }

                // increase unless done
                if (j == 0)
                {
                    break; // Terminate the algorithm
                }

            }
        }

 /// <summary>
 /// Initializes a newly created <code>SequenceInputStream</code>
 /// by remembering the argument, which must
 /// be an <code>Enumeration</code>  that produces
 /// objects whose run-time type is <code>InputStream</code>.
 /// </summary>
 /// <remarks>
 /// Initializes a newly created <code>SequenceInputStream</code>
 /// by remembering the argument, which must
 /// be an <code>Enumeration</code>  that produces
 /// objects whose run-time type is <code>InputStream</code>.
 /// The input streams that are  produced by
 /// the enumeration will be read, in order,
 /// to provide the bytes to be read  from this
 /// <code>SequenceInputStream</code>. After
 /// each input stream from the enumeration
 /// is exhausted, it is closed by calling its
 /// <code>close</code> method.
 /// </remarks>
 /// <param name="e">an enumeration of input streams.</param>
 /// <seealso cref="System.Collections.IEnumerator{E}">System.Collections.IEnumerator&lt;E&gt;
 /// 	</seealso>
 public SequenceInputStream(System.Collections.Generic.IEnumerator<InputStream> e)
 {
     this.e = e;
     try
     {
         nextStream();
     }
     catch (System.IO.IOException)
     {
         // This should never happen
         throw new System.Exception("panic");
     }
 }

		public PropertiesEnumerator(System.Collections.IEnumerator _Enmtr) { Enmtr=_Enmtr; }

		public NuGenFilterIterator(System.Collections.IEnumerator iter, NuGenFilterIterator.Predicate predicate)
		{
			this.iter = iter;
			this.predicate = predicate;
		}

		public QueryDefsEnumerator(System.Collections.IEnumerator _Enmtr) { Enmtr=_Enmtr; }

		public EnumeratorBase(System.Collections.IEnumerator inner)
		{
			this.inner = inner;
		}

 public override void Reset()
 {
     if (cache != null)
     {
         iterator = cache.GetEnumerator();
     }
 }

        public static SyntaxTree GetTree(System.Collections.ArrayList Tokens)
        {
            TokenEnm = Tokens.GetEnumerator();

            GetToken();

            return StatementBlock();
        }

        /// <summary>
        /// Create new odb client
        /// </summary>
        public OdbClient()
        {

            this.PriorityEnumerator = Priorities.GetEnumerator();
            this.socket = new OdbSocket(new StreamSocket());

            this.status = new OdbStatus(this.socket);
            this.commands = new OdbCommands(this.socket);
            this.ecu = new OdbEcu(this.socket, this.commands);
        }

		public override Token Next(Token reusableToken)
		{
			System.Diagnostics.Debug.Assert(reusableToken != null);
			if (iter == null)
				iter = lst.GetEnumerator();
			// Since this TokenStream can be reset we have to maintain the tokens as immutable
			if (iter.MoveNext())
			{
				Token nextToken = (Token) iter.Current;
				return (Token) nextToken.Clone();
			}
			return null;
		}

        public VertexDeclaration( IGraphicsDevice graphicsDevice, VertexElement [] elements )
        {
            this.elements = elements.GetEnumerator ();
            SharpDX.Direct3D9.Device device = graphicsDevice.Handle as SharpDX.Direct3D9.Device;

            SharpDX.Direct3D9.VertexElement [] convedElements = new SharpDX.Direct3D9.VertexElement [ elements.Length + 1 ];
            for ( int i = 0, offset = 0; i < elements.Length; ++i )
            {
                convedElements [ i ] = new SharpDX.Direct3D9.VertexElement ( 0, ( short ) offset,
                    ConvertType ( elements [ i ].Size ), SharpDX.Direct3D9.DeclarationMethod.Default,
                    ConvertType ( elements [ i ].Type ), ( byte ) elements [ i ].UsageIndex );
                offset += ElementSizeToRealSize ( elements [ i ].Size );
            }
            convedElements [ elements.Length ] = SharpDX.Direct3D9.VertexElement.VertexDeclarationEnd;

            vertexDeclaration = new SharpDX.Direct3D9.VertexDeclaration ( device, convedElements );
        }

		public override Token Next()
		{
			if (cache == null)
			{
				// fill cache lazily
				cache = new System.Collections.ArrayList();
				FillCache();
				iterator = cache.GetEnumerator();
			}
			
			if (!iterator.MoveNext())
			{
				// the cache is exhausted, return null
				return null;
			}
			
			return (Token) iterator.Current;
		}

		public override bool IncrementToken()
		{
			if (cache == null)
			{
				// fill cache lazily
				cache = new System.Collections.ArrayList();
				FillCache();
				iterator = cache.GetEnumerator();
			}
			
			if (!iterator.MoveNext())
			{
				// the cache is exhausted, return false
				return false;
			}
			// Since the TokenFilter can be reset, the tokens need to be preserved as immutable.
			RestoreState((AttributeSource.State) iterator.Current);
			return true;
		}

        public override Token Next(/* in */ Token reusableToken)
        {
            System.Diagnostics.Debug.Assert(reusableToken != null);
            if (cache == null)
            {
                // fill cache lazily
                cache = new System.Collections.ArrayList();
                FillCache(reusableToken);
                iterator = cache.GetEnumerator();
            }

            if (!iterator.MoveNext())
            {
                // the cache is exhausted, return null
                return null;
            }

            Token nextToken = (Token) iterator.Current;
            return (Token) nextToken.Clone();
        }

 public Enumerator(AllIterator list, MemberInfo info)
 {
     this.iterator = list.GetEnumerator();
     this.info = info;
 }

			public override bool Next()
			{
				if (termEnum == null)
					return false;
				
				// another term in this field?
				if (termEnum.Next() && (System.Object) termEnum.Term().Field() == (System.Object) field)
					return true; // yes, keep going
				
				termEnum.Close(); // close old termEnum
				
				// find the next field with terms, if any
				if (fieldIterator == null)
				{
                    System.Collections.Comparer comparer = System.Collections.Comparer.Default;
                    System.Collections.SortedList newList = new System.Collections.SortedList();
                    if (Enclosing_Instance.fieldToReader != null)
                    {
                        if (Enclosing_Instance.fieldToReader.Count > 0)
                        {
                            int index = 0;
                            while (comparer.Compare(Enclosing_Instance.fieldToReader.GetKey(index), field) < 0)
                                index++;
                            for (; index < Enclosing_Instance.fieldToReader.Count; index++)
                            {
                                newList.Add(Enclosing_Instance.fieldToReader.GetKey(index), Enclosing_Instance.fieldToReader[Enclosing_Instance.fieldToReader.GetKey(index)]);
                            }
                        }
                    }

                    fieldIterator = newList.Keys.GetEnumerator();
                    fieldIterator.MoveNext();
					System.Object generatedAux = fieldIterator.Current; // Skip field to get next one
				}
				while (fieldIterator.MoveNext())
				{
					field = ((System.String) fieldIterator.Current);
					termEnum = ((IndexReader) Enclosing_Instance.fieldToReader[field]).Terms(new Term(field));
					Term term = termEnum.Term();
					if (term != null && (System.Object) term.Field() == (System.Object) field)
						return true;
					else
						termEnum.Close();
				}
				
				return false; // no more fields
			}

 public Enumerator(FieldDeclarationCollection collection)
 {
     this.wrapped = ((System.Collections.CollectionBase)collection).GetEnumerator();
 }