Esempio n. 1
0
 public override string ToString()
 {
     if (isEmpty())
     {
         return("[]");
     }
     java.lang.StringBuilder buffer = new java.lang.StringBuilder(size() * 16);
     buffer.append('[');
     java.util.Iterator <E> it = iterator();
     while (it.hasNext())
     {
         object next = it.next();
         if (next != this)
         {
             buffer.append(next);
         }
         else
         {
             buffer.append("(this Collection)");
         }
         if (it.hasNext())
         {
             buffer.append(", ");
         }
     }
     buffer.append(']');
     return(buffer.ToString());
 }
        /**
         * Tests two lists for value-equality as per the equality contract in
         * {@link java.util.List#equals(java.lang.Object)}.
         * <p>
         * This method is useful for implementing <code>List</code> when you cannot
         * extend AbstractList. The method takes Collection instances to enable other
         * collection types to use the List implementation algorithm.
         * <p>
         * The relevant text (slightly paraphrased as this is a static method) is:
         * <blockquote>
         * Compares the two list objects for equality.  Returns
         * <tt>true</tt> if and only if both
         * lists have the same size, and all corresponding pairs of elements in
         * the two lists are <i>equal</i>.  (Two elements <tt>e1</tt> and
         * <tt>e2</tt> are <i>equal</i> if <tt>(e1==null ? e2==null :
         * e1.equals(e2))</tt>.)  In other words, two lists are defined to be
         * equal if they contain the same elements in the same order.  This
         * definition ensures that the equals method works properly across
         * different implementations of the <tt>List</tt> interface.
         * </blockquote>
         *
         * <b>Note:</b> The behaviour of this method is undefined if the lists are
         * modified during the equals comparison.
         *
         * @see java.util.List
         * @param list1  the first list, may be null
         * @param list2  the second list, may be null
         * @return whether the lists are equal by value comparison
         */
        public static bool isEqualList(java.util.Collection <Object> list1, java.util.Collection <Object> list2)
        {
            if (list1 == list2)
            {
                return(true);
            }
            if (list1 == null || list2 == null || list1.size() != list2.size())
            {
                return(false);
            }

            java.util.Iterator <Object> it1 = list1.iterator();
            java.util.Iterator <Object> it2 = list2.iterator();
            Object obj1 = null;
            Object obj2 = null;

            while (it1.hasNext() && it2.hasNext())
            {
                obj1 = it1.next();
                obj2 = it2.next();

                if (!(obj1 == null ? obj2 == null : obj1.equals(obj2)))
                {
                    return(false);
                }
            }

            return(!(it1.hasNext() || it2.hasNext()));
        }
Esempio n. 3
0
 public virtual bool remove(object @object)
 {
     java.util.Iterator <E> it = iterator();
     if (@object != null)
     {
         while (it.hasNext())
         {
             if (@object.Equals(it.next()))
             {
                 it.remove();
                 return(true);
             }
         }
     }
     else
     {
         while (it.hasNext())
         {
             if (it.next() == null)
             {
                 it.remove();
                 return(true);
             }
         }
     }
     return(false);
 }
        public override String ToString()
        {
            if (size() == 0)
            {
                return("[]");
            }
            java.lang.StringBuffer buf = new java.lang.StringBuffer(16 * size());
            buf.append("[");

            java.util.Iterator <Object> it = iterator();
            bool hasNext = it.hasNext();

            while (hasNext)
            {
                Object value = it.next();
                buf.append(value == this ? "(this Collection)" : value);
                hasNext = it.hasNext();
                if (hasNext)
                {
                    buf.append(", ");
                }
            }
            buf.append("]");
            return(buf.toString());
        }
Esempio n. 5
0
        /**
         * Returns an {@code Enumeration} that contains all of the loaded JDBC
         * drivers that the current caller can access.
         *
         * @return An {@code Enumeration} containing all the currently loaded JDBC
         *         {@code Drivers}.
         */
        public static java.util.Enumeration <Driver> getDrivers()
        {
            java.lang.ClassLoader callerClassLoader = java.lang.Runtime.getRuntime().getClass().getClassLoader();// Basties note: sometime do the same as VM.callerClassLoader();

            /*
             * Synchronize to avoid clashes with additions and removals of drivers
             * in the DriverSet
             */
            lock (theDrivers)
            {
                /*
                 * Create the Enumeration by building a Vector from the elements of
                 * the DriverSet
                 */
                java.util.Vector <Driver>   theVector   = new java.util.Vector <Driver>();
                java.util.Iterator <Driver> theIterator = theDrivers.iterator();
                while (theIterator.hasNext())
                {
                    Driver theDriver = theIterator.next();
                    if (DriverManager.isClassFromClassLoader(theDriver,
                                                             callerClassLoader))
                    {
                        theVector.add(theDriver);
                    }
                }
                return(theVector.elements());
            }
        }
