1 files changed, 562 insertions, 0 deletions

diff --git a/OpenSim/Framework/Cache.cs b/OpenSim/Framework/Cache.cs
new file mode 100644
index 0000000..31cab4a
--- /dev/null
+++ b/OpenSim/Framework/Cache.cs
@@ -0,0 +1,562 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using OpenMetaverse;
+
+namespace OpenSim.Framework
+{
+    // The delegate we will use for performing fetch from backing store
+    //
+    public delegate Object FetchDelegate(string index);
+    public delegate bool ExpireDelegate(string index);
+
+    // Strategy
+    //
+    // Conservative = Minimize memory. Expire items quickly.
+    // Balanced = Expire items with few hits quickly.
+    // Aggressive = Keep cache full. Expire only when over 90% and adding
+    //
+    public enum CacheStrategy
+    {
+        Conservative = 0,
+        Balanced = 1,
+        Aggressive = 2
+    }
+
+    // Select classes to store data on different media
+    //
+    public enum CacheMedium
+    {
+        Memory = 0,
+        File = 1
+    }
+
+    public enum CacheFlags
+    {
+        CacheMissing = 1,
+        AllowUpdate = 2
+    }
+
+    // The base class of all cache objects. Implements comparison and sorting
+    // by the string member.
+    //
+    // This is not abstract because we need to instantiate it briefly as a
+    // method parameter
+    //
+    public class CacheItemBase : IEquatable<CacheItemBase>, IComparable<CacheItemBase>
+    {
+        public string uuid;
+        public DateTime entered;
+        public DateTime lastUsed;
+        public DateTime expires = new DateTime(0);
+        public int hits = 0;
+
+        public virtual Object Retrieve()
+        {
+            return null;
+        }
+
+        public virtual void Store(Object data)
+        {
+        }
+
+        public CacheItemBase(string index)
+        {
+            uuid = index;
+            entered = DateTime.Now;
+            lastUsed = entered;
+        }
+
+        public CacheItemBase(string index, DateTime ttl)
+        {
+            uuid = index;
+            entered = DateTime.Now;
+            lastUsed = entered;
+            expires = ttl;
+        }
+
+        public virtual bool Equals(CacheItemBase item)
+        {
+            return uuid == item.uuid;
+        }
+
+        public virtual int CompareTo(CacheItemBase item)
+        {
+            return uuid.CompareTo(item.uuid);
+        }
+
+        public virtual bool IsLocked()
+        {
+            return false;
+        }
+    }
+
+    // Simple in-memory storage. Boxes the object and stores it in a variable
+    //
+    public class MemoryCacheItem : CacheItemBase
+    {
+        private Object m_Data;
+
+        public MemoryCacheItem(string index) :
+            base(index)
+        {
+        }
+
+        public MemoryCacheItem(string index, DateTime ttl) :
+            base(index, ttl)
+        {
+        }
+
+        public MemoryCacheItem(string index, Object data) :
+            base(index)
+        {
+            Store(data);
+        }
+
+        public MemoryCacheItem(string index, DateTime ttl, Object data) :
+            base(index, ttl)
+        {
+            Store(data);
+        }
+
+        public override Object Retrieve()
+        {
+            return m_Data;
+        }
+
+        public override void Store(Object data)
+        {
+            m_Data = data;
+        }
+    }
+
+    // Simple persistent file storage
+    //
+    public class FileCacheItem : CacheItemBase
+    {
+        public FileCacheItem(string index) :
+            base(index)
+        {
+        }
+
+        public FileCacheItem(string index, DateTime ttl) :
+            base(index, ttl)
+        {
+        }
+
+        public FileCacheItem(string index, Object data) :
+            base(index)
+        {
+            Store(data);
+        }
+
+        public FileCacheItem(string index, DateTime ttl, Object data) :
+            base(index, ttl)
+        {
+            Store(data);
+        }
+
+        public override Object Retrieve()
+        {
+            //TODO: Add file access code
+            return null;
+        }
+
+        public override void Store(Object data)
+        {
+            //TODO: Add file access code
+        }
+    }
+
+    // The main cache class. This is the class you instantiate to create
+    // a cache
+    //
+    public class Cache
+    {
+        /// <summary>
+        /// Must only be accessed under lock.
+        /// </summary>
+        private List<CacheItemBase> m_Index = new List<CacheItemBase>();
+
+        /// <summary>
+        /// Must only be accessed under m_Index lock.
+        /// </summary>
+        private Dictionary<string, CacheItemBase> m_Lookup =
+            new Dictionary<string, CacheItemBase>();
+
+        private CacheStrategy m_Strategy;
+        private CacheMedium m_Medium;
+        private CacheFlags m_Flags = 0;
+        private int m_Size = 1024;
+        private TimeSpan m_DefaultTTL = new TimeSpan(0);
+        public ExpireDelegate OnExpire;
+
+        // Comparison interfaces
+        //
+        private class SortLRU : IComparer<CacheItemBase>
+        {
+            public int Compare(CacheItemBase a, CacheItemBase b)
+            {
+                if (a == null && b == null)
+                    return 0;
+                if (a == null)
+                    return -1;
+                if (b == null)
+                    return 1;
+
+                return(a.lastUsed.CompareTo(b.lastUsed));
+            }
+        }
+
+        // Convenience constructors
+        //
+        public Cache()
+        {
+            m_Strategy = CacheStrategy.Balanced;
+            m_Medium = CacheMedium.Memory;
+            m_Flags = 0;
+        }
+
+        public Cache(CacheMedium medium) :
+            this(medium, CacheStrategy.Balanced)
+        {
+        }
+
+        public Cache(CacheMedium medium, CacheFlags flags) :
+            this(medium, CacheStrategy.Balanced, flags)
+        {
+        }
+
+        public Cache(CacheMedium medium, CacheStrategy strategy) :
+            this(medium, strategy, 0)
+        {
+        }
+
+        public Cache(CacheStrategy strategy, CacheFlags flags) :
+            this(CacheMedium.Memory, strategy, flags)
+        {
+        }
+
+        public Cache(CacheFlags flags) :
+            this(CacheMedium.Memory, CacheStrategy.Balanced, flags)
+        {
+        }
+
+        public Cache(CacheMedium medium, CacheStrategy strategy,
+                CacheFlags flags)
+        {
+            m_Strategy = strategy;
+            m_Medium = medium;
+            m_Flags = flags;
+        }
+
+        // Count of the items currently in cache
+        //
+        public int Count
+        {
+            get { lock (m_Index) { return m_Index.Count; } }
+        }
+
+        // Maximum number of items this cache will hold
+        //
+        public int Size
+        {
+            get { return m_Size; }
+            set { SetSize(value); }
+        }
+
+        private void SetSize(int newSize)
+        {
+            lock (m_Index)
+            {
+                if (Count <= Size)
+                    return;
+
+                m_Index.Sort(new SortLRU());
+                m_Index.Reverse();
+
+                m_Index.RemoveRange(newSize, Count - newSize);
+                m_Size = newSize;
+
+                m_Lookup.Clear();
+
+                foreach (CacheItemBase item in m_Index)
+                    m_Lookup[item.uuid] = item;
+            }
+        }
+
+        public TimeSpan DefaultTTL
+        {
+            get { return m_DefaultTTL; }
+            set { m_DefaultTTL = value; }
+        }
+
+        // Get an item from cache. Return the raw item, not it's data
+        //
+        protected virtual CacheItemBase GetItem(string index)
+        {
+            CacheItemBase item = null;
+
+            lock (m_Index)
+            {
+                if (m_Lookup.ContainsKey(index))
+                    item = m_Lookup[index];
+
+                if (item == null)
+                {
+                    Expire(true);
+                    return null;
+                }
+    
+                item.hits++;
+                item.lastUsed = DateTime.Now;
+    
+                Expire(true);
+            }
+
+            return item;
+        }
+
+        // Get an item from cache. Do not try to fetch from source if not
+        // present. Just return null
+        //
+        public virtual Object Get(string index)
+        {
+            CacheItemBase item = GetItem(index);
+
+            if (item == null)
+                return null;
+
+            return item.Retrieve();
+        }
+
+        // Fetch an object from backing store if not cached, serve from
+        // cache if it is.
+        //
+        public virtual Object Get(string index, FetchDelegate fetch)
+        {
+            Object item = Get(index);
+            if (item != null)
+                return item;
+
+            Object data = fetch(index);
+            if (data == null)
+            {
+                if ((m_Flags & CacheFlags.CacheMissing) != 0)
+                {
+                    lock (m_Index)
+                    {
+                        CacheItemBase missing = new CacheItemBase(index);
+                        if (!m_Index.Contains(missing))
+                        {
+                            m_Index.Add(missing);
+                            m_Lookup[index] = missing;
+                        }
+                    }
+                }
+                return null;
+            }
+
+            Store(index, data);
+
+            return data;
+        }
+
+        // Find an object in cache by delegate.
+        //
+        public Object Find(Predicate<CacheItemBase> d)
+        {
+            CacheItemBase item;
+
+            lock (m_Index)
+                item = m_Index.Find(d);
+
+            if (item == null)
+                return null;
+
+            return item.Retrieve();
+        }
+
+        public virtual void Store(string index, Object data)
+        {
+            Type container;
+
+            switch (m_Medium)
+            {
+            case CacheMedium.Memory:
+                container = typeof(MemoryCacheItem);
+                break;
+            case CacheMedium.File:
+                return;
+            default:
+                return;
+            }
+
+            Store(index, data, container);
+        }
+
+        public virtual void Store(string index, Object data, Type container)
+        {
+            Store(index, data, container, new Object[] { index });
+        }
+
+        public virtual void Store(string index, Object data, Type container,
+                Object[] parameters)
+        {
+            CacheItemBase item;
+
+            lock (m_Index)
+            {
+                Expire(false);
+
+                if (m_Index.Contains(new CacheItemBase(index)))
+                {
+                    if ((m_Flags & CacheFlags.AllowUpdate) != 0)
+                    {
+                        item = GetItem(index);
+
+                        item.hits++;
+                        item.lastUsed = DateTime.Now;
+                        if (m_DefaultTTL.Ticks != 0)
+                            item.expires = DateTime.Now + m_DefaultTTL;
+
+                        item.Store(data);
+                    }
+                    return;
+                }
+
+                item = (CacheItemBase)Activator.CreateInstance(container,
+                        parameters);
+
+                if (m_DefaultTTL.Ticks != 0)
+                    item.expires = DateTime.Now + m_DefaultTTL;
+
+                m_Index.Add(item);
+                m_Lookup[index] = item;
+            }
+
+            item.Store(data);
+        }
+
+        /// <summary>
+        /// Expire items as appropriate.
+        /// </summary>
+        /// <remarks>
+        /// Callers must lock m_Index.
+        /// </remarks>
+        /// <param name='getting'></param>
+        protected virtual void Expire(bool getting)
+        {
+            if (getting && (m_Strategy == CacheStrategy.Aggressive))
+                return;
+
+            if (m_DefaultTTL.Ticks != 0)
+            {
+                DateTime now= DateTime.Now;
+
+                foreach (CacheItemBase item in new List<CacheItemBase>(m_Index))
+                {
+                    if (item.expires.Ticks == 0 ||
+                            item.expires <= now)
+                    {
+                        m_Index.Remove(item);
+                        m_Lookup.Remove(item.uuid);
+                    }
+                }
+            }
+
+            switch (m_Strategy)
+            {
+                case CacheStrategy.Aggressive:
+                    if (Count < Size)
+                        return;
+
+                    m_Index.Sort(new SortLRU());
+                    m_Index.Reverse();
+
+                    int target = (int)((float)Size * 0.9);
+                    if (target == Count) // Cover ridiculous cache sizes
+                        return;
+
+                    ExpireDelegate doExpire = OnExpire;
+
+                    if (doExpire != null)
+                    {
+                        List<CacheItemBase> candidates =
+                                m_Index.GetRange(target, Count - target);
+
+                        foreach (CacheItemBase i in candidates)
+                        {
+                            if (doExpire(i.uuid))
+                            {
+                                m_Index.Remove(i);
+                                m_Lookup.Remove(i.uuid);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        m_Index.RemoveRange(target, Count - target);
+
+                        m_Lookup.Clear();
+
+                        foreach (CacheItemBase item in m_Index)
+                            m_Lookup[item.uuid] = item;
+                    }
+
+                    break;
+
+                    default:
+                        break;
+            }
+        }
+
+        public void Invalidate(string uuid)
+        {
+            lock (m_Index)
+            {
+                if (!m_Lookup.ContainsKey(uuid))
+                    return;
+
+                CacheItemBase item = m_Lookup[uuid];
+                m_Lookup.Remove(uuid);
+                m_Index.Remove(item);
+            }
+        }
+
+        public void Clear()
+        {
+            lock (m_Index)
+            {
+                m_Index.Clear();
+                m_Lookup.Clear();
+            }
+        }
+    }
+}
\ No newline at end of file