indexChooserFeatureSet.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright (c) 2015 MAK Technologies, Inc.
 * All rights reserved.
 ******************************************************************************/


#pragma  once

#include <features/featureSetWrappers.h>
#include <features/attributeIndexingFeatureSet.h>

namespace MAKVRinTerra
{
   template <typename FS>
   class DtIndexChooserFeatureSet : public FS
   {
   public:
      typedef typename FS::Feature         Feature;
      typedef typename FS::ForEachFunction ForEachFunction;
      typedef typename FS::LoadedCallback  LoadedCallback;
      typedef typename FS::DetachCallback  DetachCallback;

      typedef boost::shared_ptr<DtIndexChooserFeatureSet> Ptr;

      static FS* Make(FS* input, FS* mainIndex)
      {
         return new DtIndexChooserFeatureSet(input, mainIndex);
      }

      std::string label() const { return myInput->label() + " index chooser"; }

      unsigned numberOfFeatures() const
      {
         unsigned tot = myMainIndex->numberOfFeatures();

         Mutex::scoped_lock lock(myData->myMutex, false);
         for (typename Data::const_iterator i=myData->begin(), end=myData->end(); i!=end; ++i)
            tot += i->second->numberOfFeatures();

         return tot;
      }

      bool elided() const
      {
         if (!myMainIndex->elided())
            return false;

         Mutex::scoped_lock lock(myData->myMutex, false);
         for (typename Data::const_iterator i=myData->begin(), end=myData->end(); i!=end; ++i)
            if (!i->second->elided())
               return false;

         return true;
      }

      bool empty() const
      {
         if (!myMainIndex->empty())
            return false;

         Mutex::scoped_lock lock(myData->myMutex, false);
         for (typename Data::const_iterator i=myData->begin(), end=myData->end(); i!=end; ++i)
            if (!i->second->empty())
               return false;

         return true;
      }

      bool isIndexed() const
      {
         return true;
      }

      bool isCacheable(const boost::optional<DtFeatureGeometry>& area) const
      {
         return myMainIndex->isCacheable(area);
      }

      void cacheEstimate(double& time, double& size, const boost::optional<DtFeatureGeometry>& area) const
      {
         myMainIndex->cacheEstimate(time, size, area);
      }

      void cacheData(
         const boost::optional<DtFeatureGeometry>& area,
         DtFeatureCacheProgressCallback* progress) const
      {
         myMainIndex->cacheData(area, progress);
      }

      bool loaded(double timeout=0.0) const
      {
         tbb::tick_count start = tbb::tick_count::now();

         if (!myMainIndex->loaded(timeout))
            return false;

         Mutex::scoped_lock lock(myData->myMutex, false);
         for (typename Data::const_iterator i=myData->begin(), end=myData->end(); i!=end; ++i)
         {
            double whatsleft = timeout - (tbb::tick_count::now() - start).seconds();
            if (whatsleft < 0)
               whatsleft = 0;

            if (!i->second->loaded(whatsleft))
               return false;
         }

         return true;
      }

      FS* clone() const
      {
         return new DtIndexChooserFeatureSet(*this);
      }

      DetachCallback addLoadedCallback(const LoadedCallback& cb) const
      {
         return myMainIndex->addLoadedCallback(cb);
      }

      struct Caller
      {
         void operator()(const Feature& feature) const
         {
            if (query.matches(feature))
               func(feature);
         }

         Caller(const ForEachFunction& func, const DtQuery& query)
            : func(func), query(query)
         {
         }

      private:
         ForEachFunction func;
         DtQuery query;
      };

      void forEachFeatureParallel(const ForEachFunction& func) const
      {
         Caller caller(func, myFilteredAttributes);
         myMainIndex->forEachFeatureParallel(caller);
      }

      DetachCallback forEachFeatureAsync(const ForEachFunction& func) const
      {
         Caller caller(func, myFilteredAttributes);
         return myMainIndex->forEachFeatureAsync(caller);
      }

      FS* filter(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geometry,
         DtLoadType load) const
      {
         DtQuery combined = myFilteredAttributes && query;

         if (geometry)
            return myMainIndex->filter(combined, geometry, load);

         if (!query.isTrue())
         {
            std::auto_ptr<FS> filterTest(myInput->filter(combined, geometry, DO_NOT_LOAD));
            if (DtIsElided(filterTest.get()))
               return 0;
         }

         if (load == DO_NOT_LOAD)
            return new DtIndexChooserFeatureSet(*this, combined);

         DtWarn << "Query = " << query << std::endl;
         DtWarn << "Previous query = " << myFilteredAttributes << std::endl;
         DtWarn << "Combined = " << combined << std::endl;

         if (const DtHasAttribute* attr = query.trycast<DtHasAttribute>())
         {
            Mutex::scoped_lock lock(myData->myMutex, true);
            typename Data::const_iterator i = myData->myIndexMap.find(attr->key());
            if (i != myData->myIndexMap.end())
            {
               DtInfo << "Using feature attribute index on key " << attr->key() << std::endl;
               return i->second->filter(combined, geometry, load);
            }

            typedef DtAttributeIndexingFeatureSet<FS> AttributeIndex;
            typedef typename AttributeIndex::Config AttributeConfig;

            std::auto_ptr<FS> set(AttributeIndex::Make(
               new AttributeConfig(myInput->filter(true, LOAD), attr->key())));

            DtInfo << "Creating feature attribute index on key " << attr->key() << std::endl;
            std::auto_ptr<FS> ret(set->filter(combined, geometry, load));

            myData->myIndexMap.insert(attr->key(), set.release());
            return ret.release();
         }

         return myMainIndex->filter(combined, geometry, load);
      }

   private:
      explicit DtIndexChooserFeatureSet(FS* input, FS* mainIndex)
         : myInput(input)
         , myMainIndex(mainIndex)
         , myData(new Data())
         , myFilteredAttributes(true)
      {
      }

      explicit DtIndexChooserFeatureSet(
         const DtIndexChooserFeatureSet& from, const DtQuery& combined)
         : myInput(from.myInput)
         , myMainIndex(from.myMainIndex)
         , myData(from.myData)
         , myFilteredAttributes(combined)
      {
      }

      explicit DtIndexChooserFeatureSet(const DtIndexChooserFeatureSet& from)
         : myInput(from.myInput)
         , myMainIndex(from.myMainIndex)
         , myData(from.myData)
         , myFilteredAttributes(from.myFilteredAttributes)
      {
      }

      typedef tbb::queuing_rw_mutex Mutex;

      const boost::shared_ptr<FS> myInput;
      const boost::shared_ptr<FS> myMainIndex;

      struct Data
      {
         typedef boost::ptr_map<const DtFeature::Key, FS> Map;
         typedef typename Map::const_iterator const_iterator;

         const_iterator begin() const { return myIndexMap.begin(); }
         const_iterator end() const { return myIndexMap.end(); }

         mutable Mutex myMutex;
         Map myIndexMap;
      };

      const boost::shared_ptr<Data> myData;
      DtQuery myFilteredAttributes;
   };
}