Esempio n. 6
0
        /**
         * Tries to find a driver that can interpret the supplied URL.
         *
         * @param url
         *            the URL of a database.
         * @return a {@code Driver} that matches the provided URL. {@code null} if
         *         no {@code Driver} understands the URL
         * @throws SQLException
         *             if there is any kind of problem accessing the database.
         */
        public static Driver getDriver(String url)
        {                                                                                                         //throws SQLException {
            java.lang.ClassLoader callerClassLoader = java.lang.Runtime.getRuntime().getClass().getClassLoader(); // Basties note: sometime do the same as VM.callerClassLoader();

            lock (theDrivers)
            {
                /*
                 * Loop over the drivers in the DriverSet checking to see if one
                 * does understand the supplied URL - return the first driver which
                 * does understand the URL
                 */
                java.util.Iterator <Driver> theIterator = theDrivers.iterator();
                while (theIterator.hasNext())
                {
                    Driver theDriver = theIterator.next();
                    if (theDriver.acceptsURL(url) &&
                        DriverManager.isClassFromClassLoader(theDriver,
                                                             callerClassLoader))
                    {
                        return(theDriver);
                    }
                }
            }
            // If no drivers understand the URL, throw an SQLException
            // sql.6=No suitable driver
            // SQLState: 08 - connection exception
            // 001 - SQL-client unable to establish SQL-connection
            throw new SQLException("No suitable driver", "08001"); //$NON-NLS-1$ //$NON-NLS-2$
        }
Esempio n. 7
0
        void WriteGraph(RdfGraph graph, RdfSourceWrapper sourcewrapper, StatementSink sink)
        {
            java.util.Iterator iter = graph.iterator();
            while (iter.hasNext())
            {
                GraphStatement stmt = (GraphStatement)iter.next();
                Statement      s;
                if (stmt is GraphStatementWrapper)
                {
                    s = ((GraphStatementWrapper)stmt).s;
                }
                else
                {
                    s = new Statement(
                        sourcewrapper.ToEntity(stmt.getSubject()),
                        sourcewrapper.ToEntity(stmt.getPredicate()),
                        sourcewrapper.ToResource(stmt.getObject()),
                        stmt.getGraphName() == null ? Statement.DefaultMeta : sourcewrapper.ToEntity(stmt.getGraphName()));
                }

                if (s.AnyNull)
                {
                    continue;                            // unbound variable, or literal in bad position
                }
                sink.Add(s);
            }
        }
Esempio n. 8
0
 /**
  * Return the hash code value for this list.  This implementation uses
  * exactly the code that is used to define the list hash function in the
  * documentation for the <code>List.hashCode</code> method.
  */
 public override int GetHashCode()
 {
     if (fast)
     {
         int hashCode = 1;
         java.util.Iterator <Object> i = list.iterator();
         while (i.hasNext())
         {
             Object o = i.next();
             hashCode = 31 * hashCode + (o == null ? 0 : o.GetHashCode());
         }
         return(hashCode);
     }
     else
     {
         lock (list)
         {
             int hashCode = 1;
             java.util.Iterator <Object> i = list.iterator();
             while (i.hasNext())
             {
                 Object o = i.next();
                 hashCode = 31 * hashCode + (o == null ? 0 : o.GetHashCode());
             }
             return(hashCode);
         }
     }
 }
Esempio n. 9
0
            public Object next()
            {
                if (firstNodes.empty())
                {
                    throw new java.util.NoSuchElementException();
                }

                // get a node from firstNodes
                ProviderNode node = firstNodes.pop();

                // find all the outgoing nodes
                java.util.Iterator <Object> it = node.getOutgoingNodes();
                while (it.hasNext())
                {
                    ProviderNode outNode = (ProviderNode)it.next();

                    // remove the incoming edge from the node.
                    int edges = incomingEdges.get(outNode);
                    edges--;
                    incomingEdges.put(outNode, new java.lang.Integer(edges));

                    // add to the firstNodes if this node's incoming edge is equal to 0
                    if (edges == 0)
                    {
                        firstNodes.push(outNode);
                    }
                }

                incomingEdges.remove(node);

                return(node.getProvider());
            }
