DatasetExCollection2.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyCaffe.basecode;
 
namespace MyCaffe.db.image
{
    public class DatasetExCollection2 : IEnumerable<DatasetEx2>, IDisposable
    {
        List<DatasetEx2> m_rgDatasets = new List<DatasetEx2>();
        bool m_bUseTrainingSourcesForTesting = false;
        ImageSet2 m_lastImgSet = null;
        object m_syncObj = new object();
 
        public DatasetExCollection2()
        {
        }
 
        public bool RemoveDataset(DatasetEx2 ds)
        {
            return m_rgDatasets.Remove(ds);
        }
 
        public bool RemoveUser(Guid user)
        {
            bool bReleased = true;
 
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.RemoveUser(user) > 0)
                    bReleased = false;
            }
 
            return bReleased;
        }
 
        public bool SaveImageMean(int nSrcID, SimpleDatum sd, bool bUpdate)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.SaveImageMean(nSrcID, sd, bUpdate))
                    return true;
            }
 
            return false;
        }
 
        public SimpleDatum QueryImageMean(int nSrcID)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                SimpleDatum sd = ds.QueryImageMean(nSrcID);
                if (sd != null)
                    return sd;
            }
 
            return null;
        }
 
        public void Reset()
        {
            m_lastImgSet = null;
        }
 
        public void ReloadIndexing(int nDsId)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                    {
                        ds.ReloadIndexing();
                        return;
                    }
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = " + nDsId.ToString() + ".");
            }
        }
 
        public void ReloadIndexing(string strDs)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                    {
                        ds.ReloadIndexing();
                        return;
                    }
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs.ToString() + "'.");
            }
        }
 
        public void Relabel(LabelMappingCollection col)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                ds.Relabel(col);
            }
        }
 
        public int Count
        {
            get { return m_rgDatasets.Count; }
        }
 
        public void EnableUsingTrainingSourcesForTesting(bool bEnable)
        {
            m_bUseTrainingSourcesForTesting = bEnable;
 
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                ds.UseTrainingImagesForTesting = bEnable;
            }
        }
 
        public bool UseTrainingSourcesForTesting
        {
            get { return m_bUseTrainingSourcesForTesting; }
        }
 
        public DatasetEx2 this[int nIdx]
        {
            get { return m_rgDatasets[nIdx]; }
        }
 
        public DatasetEx2 FindDataset(int nDatasetID)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetID == nDatasetID)
                    return ds;
            }
 
            return null;
        }
 
        public DatasetEx2 FindDataset(string strDs)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetName == strDs)
                    return ds;
            }
 
            return null;
        }
 
        public DatasetEx2 FindDatasetFromSource(int nSrcId)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.Find(nSrcId) != null)
                    return ds;
            }
 
            return null;
        }
 
        public ImageSet2 FindImageset(int nSourceID)
        {
            lock (m_syncObj)
            {
                if (m_lastImgSet != null && m_lastImgSet.Source.ID == nSourceID)
                    return m_lastImgSet;
 
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    ImageSet2 imgSet = ds.Find(nSourceID);
 
                    if (imgSet != null)
                    {
                        m_lastImgSet = imgSet;
                        return imgSet;
                    }
                }
 
                throw new Exception("Could not find source with ID = " + nSourceID.ToString() + "!");
            }
        }
 
        public ImageSet2 FindImageset(string strSource)
        {
            lock (m_syncObj)
            {
                if (m_lastImgSet != null && m_lastImgSet.Source.Name == strSource)
                    return m_lastImgSet;
 
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    ImageSet2 imgSet = ds.Find(strSource);
 
                    if (imgSet != null)
                    {
                        m_lastImgSet = imgSet;
                        return imgSet;
                    }
                }
 
                throw new Exception("Could not find source with Name = " + strSource + "!");
            }
        }
 
        public bool WaitForDatasetToLoad(int nDsId, bool bTraining, bool bTesting, int nWait = int.MaxValue)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                        return ds.WaitForLoadingToComplete(bTraining, bTesting, nWait);
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = " + nDsId.ToString() + ".");
            }
        }
 
        public bool WaitForDatasetToLoad(string strDs, bool bTraining, bool bTesting, int nWait = int.MaxValue)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                        return ds.WaitForLoadingToComplete(bTraining, bTesting, nWait);
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
        public bool WaitForDatasetToRefresh(int nDsId, bool bTraining, bool bTesting, int nWait = int.MaxValue)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                        return ds.WaitForRefreshToComplete(bTraining, bTesting, nWait);
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = " + nDsId.ToString() + ".");
            }
        }
 
        public bool WaitForDatasetToRefresh(string strDs, bool bTraining, bool bTesting, int nWait = int.MaxValue)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                        return ds.WaitForRefreshToComplete(bTraining, bTesting, nWait);
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
        public bool IsRefreshRunning(int nDsId, bool bTraining, bool bTesting)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                        return ds.IsRefreshRunning(bTraining, bTesting);
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = '" + nDsId.ToString() + "'.");
            }
        }
 
        public bool IsRefreshRunning(string strDs, bool bTraining, bool bTesting)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                        return ds.IsRefreshRunning(bTraining, bTesting);
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
 
        public bool StartRefresh(string strDs, bool bTraining, bool bTesting, double dfReplacementPct)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                    {
                        ds.StartRefresh(bTraining, bTesting, dfReplacementPct);
                        return true;
                    }
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
        public bool StopRefresh(string strDs, bool bTraining, bool bTesting)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                    {
                        ds.StopRefresh(bTraining, bTesting);
                        return true;
                    }
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
        public bool StartRefresh(int nDsID, bool bTraining, bool bTesting, double dfReplacementPct)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsID)
                    {
                        ds.StartRefresh(bTraining, bTesting, dfReplacementPct);
                        return true;
                    }
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = '" + nDsID.ToString() + "'.");
            }
        }
 
        public bool StopRefresh(int nDsID, bool bTraining, bool bTesting)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsID)
                    {
                        ds.StopRefresh(bTraining, bTesting);
                        return true;
                    }
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = '" + nDsID.ToString() + "'.");
            }
        }
 
        public bool StartAutomaticRefreshSchedule(string strDs, bool bTraining, bool bTesting, int nPeriodInMs, double dfReplacementPct)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetName == strDs)
                {
                    return ds.StartAutomaticRefreshSchedule(bTraining, bTesting, nPeriodInMs, dfReplacementPct);
                }
            }
 
            throw new Exception("Failed to create a new query state for dataset name = '" + strDs + "'.");
        }
 
        public bool StopAutomaticRefreshSchedule(string strDs, bool bTraining, bool bTesting)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetName == strDs)
                {
                    return ds.StopAutomaticRefreshSchedule(bTraining, bTesting);
                }
            }
 
            throw new Exception("Failed to create a new query state for dataset name = '" + strDs + "'.");
        }
 
        public bool GetScheduledAutoRefreshInformation(string strDs, out int nPeriodInMs, out double dfReplacementPct, out int nTrainingRefreshCount, out int nTestingRefreshCount)
        {
            nPeriodInMs = 0;
            dfReplacementPct = 0;
            nTrainingRefreshCount = 0;
            nTestingRefreshCount = 0;
 
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetName == strDs)
                {
                    return ds.GetAutomaticRefreshSchedule(out nPeriodInMs, out dfReplacementPct, out nTrainingRefreshCount, out nTestingRefreshCount);
                }
            }
 
            throw new Exception("Failed to create a new query state for dataset name = '" + strDs + "'.");
        }
 
        public bool StartAutomaticRefreshSchedule(int nDsID, bool bTraining, bool bTesting, int nPeriodInMs, double dfReplacementPct)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetID == nDsID)
                {
                    return ds.StartAutomaticRefreshSchedule(bTraining, bTesting, nPeriodInMs, dfReplacementPct);
                }
            }
 
            throw new Exception("Failed to create a new query state for dataset ID = '" + nDsID.ToString() + "'.");
        }
 
        public bool StopAutomaticRefreshSchedule(int nDsID, bool bTraining, bool bTesting)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetID == nDsID || nDsID == 0)
                {
                    return ds.StopAutomaticRefreshSchedule(bTraining, bTesting);
                }
            }
 
            throw new Exception("Failed to create a new query state for dataset ID = '" + nDsID.ToString() + "'.");
        }
 
        public bool GetScheduledAutoRefreshInformation(int nDsID, out int nPeriodInMs, out double dfReplacementPct, out int nTrainingRefreshCount, out int nTestingRefreshCount)
        {
            nPeriodInMs = 0;
            dfReplacementPct = 0;
            nTrainingRefreshCount = 0;
            nTestingRefreshCount = 0;
 
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                if (ds.DatasetID == nDsID)
                {
                    return ds.GetAutomaticRefreshSchedule(out nPeriodInMs, out dfReplacementPct, out nTrainingRefreshCount, out nTestingRefreshCount);
                }
            }
 
            throw new Exception("Failed to create a new query state for dataset ID = '" + nDsID.ToString() + "'.");
        }
 
 
        public long CreateQueryState(int nDsId, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                        return ds.CreateQueryState(bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort);
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = " + nDsId.ToString() + ".");
            }
        }
 
        public long CreateQueryState(string strDs, bool bUseUniqueLabelIndexes = true, bool bUseUniqueImageIndexes = true, IMGDB_SORT sort = IMGDB_SORT.NONE)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                        return ds.CreateQueryState(bUseUniqueLabelIndexes, bUseUniqueImageIndexes, sort);
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
        public bool SetDefaultQueryState(int nDsId, long lQueryState)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                        return ds.SetDefaultQueryState(lQueryState);
                }
 
                throw new Exception("Failed to create a new query state for dataset ID = '" + nDsId.ToString() + "'.");
            }
        }
 
        public bool SetDefaultQueryState(string strDs, long lQueryState)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                        return ds.SetDefaultQueryState(lQueryState);
                }
 
                throw new Exception("Failed to create a new query state for dataset = '" + strDs + "'.");
            }
        }
 
        public bool FreeQueryState(int nDsId, long lHandle)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetID == nDsId)
                        return ds.FreeQueryState(lHandle);
                }
 
                return false;
            }
        }
 
        public bool FreeQueryState(string strDs, long lHandle)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    if (ds.DatasetName == strDs)
                        return ds.FreeQueryState(lHandle);
                }
 
                return false;
            }
        }
 
        public QueryState FindQueryState(long lQueryState, string strSource)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    ImageSet2 imgSet = ds.Find(strSource);
 
                    if (imgSet != null)
                        return ds.FindQueryState(lQueryState, imgSet.ImageSetType);
                }
 
                throw new Exception("Could not find query state for data source with Name = " + strSource + "!");
            }
        }
 
        public QueryState FindQueryState(long lQueryState, int nSrcId)
        {
            lock (m_syncObj)
            {
                foreach (DatasetEx2 ds in m_rgDatasets)
                {
                    ImageSet2 imgSet = ds.Find(nSrcId);
 
                    if (imgSet != null)
                        return ds.FindQueryState(lQueryState, imgSet.ImageSetType);
                }
 
                throw new Exception("Could not find query state for data source with ID = " + nSrcId.ToString() + "!");
            }
        }
 
        public void Add(DatasetEx2 ds)
        {
            m_rgDatasets.Add(ds);
        }
 
        protected virtual void Dispose(bool bDisposing)
        {
            foreach (DatasetEx2 ds in m_rgDatasets)
            {
                ds.Dispose();
            }
 
            m_rgDatasets.Clear();
        }
 
        public void Dispose()
        {
            Dispose(true);
        }
 
        public IEnumerator<DatasetEx2> GetEnumerator()
        {
            return m_rgDatasets.GetEnumerator();
        }
 
        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return m_rgDatasets.GetEnumerator();
        }
    }
}