ConnectionStrategy.hh

#ifndef __SUBSCRIPTIONSERVICE__CONNECTIONSTRATEGY_CONNECTIONSTRATEGY_HH__
#define __SUBSCRIPTIONSERVICE__CONNECTIONSTRATEGY_CONNECTIONSTRATEGY_HH__

#include <algorithm>
#include <accdevexception.hh>
#include "subscriptionservice/Description/DeviceDescriptor.hh"

namespace DeviceAccess
{
  namespace Subscription
  {
    namespace ConnectionStrategy
    {
      using ::DeviceAccess::Subscription::Description::DeviceDescriptor;

      class ConnStrat
      {
      public:
        virtual void checkConns(
          const std::vector<DeviceDescriptor>& dds,
          const std::vector<int>& idxs) const
          throw (AccDevException) = 0;

        virtual ~ConnStrat() {}
        
          static const AccDevException NOTCONNECTED;
      };

      class ThrowOnZeroConns : public ConnStrat
      {
      public:
        virtual void checkConns(
          const std::vector<DeviceDescriptor>& dds,
          const std::vector<int>& idxs) const
          throw (AccDevException)
          {
            if (idxs.size() == 0)
              throw NOTCONNECTED;
          }
      };

      class ThrowAlways : public ConnStrat
      {
      public:
        virtual void checkConns(
          const std::vector<DeviceDescriptor>& dds,
          const std::vector<int>& idxs) const
          throw (AccDevException)
          {
            if (idxs.size() < dds.size())
              throw NOTCONNECTED;
          }

      };

      class ThrowNever : public ConnStrat
      {
      public:
        virtual void checkConns(
          const std::vector<DeviceDescriptor>& dds,
          const std::vector<int>& idxs) const
          throw (AccDevException)
          {
          }
      };

      class ThrowOnIdx : public ConnStrat
      {
      private:
        std::vector<int> _idxs;

      public:
        ThrowOnIdx(const std::vector<int> idxs) :
          _idxs(idxs)
        {
        }

        virtual void checkConns(
          const std::vector<DeviceDescriptor>& dds,
          const std::vector<int>& idxs) const
          throw (AccDevException)
          {
            for (std::vector<int>::const_iterator it = _idxs.begin();
              it != _idxs.end(); it++)
              if (std::find(idxs.begin(), idxs.end(), *it) == idxs.end())
                throw NOTCONNECTED;
          }
      };

      class ThrowOnNomen : public ConnStrat
      {
      private:
        std::vector<string> _nomens;

      public:
        ThrowOnNomen(const std::vector<string> nomens) :
          _nomens(nomens)
        {
        }

        virtual void checkConns(
          const std::vector<DeviceDescriptor>& dds,
          const std::vector<int>& idxs) const
          throw (AccDevException)
        {
          for (std::vector<string>::const_iterator it = _nomens.begin();
            it != _nomens.end(); it++)
            if (std::find_if(idxs.begin(), idxs.end(),
              TestNomen(*it, dds))
              == idxs.end())
            {
              throw NOTCONNECTED;
            }
        }

      private:
        struct TestNomen {
            std::string _nomen;
            const std::vector<DeviceDescriptor>& _dds;

            TestNomen(
              const std::string& nomen,
              const std::vector<DeviceDescriptor>& dds) :
              _nomen(nomen),
              _dds(dds) {}

            bool operator()(int i)
            {
              return _nomen == _dds[i].device->nomen();
            }
          };
      };
    }
  }
}

#endif

---