Esempio n. 10
0
 /**
  * Destroys all instances in the stack and clears the stack.
  *
  * @param key key passed to factory when destroying instances
  * @param stack stack to destroy
  */
 private void destroyStack(K key, java.util.Stack <V> stack)
 {
     lock (this)
     {
         if (null == stack)
         {
             return;
         }
         else
         {
             if (null != _factory)
             {
                 java.util.Iterator <V> it = stack.iterator();
                 while (it.hasNext())
                 {
                     try
                     {
                         _factory.destroyObject(key, it.next());
                     }
                     catch (Exception e)
                     {
                         // ignore error, keep destroying the rest
                     }
                 }
             }
             _totIdle -= stack.size();
             _activeCount.remove(key);
             stack.clear();
         }
     }
 }
Esempio n. 11
0
        public override bool retainAll(java.util.Collection <Object> coll)
        {
            bool result = collection.retainAll(coll);

            if (result == false)
            {
                return(false);
            }
            else if (collection.size() == 0)
            {
                setOrder.clear();
            }
            else
            {
                for (java.util.Iterator <Object> it = setOrder.iterator(); it.hasNext();)
                {
                    Object obj = it.next();
                    if (collection.contains(obj) == false)
                    {
                        it.remove();
                    }
                }
            }
            return(result);
        }
Esempio n. 12
0
        public override bool Equals(Object o)
        {
            if (!(o is java.util.Map <Object, Object>))
            {
                return(false);
            }

            java.util.Map <Object, Object> m    = (java.util.Map <Object, Object>)o;
            java.util.Set <Object>         keys = keySet();
            if (!keys.equals(m.keySet()))
            {
                return(false);
            }

            java.util.Iterator <Object> it = keys.iterator();
            while (it.hasNext())
            {
                Key    key = (Key)it.next();
                Object v1  = get(key);
                Object v2  = m.get(key);
                if (!(v1 == null?v2 == null:v1.equals(v2)))
                {
                    return(false);
                }
            }
            return(true);
        }
Esempio n. 13
0
        /// <summary>
        /// https://universaldependencies.org/u/dep/index.html
        /// Stratify a sentence according to the subject-predicate relationship
        /// </summary>
        /// <param name="sentence"></param>
        /// <returns>sentence, subject, predicate, objective</returns>
        public List <(edu.stanford.nlp.util.CoreMap, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord)> StepSamplingDependency(edu.stanford.nlp.util.CoreMap sentence)
        {
            List <(edu.stanford.nlp.util.CoreMap, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord)> samplings = new List <(edu.stanford.nlp.util.CoreMap, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord, edu.stanford.nlp.ling.IndexedWord)>();

            edu.stanford.nlp.semgraph.SemanticGraph dependencies = sentence.get(enhancedPlusPlusDependenciesAnnotationClass) as edu.stanford.nlp.semgraph.SemanticGraph;
            java.util.Collection typedDependencies = dependencies.typedDependencies();
            java.util.Iterator   itr = typedDependencies.iterator();
            while (itr.hasNext())
            {
                edu.stanford.nlp.trees.TypedDependency td = itr.next() as edu.stanford.nlp.trees.TypedDependency;
                string relationType = td.reln().getShortName();
                //Nominals
                if (relationType == "nsubj" || relationType == "nsubjpass")
                {
                    edu.stanford.nlp.ling.IndexedWord subject, predicate, objective;
                    subject = td.dep(); predicate = td.gov();
                    //在谓语位置上,缺不满足谓语角色的词,此种谓语可缺省
                    edu.stanford.nlp.ling.IndexedWord expl = FindIndexedWordByDependencyType(dependencies, predicate, "expl");
                    predicate = expl == null ? predicate : null;
                    //直接宾语,
                    objective = FindIndexedWordByDependencyType(dependencies, predicate, "obj", "dobj");
                    //动词或形容词的补语做宾语, open clausal complement
                    objective = objective ?? FindIndexedWordByDependencyType(dependencies, predicate, "ccomp", "xcomp");
                    //加入层次集合
                    samplings.Add((sentence, subject, predicate, objective));
                }
            }
            return(samplings);
        }
