private static void removeTimestamp(long userID,
                                            long itemID,
                                            FastByIDMap <FastByIDMap <DateTime?> > timestamps)
        {
            FastByIDMap <DateTime?> itemTimestamps = timestamps.Get(userID);

            if (itemTimestamps != null)
            {
                itemTimestamps.Remove(itemID);
            }
        }
 public void testVersusHashMap()
 {
     FastByIDMap<String> actual = new FastByIDMap<String>();
     IDictionary<long, string> expected = new Dictionary<long,string>(1000000);
     var r = RandomUtils.getRandom();
     for (int i = 0; i < 1000000; i++) {
       double d = r.nextDouble();
       long key = (long) r.nextInt(100);
       if (d < 0.4) {
     Assert.AreEqual( expected.ContainsKey(key)?expected[key]:null, actual.Get(key));
       } else {
     if (d < 0.7) {
     var expectedOldVal = expected.ContainsKey(key) ? expected[key] : null;
     expected[key] = "bang";
     Assert.AreEqual(expectedOldVal, actual.Put(key, "bang"));
     } else {
     var expectedOldVal = expected.ContainsKey(key) ? expected[key] : null;
     expected.Remove(key);
     Assert.AreEqual(expectedOldVal, actual.Remove(key));
     }
     Assert.AreEqual(expected.Count, actual.Count());
     Assert.AreEqual(expected.Count==0, actual.IsEmpty());
       }
     }
 }
 public void testSizeEmpty()
 {
     FastByIDMap<long> map = new FastByIDMap<long>();
     Assert.AreEqual(0, map.Count());
     Assert.True(map.IsEmpty());
     map.Put(500000L, 2L);
     Assert.AreEqual(1, map.Count());
     Assert.False(map.IsEmpty());
     map.Remove(500000L);
     Assert.AreEqual(0, map.Count());
     Assert.True(map.IsEmpty());
 }
 public void testRemove()
 {
     FastByIDMap<long?> map = new FastByIDMap<long?>();
     map.Put(500000L, 2L);
     map.Remove(500000L);
     Assert.AreEqual(0, map.Count());
     Assert.True(map.IsEmpty());
     Assert.IsNull(map.Get(500000L));
 }
        /// <p>
        /// Reads one line from the input file and adds the data to a {@link FastByIDMap} data structure which maps user IDs
        /// to preferences. This assumes that each line of the input file corresponds to one preference. After
        /// reading a line and determining which user and item the preference pertains to, the method should look to
        /// see if the data contains a mapping for the user ID already, and if not, add an empty data structure of preferences
        /// as appropriate to the data.
        /// </p>
        ///
        /// <p>
        /// Note that if the line is empty or begins with '#' it will be ignored as a comment.
        /// </p>
        ///
        /// @param line
        ///          line from input data file
        /// @param data
        ///          all data read so far, as a mapping from user IDs to preferences
        /// @param fromPriorData an implementation detail -- if true, data will map IDs to
        ///  {@link PreferenceArray} since the framework is attempting to read and update raw
        ///  data that is already in memory. Otherwise it maps to {@link Collection}s of
        ///  {@link Preference}s, since it's reading fresh data. Subclasses must be prepared
        ///  to handle this wrinkle.
        protected void processLine <T>(string line,
                                       FastByIDMap <T> data,
                                       FastByIDMap <FastByIDMap <DateTime?> > timestamps,
                                       bool fromPriorData)
        {
            // Ignore empty lines and comments
            if (line.Length == 0 || line[0] == COMMENT_CHAR)
            {
                return;
            }

            var    tokens                = SplitLine(line);
            string userIDString          = tokens[0];
            string itemIDString          = tokens[1];
            string preferenceValueString = tokens[2];
            bool   hasTimestamp          = tokens.Length > 3;
            string timestampString       = hasTimestamp ? tokens[3] : null;

            long userID = readUserIDFromString(userIDString);
            long itemID = readItemIDFromString(itemIDString);

            if (transpose)
            {
                long tmp = userID;
                userID = itemID;
                itemID = tmp;
            }

            // This is kind of gross but need to handle two types of storage
            var maybePrefs = data.Get(userID);

            if (fromPriorData)
            {
                // Data are PreferenceArray

                IPreferenceArray prefs = (IPreferenceArray)maybePrefs;
                if (!hasTimestamp && String.IsNullOrWhiteSpace(preferenceValueString))
                {
                    // Then line is of form "userID,itemID,", meaning remove
                    if (prefs != null)
                    {
                        bool exists = false;
                        int  length = prefs.Length();
                        for (int i = 0; i < length; i++)
                        {
                            if (prefs.GetItemID(i) == itemID)
                            {
                                exists = true;
                                break;
                            }
                        }
                        if (exists)
                        {
                            if (length == 1)
                            {
                                data.Remove(userID);
                            }
                            else
                            {
                                IPreferenceArray newPrefs = new GenericUserPreferenceArray(length - 1);
                                for (int i = 0, j = 0; i < length; i++, j++)
                                {
                                    if (prefs.GetItemID(i) == itemID)
                                    {
                                        j--;
                                    }
                                    else
                                    {
                                        newPrefs.Set(j, prefs.Get(i));
                                    }
                                }
                                data.Put(userID, (T)newPrefs);
                            }
                        }
                    }

                    removeTimestamp(userID, itemID, timestamps);
                }
                else
                {
                    float preferenceValue = float.Parse(preferenceValueString, CultureInfo.InvariantCulture);

                    bool exists = false;
                    if (uniqueUserItemCheck && prefs != null)
                    {
                        for (int i = 0; i < prefs.Length(); i++)
                        {
                            if (prefs.GetItemID(i) == itemID)
                            {
                                exists = true;
                                prefs.SetValue(i, preferenceValue);
                                break;
                            }
                        }
                    }

                    if (!exists)
                    {
                        if (prefs == null)
                        {
                            prefs = new GenericUserPreferenceArray(1);
                        }
                        else
                        {
                            IPreferenceArray newPrefs = new GenericUserPreferenceArray(prefs.Length() + 1);
                            for (int i = 0, j = 1; i < prefs.Length(); i++, j++)
                            {
                                newPrefs.Set(j, prefs.Get(i));
                            }
                            prefs = newPrefs;
                        }
                        prefs.SetUserID(0, userID);
                        prefs.SetItemID(0, itemID);
                        prefs.SetValue(0, preferenceValue);
                        data.Put(userID, (T)prefs);
                    }
                }

                addTimestamp(userID, itemID, timestampString, timestamps);
            }
            else
            {
                // Data are IEnumerable<Preference>

                IEnumerable <IPreference> prefs = ((IEnumerable <IPreference>)maybePrefs);

                if (!hasTimestamp && String.IsNullOrWhiteSpace(preferenceValueString))
                {
                    // Then line is of form "userID,itemID,", meaning remove
                    if (prefs != null)
                    {
                        // remove pref
                        var prefsIterator = ((IEnumerable <IPreference>)prefs.ToArray()).GetEnumerator();
                        while (prefsIterator.MoveNext())
                        {
                            IPreference pref = prefsIterator.Current;
                            if (pref.GetItemID() == itemID)
                            {
                                if (prefs is IList <IPreference> )
                                {
                                    ((IList <IPreference>)maybePrefs).Remove(pref);// prefsIterator.remove()
                                }
                                break;
                            }
                        }
                    }

                    removeTimestamp(userID, itemID, timestamps);
                }
                else
                {
                    float preferenceValue = float.Parse(preferenceValueString, CultureInfo.InvariantCulture);

                    bool exists = false;
                    if (uniqueUserItemCheck && prefs != null)
                    {
                        foreach (IPreference pref in prefs)
                        {
                            if (pref.GetItemID() == itemID)
                            {
                                exists = true;
                                pref.SetValue(preferenceValue);
                                break;
                            }
                        }
                    }

                    if (!exists)
                    {
                        if (prefs == null)
                        {
                            prefs = new List <IPreference>(5);
                            data.Put(userID, (T)prefs);
                        }

                        if (prefs is IList <IPreference> )
                        {
                            ((IList <IPreference>)prefs).Add(new GenericPreference(userID, itemID, preferenceValue));
                        }
                    }

                    addTimestamp(userID, itemID, timestampString, timestamps);
                }
            }
        }