sharp-oodb/index/SearchIndex.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using oodb.mapping;
using System.Linq;
using System.Collections;
namespace oodb.index
{
    public class SearchIndex : Index
    {

        Dictionary<string, ISet<Guid>> index = new Dictionary<string, ISet<Guid>>();
        Dictionary<Guid, string> reverseIndex = new Dictionary<Guid, string>();

        public SearchIndex(OODB oodb,FieldInfo fieldInfo)
            :base(oodb,fieldInfo)
        {
        }

        protected override void Prepare()
        {
            StorageMapping = OODB.GetFlatTypeMapping(typeof(string));
        }

        public ISet<Guid> GetBucket(string value)
        {
            if (!index.ContainsKey(value))
            {
                index.Add(value, new HashSet<Guid>());
            }
            return index[value];
        }

        public void Add(string value,Guid persistenceID)
        {
            if (reverseIndex.ContainsKey(persistenceID))
            {
                if (!reverseIndex[persistenceID].Equals(value))
                {
                    GetBucket(reverseIndex[persistenceID]).Remove(persistenceID);
                    GetBucket(value).Add(persistenceID);
                    reverseIndex[persistenceID] = value;
                }
            } else {
                reverseIndex[persistenceID] = value;
                GetBucket(value).Add(persistenceID);
            }
        }

        public override void Add(Persistent persistent)
        {
            Add(ValueMapping.ToText(FieldInfo.GetValue(persistent)), persistent.PersistenceID);
        }

        public override IEnumerable<Guid> Query()
        {
            return reverseIndex.Keys;
        }

        public IEnumerable<Guid> QueryTextValue(string textValue)
        {
            return GetBucket(textValue);
        }
        public IEnumerable<Guid> Query(object value)
        {
            return QueryTextValue(ValueMapping.ToText(value));
        }

        public IEnumerable<Guid> Query(Predicate predicate)
        {
            if (predicate.MatchesTextValues)
            {
                return reverseIndex.Where((kvp) => predicate.TextMatch(kvp.Value)).Select((kvp) => kvp.Key);
            } else
            {
                return reverseIndex.Where((kvp) => predicate.Match(ValueMapping.FromText(kvp.Value))).Select((kvp) => kvp.Key);
            }
        }

        public override void Remove(Guid persistenceID)
        {
            if (reverseIndex.ContainsKey(persistenceID))
            {
                GetBucket(reverseIndex[persistenceID]).Remove(persistenceID);
                reverseIndex.Remove(persistenceID);
            }
        }

        public override void RestoreIndexValues(IEnumerable<KeyValuePair<Guid, object>> indexValues)
        {
            reverseIndex.Clear();
            index.Clear();

            foreach (KeyValuePair<Guid,object> kvp in indexValues)
            {
                Add(kvp.Value as string, kvp.Key);
            }
        }

        public override IEnumerable<KeyValuePair<Guid, object>> RetrieveIndexValues()
        {
            return reverseIndex.Select((x) => new KeyValuePair<Guid, object>(x.Key, x.Value));
        }
    }
}