Esempio n. 14
0
 /**
  * Clears any objects sitting idle in the pool.
  */
 public override void clear()
 {
     lock (this)
     {
         if (null != _factory)
         {
             java.util.Iterator <java.lang.refj.SoftReference <T> > iter = _pool.iterator();
             while (iter.hasNext())
             {
                 try
                 {
                     T obj = iter.next().get();
                     if (null != obj)
                     {
                         _factory.destroyObject(obj);
                     }
                 }
                 catch (Exception e)
                 {
                     // ignore error, keep destroying the rest
                 }
             }
         }
         _pool.clear();
         pruneClearedReferences();
     }
 }
Esempio n. 15
0
        static void Main()
        {
            java.util.ArrayList <int> primeNumbers = new java.util.ArrayList <int>();
            primeNumbers.add(1);
            primeNumbers.add(2);
            primeNumbers.add(3);
            primeNumbers.add(5);
            primeNumbers.add(7);

            java.lang.SystemJ.outJ.println("Work with all collection elements");

            java.lang.SystemJ.outJ.println("Using collection with for loop");
            for (int i = 0; i < primeNumbers.size(); i++)
            {
                java.lang.SystemJ.outJ.println(primeNumbers.get(i));
            }

            java.lang.SystemJ.outJ.println("Using collection with iterator while loop");
            java.util.Iterator <int> it = primeNumbers.iterator();
            while (it.hasNext())
            {
                java.lang.SystemJ.outJ.println(it.next());
            }

            java.lang.SystemJ.outJ.println("Using Java collection with .NET foreach loop");
            foreach (int prime in primeNumbers)
            {
                java.lang.SystemJ.outJ.println(prime);
            }

            java.lang.SystemJ.outJ.print("");
        }
Esempio n. 16
0
        public override bool removeAll <_T0>(java.util.Collection <_T0> collection)
        {
            bool result = false;

            if (size() <= collection.size())
            {
                java.util.Iterator <E> it = iterator();
                while (it.hasNext())
                {
                    if (collection.contains(it.next()))
                    {
                        it.remove();
                        result = true;
                    }
                }
            }
            else
            {
                java.util.Iterator <_T0> it = collection.iterator();
                while (it.hasNext())
                {
                    result = remove(it.next()) || result;
                }
            }
            return(result);
        }
Esempio n. 17
0
        /**
         * Adds an delete change.
         *
         * @param pChange
         *            the change which should result in a deletion
         */
        private void addDeletion(Change pChange)
        {
            if ((Change.TYPE_DELETE != pChange.type() &&
                 Change.TYPE_DELETE_DIR != pChange.type()) ||
                pChange.targetFile() == null)
            {
                return;
            }
            String source = pChange.targetFile();

            if (!changes.isEmpty())
            {
                for (java.util.Iterator <Change> it = changes.iterator(); it.hasNext();)
                {
                    Change change = (Change)it.next();
                    if (change.type() == Change.TYPE_ADD &&
                        change.getEntry() != null)
                    {
                        String target = change.getEntry().getName();

                        if (Change.TYPE_DELETE == pChange.type() && source.equals(target))
                        {
                            it.remove();
                        }
                        else if (Change.TYPE_DELETE_DIR == pChange.type() &&
                                 target.matches(source + "/.*"))
                        {
                            it.remove();
                        }
                    }
                }
            }
            changes.add(pChange);
        }
Esempio n. 18
0
 public void registerServiceProviders(java.util.Iterator <Object> providers)
 {
     for (java.util.Iterator <Object> iterator = providers; iterator.hasNext();)
     {
         categories.addProvider(iterator.next(), null);
     }
 }
Esempio n. 19
0
        /**
         * Adds an addition change.
         *
         * @param pChange
         *            the change which should result in an addition
         */
        private void addAddition(Change pChange)
        {
            if (Change.TYPE_ADD != pChange.type() ||
                pChange.getInput() == null)
            {
                return;
            }

            if (!changes.isEmpty())
            {
                for (java.util.Iterator <Change> it = changes.iterator(); it.hasNext();)
                {
                    Change change = it.next();
                    if (change.type() == Change.TYPE_ADD && change.getEntry() != null)
                    {
                        org.apache.commons.compress.archivers.ArchiveEntry entry = change.getEntry();
                        if (entry.equals(pChange.getEntry()))
                        {
                            if (pChange.isReplaceMode())
                            {
                                it.remove();
                                changes.add(pChange);
                                return;
                            }
                            else
                            {
                                // do not add this change
                                return;
                            }
                        }
                    }
                }
            }
            changes.add(pChange);
        }
