FeedingFanOut.h

/*
 * FeedingFanOut.h
 *
 *  Created on: Jun 15, 2016
 *      Author: Martin Hierholzer
 */

#ifndef CHIMERATK_FEEDING_FAN_OUT_H
#define CHIMERATK_FEEDING_FAN_OUT_H

#include <ChimeraTK/NDRegisterAccessor.h>

#include "FanOut.h"

namespace ChimeraTK {

  /**
   * NDRegisterAccessor implementation which distributes values written to this accessor out to any number of slaves.
   */
  template<typename UserType>
  class FeedingFanOut : public FanOut<UserType>, public ChimeraTK::NDRegisterAccessor<UserType> {

    public:

      FeedingFanOut(std::string const &name, std::string const &unit, std::string const &description,
                    size_t numberOfElements, bool withReturn)
      : FanOut<UserType>(boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>>()),
        ChimeraTK::NDRegisterAccessor<UserType>("FeedingFanOut:"+name, unit, description),
        _withReturn(withReturn)
      {
        ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D.resize(1);
        ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D[0].resize(numberOfElements);
      }

      /** Add a slave to the FanOut. Only sending end-points of a consuming node may be added. */
      void addSlave(boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>> slave, VariableNetworkNode&) override {

        // check if array shape is compatible, unless the receiver is a trigger node, so no data is expected
        if( slave->getNumberOfSamples() != 0 &&
            ( slave->getNumberOfChannels() != 1 || slave->getNumberOfSamples() != this->getNumberOfSamples() ) ) {
          std::string what = "FeedingFanOut::addSlave(): Trying to add a slave '" + slave->getName();
          what += "' with incompatible array shape! Name of fan out: '" + this->getName() + "'";
          throw ChimeraTK::logic_error(what.c_str());
        }

        // make sure slave is writeable
        if(!slave->isWriteable()) {
          throw ChimeraTK::logic_error("FeedingFanOut::addSlave() has been called with a receiving implementation!");
        }

        // handle return channels
        if(_withReturn) {
          if(slave->isReadable()) {
            if(_hasReturnSlave) {
              throw ChimeraTK::logic_error("FeedingFanOut: Cannot add multiple slaves with return channel!");
            }
            _hasReturnSlave = true;
            _returnSlave = slave;
          }
        }

        // add the slave
        FanOut<UserType>::slaves.push_back(slave);
      }

      bool isReadable() const override {
        return _withReturn;
      }

      bool isReadOnly() const override {
        return false;
      }

      bool isWriteable() const override {
        return true;
      }

      void doReadTransfer() override {
        if(!_withReturn) throw ChimeraTK::logic_error("Read operation called on write-only variable.");
        _returnSlave->doReadTransfer();
      }

      bool doReadTransferNonBlocking() override {
        if(!_withReturn) throw ChimeraTK::logic_error("Read operation called on write-only variable.");
        return _returnSlave->doReadTransferNonBlocking();
      }

      bool doReadTransferLatest() override {
        if(!_withReturn) throw ChimeraTK::logic_error("Read operation called on write-only variable.");
        return _returnSlave->doReadTransferLatest();
      }

      void doPreRead() override {
        if(!_withReturn) throw ChimeraTK::logic_error("Read operation called on write-only variable.");
        _returnSlave->accessChannel(0).swap(ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D[0]);
        _returnSlave->preRead();
      }

      void doPostRead() override {
        if(!_withReturn) throw ChimeraTK::logic_error("Read operation called on write-only variable.");
        assert(_hasReturnSlave);
        _returnSlave->postRead();
        _returnSlave->accessChannel(0).swap(ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D[0]);
        // distribute return-channel update to the other slaves
        for(auto &slave : FanOut<UserType>::slaves) {     // send out copies to slaves
          if(slave == _returnSlave) continue;
          if(slave->getNumberOfSamples() != 0) {          // do not send copy if no data is expected (e.g. trigger)
            slave->accessChannel(0) = ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D[0];
          }
          slave->write(_returnSlave->getVersionNumber());
        }

      }

      ChimeraTK::TransferFuture doReadTransferAsync() override {
        if(!_withReturn) throw ChimeraTK::logic_error("Read operation called on write-only variable.");
        return {_returnSlave->doReadTransferAsync(), this};
      }

      void doPreWrite() override {
        for(auto &slave : FanOut<UserType>::slaves) {     // send out copies to slaves
          if(slave->getNumberOfSamples() != 0) {          // do not send copy if no data is expected (e.g. trigger)
            if(slave == FanOut<UserType>::slaves.front()) {     // in case of first slave, swap instead of copy
              slave->accessChannel(0).swap(ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D[0]);
            }
            else {                                // not the first slave: copy the data from the first slave
              slave->accessChannel(0) = FanOut<UserType>::slaves.front()->accessChannel(0);
            }
          }
        }
        // pre write may only be called on the target accessors after we have filled them all, otherwise the first
        // accessor might take us the data away...
        for(auto &slave : FanOut<UserType>::slaves) {
          slave->preWrite();
        }
      }

      bool doWriteTransfer(ChimeraTK::VersionNumber versionNumber={}) override {
        bool dataLost = false;
        for(auto &slave : FanOut<UserType>::slaves) {
          bool ret = slave->doWriteTransfer(versionNumber);
          if(ret) dataLost = true;
        }
        return dataLost;
      }

      void doPostWrite() override {
        for(auto &slave : FanOut<UserType>::slaves) {
          slave->postWrite();
        }
        FanOut<UserType>::slaves.front()->accessChannel(0).swap(ChimeraTK::NDRegisterAccessor<UserType>::buffer_2D[0]);
      }

      bool mayReplaceOther(const boost::shared_ptr<const ChimeraTK::TransferElement>&) const override {
        return false;   /// @todo implement properly?
      }

      std::list<boost::shared_ptr<ChimeraTK::TransferElement> > getInternalElements() override {
        return {};    /// @todo implement properly?
      }

      std::vector<boost::shared_ptr<ChimeraTK::TransferElement> > getHardwareAccessingElements() override {
        return { boost::enable_shared_from_this<ChimeraTK::TransferElement>::shared_from_this() }; /// @todo implement properly?
      }

      void replaceTransferElement(boost::shared_ptr<ChimeraTK::TransferElement>) override {
        // You can't replace anything here. Just do nothing.
        /// @todo implement properly?
      }

      AccessModeFlags getAccessModeFlags() const override { return {AccessMode::wait_for_new_data}; }

      VersionNumber getVersionNumber() const override { return FanOut<UserType>::slaves.front()->getVersionNumber(); }

      boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>> getReturnSlave() {
        return _returnSlave;
      }

    protected:

      /// Flag whether this FeedingFanOut has a return channel. Is specified in the constructor
      bool _withReturn;

      /// Used if _withReturn is true: flag whether the corresponding slave with the return channel has already been
      /// added.
      bool _hasReturnSlave{false};

      /// The slave with return channel
      boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>> _returnSlave;

  };

} /* namespace ChimeraTK */

#endif /* CHIMERATK_FEEDING_FAN_OUT_H */