Создайте класс шаблона на основе логического значения времени выполнения

Как я могу реализовать ниже? Я хотел бы «предварительно создать» 2 экземпляра класса шаблона «Doer» для логических значений. Я застрял с виртуалами? что было бы наиболее эффективным способом сделать что-то подобное? Я знаю о варианте повышения, но не уверен, что это лучше всего использовать? По сути, я хотел бы иметь 2 шаблона «Doer» для значений bool, так как разные члены doer будут выполнять разные действия в зависимости от значения bool.

struct Config
{
   int y;
};

template<typename DoerT>
class Aspect
{
   public:
         Aspect(bool b)
         {
            if(b) //can I create this way and pass around?
                _doer<true>(this);
            else 
                _doer<false>(this);
         }

         //will this work?
         DoerT doer() const { return _doer;}

   private:
     DoerT _doer;
};


template<typename ConfigT, bool b>
class Doer
{
  public:
    //how to create typedef for Aspect and objects that need "b"
        typedef Aspect<Doer<ConfigT,b> >* AspectT;

        //also can I then specialize member functions of OtherObject
        ///based on b?   There will be several other types here that
        //will need to perform tasks differently based on the bool.
        typedef OtherObject<ConfigT,b> OOT;

        Doer(AspectT asp) : _asp(asp) {}
        void doSomething(const Data& d) 
        {
        }

  private:
        AspectT _asp;
        OOT _obj;
};
//specialized members of Doer that need to behave differently based
//on bool..
template<Config,true>  template<> Doer::doSomething {..}
template<Config,false> template<> Doer::doSomething {..}



template<typename DoerT>
class Manager
{
   public:
         typedef Aspect<DoerT>* AspectPtr;

         void Load()
         {
            //retrieves data from database isNew returns bool
            Data dbData = GetDataFromDB();
            for(auto d : dbData)
            {
               //pass Boolean value to Aspect to create Doer templates
               rows[dbData.Name]= new AspectPtr<DoerT>(d.IsNew());
            }

         }
         AspectPtr Find(const std::string& name)
     {
    return rows[name];   
     }

  private:
        std::map<std::string,AspectPtr> rows;

};


class MXProcessor : Processor<Doer<Config, bool> > {...}


template<typename DoerT>
class Processor
{
   public:
      typedef Aspect<DoerT>* AspectPtr;
      typedef OtherObject1<DoerT>  obj1;
  typedef OtherObject2<DoerT>  obj2;
      void start()
      {
           _mgr.Load();
      } 
      void processData(const Data& d)
      {
            //lookup context row
            AspectPtr asp = _ctxMgr.Find(d.Name);
            asp->doer().doSomething(d);
      }

  private:
      Manager<DoerT>  _mgr;
      LogMgr<DoerT>  _lmgr;
};

int main() { //start MXProcessors}