Esempio n. 20
0
        /**
         * Returns a set of attributes present in the {@code AttributedString}.
         * An empty set returned indicates that no attributes where defined.
         *
         * @return a set of attribute keys that may be empty.
         */
        public java.util.Set <AttributedCharacterIteratorNS.Attribute> getAllAttributeKeys()
        {
            if (begin == 0 && end == attrString.text.Length &&
                attributesAllowed == null)
            {
                return(attrString.attributeMap.keySet());
            }

            java.util.Set <AttributedCharacterIteratorNS.Attribute> result = new java.util.HashSet <AttributedCharacterIteratorNS.Attribute>();//(attrString.attributeMap.size() * 4 / 3) + 1);
            java.util.Iterator <java.util.MapNS.Entry <AttributedCharacterIteratorNS.Attribute, java.util.List <IAC_Range> > > it = attrString.attributeMap
                                                                                                                                    .entrySet().iterator();
            while (it.hasNext())
            {
                java.util.MapNS.Entry <AttributedCharacterIteratorNS.Attribute, java.util.List <IAC_Range> > entry = it.next();
                if (attributesAllowed == null ||
                    attributesAllowed.contains(entry.getKey()))
                {
                    java.util.List <IAC_Range> ranges = entry.getValue();
                    if (inRange(ranges))
                    {
                        result.add(entry.getKey());
                    }
                }
            }
            return(result);
        }
        //-----------------------------------------------------------------------

        /**
         * Returns the Map as a string.
         *
         * @return the Map as a String
         */
        public override String ToString()
        {
            if (isEmpty())
            {
                return("{}");
            }
            java.lang.StringBuffer buf = new java.lang.StringBuffer();
            buf.append('{');
            bool first = true;

            java.util.Iterator <Object> it = entrySet().iterator();
            while (it.hasNext())
            {
                java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
                Object key   = entry.getKey();
                Object value = entry.getValue();
                if (first)
                {
                    first = false;
                }
                else
                {
                    buf.append(", ");
                }
                buf.append(key == this ? "(this Map)" : key);
                buf.append('=');
                buf.append(value == this ? "(this Map)" : value);
            }
            buf.append('}');
            return(buf.toString());
        }
        /**
         * Returns an array of all of this bag's elements.
         *
         * @param array  the array to populate
         * @return an array of all of this bag's elements
         */
        public virtual Object[] toArray <Object>(Object[] array)
        {
            int size = this.size();

            if (array.Length < size)
            {
                array = new Object[sizeJ];
            }

            int i = 0;

            java.util.Iterator <Object> it = (java.util.Iterator <Object>)map.keySet().iterator();
            while (it.hasNext())
            {
                Object current = it.next();
                for (int index = getCount(current); index > 0; index--)
                {
                    array[i++] = current;
                }
            }
            if (array.Length > size)
            {
                array[size] = default(Object);
            }
            return(array);
        }
        //-----------------------------------------------------------------------

        /**
         * Compares this Bag to another.
         * This Bag equals another Bag if it contains the same number of occurrences of
         * the same elements.
         *
         * @param object  the Bag to compare to
         * @return true if equal
         */
        public override bool Equals(Object obj)
        {
            if (obj == this)
            {
                return(true);
            }
            if (obj is Bag == false)
            {
                return(false);
            }
            Bag other = (Bag)obj;

            if (other.size() != size())
            {
                return(false);
            }
            for (java.util.Iterator <Object> it = map.keySet().iterator(); it.hasNext();)
            {
                Object element = it.next();
                if (other.getCount(element) != getCount(element))
                {
                    return(false);
                }
            }
            return(true);
        }
