/// -----------------------------------------------------------------
        /// <summary>
        /// </summary>
        /// -----------------------------------------------------------------
        protected void PurgeCache()
        {
            int now = Util.EnvironmentTickCount();

            if (Util.EnvironmentTickCountCompare(now, LastPurge) < PurgeInterval)
            {
                return;
            }

            List <UUID> purgelist = new List <UUID>();

            foreach (KeyValuePair <UUID, CapabilityInfo> kvp in CapabilityCollection)
            {
                int span    = kvp.Value.LifeSpan;
                int refresh = kvp.Value.LastRefresh;

                if (span > 0 && Util.EnvironmentTickCountCompare(now, refresh) > span)
                {
                    purgelist.Add(kvp.Key);
                }
            }

            foreach (UUID cap in purgelist)
            {
                CapabilityCollection.Remove(cap);
            }

            LastPurge = now;
        }
 /// -----------------------------------------------------------------
 /// <summary>
 /// </summary>
 /// -----------------------------------------------------------------
 public bool AddCapability(UUID cap, UserAccount acct, HashSet <String> dlist, String scene, int span)
 {
     lock (CapabilityCollection)
     {
         CapabilityInfo capinfo = new CapabilityInfo(cap, acct, dlist, scene, span);
         CapabilityCollection.Add(cap, capinfo);
         return(true);
     }
 }
 /// -----------------------------------------------------------------
 /// <summary>
 /// </summary>
 /// -----------------------------------------------------------------
 public bool RemoveCapability(UUID cap)
 {
     lock (CapabilityCollection)
     {
         if (CapabilityCollection.ContainsKey(cap))
         {
             CapabilityCollection.Remove(cap);
             return(true);
         }
     }
     return(false);
 }
        /// -----------------------------------------------------------------
        /// <summary>
        /// </summary>
        /// -----------------------------------------------------------------
        public bool UpdateCapability(UUID cap, int span)
        {
            lock (CapabilityCollection)
            {
                CapabilityInfo capinfo;
                if (!CapabilityCollection.TryGetValue(cap, out capinfo))
                {
                    return(false);
                }

                capinfo.LifeSpan    = span * 1000;
                capinfo.LastRefresh = Util.EnvironmentTickCount();

                return(true);
            }
        }
        /// -----------------------------------------------------------------
        /// <summary>
        /// </summary>
        /// -----------------------------------------------------------------
        public bool GetCapability(UUID cap, out UserAccount acct, out HashSet <String> dlist, out String scene)
        {
            lock (CapabilityCollection)
            {
                PurgeCache();

                CapabilityInfo capinfo;
                if (!CapabilityCollection.TryGetValue(cap, out capinfo))
                {
                    acct  = null;
                    dlist = null;
                    scene = String.Empty;
                    return(false);
                }

                acct  = capinfo.Account;
                dlist = capinfo.DomainList;
                scene = capinfo.SceneName;
                capinfo.LastRefresh = Util.EnvironmentTickCount();

                return(true);
            }
        }