Esempio n. 24
0
        /*
         *
         * Adds information about provider services into HashMap.
         *
         * @param p
         */
        public static void initServiceInfo(java.security.Provider p)
        {
            java.security.Provider.Service serv;
            String key;
            String type;
            String alias;

            java.lang.StringBuilder sb = new java.lang.StringBuilder(128);

            for (java.util.Iterator <java.security.Provider.Service> it1 = p.getServices().iterator(); it1.hasNext();)
            {
                serv = it1.next();
                type = serv.getType();
                sb.delete(0, sb.length());
                key = sb.append(type).append(".").append( //$NON-NLS-1$
                    Util.toUpperCase(serv.getAlgorithm())).toString();
                if (!services.containsKey(key))
                {
                    services.put(key, serv);
                }
                for (java.util.Iterator <String> it2 = Engine.door.getAliases(serv); it2.hasNext();)
                {
                    alias = it2.next();
                    sb.delete(0, sb.length());
                    key = sb.append(type).append(".").append(Util.toUpperCase(alias)) //$NON-NLS-1$
                          .toString();
                    if (!services.containsKey(key))
                    {
                        services.put(key, serv);
                    }
                }
            }
        }
        /**
         * Remove any members of the bag that are not in the given
         * bag, respecting cardinality.
         * @see #retainAll(Collection)
         *
         * @param other  the bag to retain
         * @return <code>true</code> if this call changed the collection
         */
        bool retainAll(Bag other)
        {
            bool result = false;
            Bag  excess = new HashBag();

            java.util.Iterator <Object> i = uniqueSet().iterator();
            while (i.hasNext())
            {
                Object current    = i.next();
                int    myCount    = getCount(current);
                int    otherCount = other.getCount(current);
                if (1 <= otherCount && otherCount <= myCount)
                {
                    excess.add(current, myCount - otherCount);
                }
                else
                {
                    excess.add(current, myCount);
                }
            }
            if (!excess.isEmpty())
            {
                result = removeAll(excess);
            }
            return(result);
        }
Esempio n. 26
0
        /// <summary>
        /// Gets the response and modify the headers.
        /// </summary>
        /// <returns>The response.</returns>
        /// <param name="request">Request.</param>
        public override WebResponse getResponse(WebRequest request)
        {
            WebResponse response = base.getResponse(request);

            //
            // Only if Url matches
            //
            if (request.getUrl().toExternalForm().Contains("com"))
            {
                string content = response.getContentAsString("UTF-8");
                java.util.ArrayList newheaders = new java.util.ArrayList();
                java.util.List      headers    = response.getResponseHeaders();
                java.util.Iterator  it         = headers.iterator();
                //
                // Remove the 'Access-Control-Allow-Origin' header
                //
                while (it.hasNext())
                {
                    com.gargoylesoftware.htmlunit.util.NameValuePair o = (com.gargoylesoftware.htmlunit.util.NameValuePair)it.next();
                    if (o.getName().Equals("Access-Control-Allow-Origin"))
                    {
                        string value = response.getResponseHeaderValue("Access-Control-Allow-Origin");
                        Console.WriteLine("Found header 'Access-Control-Allow-Origin' = \"{0}\" and stripping it from new headers for response", value);
                        continue; //headers.remove(o);
                    }
                    newheaders.add(o);
                }
                byte[]          utf  = System.Text.Encoding.UTF8.GetBytes(content);
                WebResponseData data = new WebResponseData(utf,
                                                           response.getStatusCode(), response.getStatusMessage(), newheaders);
                response = new WebResponse(data, request, response.getLoadTime());
                return(response);
            }
            return(response);
        }
Esempio n. 27
0
 /**
  * Return the hash code value for this map.  This implementation uses
  * exactly the code that is used to define the list hash function in the
  * documentation for the <code>Map.hashCode</code> method.
  *
  * @return suitable integer hash code
  */
 public override int GetHashCode()
 {
     if (fast)
     {
         int h = 0;
         java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator();
         while (i.hasNext())
         {
             h += i.next().GetHashCode();
         }
         return(h);
     }
     else
     {
         lock (map)
         {
             int h = 0;
             java.util.Iterator <java.util.MapNS.Entry <Object, Object> > i = map.entrySet().iterator();
             while (i.hasNext())
             {
                 h += i.next().GetHashCode();
             }
             return(h);
         }
     }
 }
Esempio n. 28
0
 /// <summary>
 /// Get the IEnemurator instance for this wrapped java.util.Iterator.
 /// </summary>
 /// <returns></returns>
 public virtual IEnumerator <E> GetEnumerator()
 {
     java.util.Iterator <E> it = this.iterator();
     while (it.hasNext())
     {
         yield return(it.next());
     }
 }
Esempio n. 29
0
 public bool hasNext()
 {
     if (expected != root.map)
     {
         throw new java.util.ConcurrentModificationException();
     }
     return(iterator.hasNext());
 }
Esempio n. 30
0
 public static void forEach(Iterable @this, java.util.function.Consumer consumer)
 {
     java.util.Iterator i = @this.iterator();
     while (i.hasNext())
     {
         consumer.accept(i.next());
     }
 }