amps-python-client 5.3.4.1__zip → 5.3.4.3__zip

amps-python-client-5.3.4.1/src/cpp/include/amps/MessageRouter.hpp

@@ -1,618 +0,0 @@
-////////////////////////////////////////////////////////////////////////////
-//
-// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
-//
-// This computer software is owned by 60East Technologies Inc. and is
-// protected by U.S. copyright laws and other laws and by international
-// treaties.  This computer software is furnished by 60East Technologies
-// Inc. pursuant to a written license agreement and may be used, copied,
-// transmitted, and stored only in accordance with the terms of such
-// license agreement and with the inclusion of the above copyright notice.
-// This computer software or any other copies thereof may not be provided
-// or otherwise made available to any other person.
-//
-// U.S. Government Restricted Rights.  This computer software: (a) was
-// developed at private expense and is in all respects the proprietary
-// information of 60East Technologies Inc.; (b) was not developed with
-// government funds; (c) is a trade secret of 60East Technologies Inc.
-// for all purposes of the Freedom of Information Act; and (d) is a
-// commercial item and thus, pursuant to Section 12.212 of the Federal
-// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
-// Government's use, duplication or disclosure of the computer software
-// is subject to the restrictions set forth by 60East Technologies Inc..
-//
-////////////////////////////////////////////////////////////////////////////
-#ifndef _MESSAGEROUTER_HPP_
-#define _MESSAGEROUTER_HPP_
-#include <map>
-#include "amps/ampscrc.hpp"
-#include "amps/util.hpp"
-#include "amps/Message.hpp"
-
-namespace AMPS
-{
-/// Wrapper for callback functions in AMPS.
-/// Can be used to bind a function pointer with a void* to use as a callback,
-/// or if available, can wrap a std::function<Object> object, so you
-/// can supply the return value of std::bind, or even a lambda.
-  template <typename Func, typename Object>
-  class Handler
-  {
-  protected:
-    friend class MessageStream;
-    Func _func;
-    void* _userData;
-#ifdef AMPS_USE_FUNCTIONAL
-    std::function<void(Object)> _callable;
-#endif
-    bool _isValid;
-
-  public:
-    // No op function for handlers
-    static void noOpHandler(Object) {;}
-
-    typedef Func FunctionType;
-    ///
-    /// Null constructor -- no function is wrapped
-    Handler() : _func(NULL), _userData(NULL)
-#ifdef AMPS_USE_FUNCTIONAL
-      , _callable(Handler<Func, Object>::noOpHandler)
-#endif
-      , _isValid(false)
-    {
-    }
-
-    /// Constructor for use with a bare function pointer.
-    /// \param func_ The function pointer to bind.  func must be declared:j
-    ///             void myFunction(Object o, void* userData);
-    ///             for example, void myHandler(const Message&m, void *userData);
-    /// \param userData_ a value you'd like passed in when you're called.
-    Handler(Func func_, void* userData_)
-      : _func(func_), _userData(userData_)
-#ifdef AMPS_USE_FUNCTIONAL
-      , _callable(noOpHandler)
-#endif
-      , _isValid(true)
-    {
-    }
-
-    /// Copy constructor
-    /// \param orig_ The handler to copy
-    Handler(const Handler& orig_)
-      : _func(orig_._func), _userData(orig_._userData)
-#ifdef AMPS_USE_FUNCTIONAL
-      , _callable(orig_._callable)
-#endif
-      , _isValid(true)
-    {
-    }
-#ifdef AMPS_USE_FUNCTIONAL
-    /// Constructor for use with a standard c++ library function object
-    /// \param callback_ An object that can be assigned to a std::function
-    template <typename T>
-    Handler(const T& callback_)
-      : _func(NULL), _userData(NULL), _callable(callback_), _isValid(true)
-    {
-    }
-#endif
-    void invoke(Object message)
-    {
-      if (_func)
-      {
-        _func(message, _userData);
-      }
-#ifdef AMPS_USE_FUNCTIONAL
-      else
-      {
-        _callable(message);
-      }
-#endif
-    }
-
-    Handler& operator=(const Handler& rhs_)
-    {
-      if (this != &rhs_)
-      {
-        _func = rhs_._func;
-        _userData = rhs_._userData;
-#ifdef AMPS_USE_FUNCTIONAL
-        _callable = rhs_._callable;
-#endif
-        _isValid = rhs_._isValid;
-      }
-      return *this;
-    }
-
-    bool  isValid(void) const
-    {
-      return _isValid;
-    }
-    Func  function(void) const
-    {
-      return _func;
-    }
-    void* userData(void) const
-    {
-      return _userData;
-    }
-  };
-  class Message;
-///
-/// A function pointer type for message-handler functions.
-  typedef void(*MessageHandlerFunc)(const Message&, void* userData);
-
-  typedef Handler<MessageHandlerFunc, const Message&> MessageHandler;
-
-///
-/// This class multiplexes messages from AMPS to multiple subscribers
-/// and uses the stream of acks from AMPS to remove routes as appropriate.
-  class MessageRouter
-  {
-  private:
-    MessageHandler _emptyMessageHandler;
-    typedef amps_uint64_t (*CRCFunction)(const char*, size_t, amps_uint64_t);
-    // Function used to calculate the CRC if one is used
-    CRCFunction     _crc;
-
-    class MessageRoute
-    {
-      MessageHandler _messageHandler;
-      unsigned _requestedAcks, _systemAcks, _terminationAck;
-    public:
-      MessageRoute() : _requestedAcks(0), _systemAcks(0), _terminationAck(0) {;}
-      MessageRoute(const MessageRoute& rhs_) :
-        _messageHandler(rhs_._messageHandler),
-        _requestedAcks (rhs_._requestedAcks),
-        _systemAcks    (rhs_._systemAcks),
-        _terminationAck(rhs_._terminationAck)
-      {;}
-      const MessageRoute& operator=(const MessageRoute& rhs_)
-      {
-        _messageHandler = rhs_._messageHandler;
-        _requestedAcks  = rhs_._requestedAcks;
-        _systemAcks     = rhs_._systemAcks;
-        _terminationAck = rhs_._terminationAck;
-        return *this;
-      }
-      MessageRoute(MessageHandler messageHandler_, unsigned requestedAcks_,
-                   unsigned systemAcks_, bool isSubscribe_) :
-        _messageHandler(messageHandler_),
-        _requestedAcks(requestedAcks_),
-        _systemAcks(systemAcks_),
-        _terminationAck(0)
-      {
-        if (!isSubscribe_)
-        {
-          // The ack to terminate the route on is whatever the highest
-          // bit set in requestedAcks is.
-          unsigned bitCounter = (requestedAcks_ | systemAcks_) >> 1;
-          _terminationAck = 1;
-          while (bitCounter > 0)
-          {
-            bitCounter >>= 1;
-            _terminationAck <<= 1;
-          }
-        }
-      }
-
-      // Deliver an ack to registered handler if the ack type was requested
-      unsigned deliverAck(const Message& message_, unsigned ackType_)
-      {
-        if ( (_requestedAcks & ackType_) == 0)
-        {
-          return 0;
-        }
-        try
-        {
-          _messageHandler.invoke(message_);
-        }
-        catch (std::exception& ex)
-        {
-          std::cerr << ex.what() << std::endl;
-        }
-        return 1;
-      }
-      bool isTerminationAck(unsigned ackType_) const
-      {
-        return ackType_ == _terminationAck;
-      }
-      unsigned deliverData(const Message& message_)
-      {
-        _messageHandler.invoke(message_);
-        return 1;
-      }
-      const MessageHandler& getMessageHandler() const
-      {
-        return _messageHandler;
-      }
-      MessageHandler& getMessageHandler()
-      {
-        return _messageHandler;
-      }
-    };
-
-  public:
-    MessageRouter()
-      : _previousCommandId(0),
-        _lookupGenerationCount(0),
-        _generationCount(0)
-    {
-#ifndef AMPS_SSE_42
-      _crc = AMPS::CRC<0>::crcNoSSE;
-#else
-      if (AMPS::CRC<0>::isSSE42Enabled())
-      {
-        _crc = AMPS::CRC<0>::crc;
-      }
-      else
-      {
-        _crc = AMPS::CRC<0>::crcNoSSE;
-      }
-#endif
-    }
-
-    int addRoute(const Field& commandId_, const AMPS::MessageHandler& messageHandler_,
-                 unsigned requestedAcks_, unsigned systemAcks_, bool isSubscribe_)
-    {
-      Lock<Mutex> lock(_lock);
-      RouteMap::iterator i = _routes.find(commandId_);
-      if (i == _routes.end())
-      {
-        _routes[commandId_.deepCopy()] = MessageRoute(messageHandler_, requestedAcks_, systemAcks_, isSubscribe_);
-        return 1;
-      }
-      else
-      {
-        // Only replace a non-subscribe with a subscribe
-        if (isSubscribe_ && !i->second.isTerminationAck(0))
-        {
-          void* routeData = i->second.getMessageHandler().userData();;
-          i->second = MessageRoute(messageHandler_, requestedAcks_, systemAcks_, isSubscribe_);
-          if (routeData)
-          {
-            Unlock<Mutex> u(_lock);
-            amps_invoke_remove_route_function(routeData);
-          }
-          return 1;
-        }
-      }
-      return 0;
-    }
-
-    // returns true if a route was removed.
-    bool removeRoute(const Field& commandId_)
-    {
-      Lock<Mutex> lock(_lock);
-      RouteMap::iterator i = _routes.find(commandId_);
-      if (i == _routes.end())
-      {
-        return false;
-      }
-      return _removeRoute(i);
-    }
-
-    void clear()
-    {
-      AMPS_FETCH_ADD(&_generationCount, 1);
-      std::vector<void*> removeData;
-      {
-        Lock<Mutex> lock(_lock);
-        for (RouteMap::iterator i = _routes.begin(); i != _routes.end(); ++i)
-        {
-          // Make a non-const copy of Field and clear it, which will clear i
-          // as well but won't actually affect the map, which is unaware that
-          // the key's shared pointer has been deleted.
-          Field f = i->first;
-          void* data = i->second.getMessageHandler().userData();
-          removeData.push_back(data);
-          f.clear();
-        }
-        _routes.clear();
-      }
-      for (size_t i = 0; i < removeData.size(); ++i)
-      {
-        amps_invoke_remove_route_function(removeData[i]);
-      }
-    }
-
-    // Returns true if a route exists for a single id.
-    bool hasRoute(const Field& commandId_) const
-    {
-      Lock<Mutex> lock(_lock);
-      RouteMap::const_iterator it = _routes.find(commandId_);
-      return it != _routes.end();
-    }
-
-    // Find a single route and return true if here, setting result_ to the handler.
-    bool getRoute(const Field& commandId_, MessageHandler& result_) const
-    {
-      Lock<Mutex> lock(_lock);
-      RouteMap::const_iterator it = _routes.find(commandId_);
-      if (it != _routes.end())
-      {
-        result_ = it->second.getMessageHandler();
-        return true;
-      }
-      else
-      {
-        result_ = _emptyMessageHandler;
-        return false;
-      }
-    }
-
-    // RouteCache is the result type for a parseRoutes(); we do extra work
-    //   to avoid hitting the map or its lock when the subids field on
-    //   publish messages does not change.
-    struct RouteLookup
-    {
-      size_t         idOffset;
-      size_t         idLength;
-      MessageHandler handler;
-    };
-    class RouteCache : public std::vector<RouteLookup>
-    {
-      RouteCache(const RouteCache&);
-      void operator=(const RouteCache&);
-    public:
-      RouteCache(void)
-        : _generationCount(0),
-          _hashVal(0)
-      {;}
-
-      void invalidateCache(void)
-      {
-#if __cplusplus >= 201100L || _MSC_VER >= 1900
-        _generationCount.store(0);
-#else
-        _generationCount = 0;
-#endif
-        _hashVal = 0;
-        clear();
-      }
-#if __cplusplus >= 201100L || _MSC_VER >= 1900
-      void invalidateCache(const std::atomic<uint_fast64_t>& generationCount_, amps_uint64_t hashVal_)
-      {
-        _generationCount.store(generationCount_);
-#else
-      void invalidateCache(const AMPS_ATOMIC_TYPE& generationCount_, amps_uint64_t hashVal_)
-      {
-        _generationCount = generationCount_;
-#endif
-        _hashVal = hashVal_;
-        clear();
-      }
-
-#if __cplusplus >= 201100L || _MSC_VER >= 1900
-      bool isCacheHit(const std::atomic<uint_fast64_t>& generationCount_, amps_uint64_t hashVal_) const
-#else
-      bool isCacheHit(const AMPS_ATOMIC_TYPE& generationCount_, amps_uint64_t hashVal_) const
-#endif
-      {
-        return _generationCount == generationCount_ && _hashVal == hashVal_;
-      }
-
-    private:
-#if __cplusplus >= 201100L || _MSC_VER >= 1900
-      std::atomic<uint_fast64_t> _generationCount;
-#else
-      AMPS_ATOMIC_TYPE _generationCount;
-#endif
-      amps_uint64_t _hashVal;
-    };
-
-    // Parses the command id list into the route lookup vector and assigns
-    // the found handlers into the list. Only intended to be called by the
-    // message handler thread. Returns the number of command/sub IDs parsed.
-    size_t parseRoutes(const Field& commandIdList_, RouteCache& result_)
-    {
-      // Super shortcut: if the whole subID list is the same as the previous one,
-      // then assume the result_ contains all the right handlers already, and that
-      // the offsets and lengths of subIds are unchanged.
-      amps_uint64_t listHash = _crc(commandIdList_.data(), commandIdList_.len(), 0);
-      if (result_.isCacheHit(_generationCount, listHash))
-      {
-        return result_.size();
-      }
-      result_.invalidateCache(_generationCount, listHash);
-
-      // Lock required now that we'll be using the route map.
-      Lock<Mutex> lockGuard(_lock);
-      size_t resultCount = 0;
-      const char* pStart = commandIdList_.data();
-      for (const char* p = pStart, *e = commandIdList_.len() + pStart; p < e;
-           ++p, ++resultCount)
-      {
-        const char* delimiter = p;
-        while (delimiter != e && *delimiter != ',')
-        {
-          ++delimiter;
-        }
-        AMPS::Field subId(p, (size_t)(delimiter - p));
-#ifdef AMPS_USE_EMPLACE
-        result_.emplace_back(RouteLookup());
-#else
-        result_.push_back(RouteLookup());
-#endif
-        // Push back and then copy over fields; would emplace_back if available on
-        // all supported compilers.
-        RouteLookup& result = result_[resultCount];
-        result.idOffset = (size_t)(p - pStart);
-        result.idLength = (size_t)(delimiter - p);
-
-        RouteMap::const_iterator it = _routes.find(subId);
-        if (it != _routes.end())
-        {
-          result.handler = it->second.getMessageHandler();
-        }
-        else
-        {
-          result.handler = _emptyMessageHandler;
-        }
-        p = delimiter;
-      }
-      return resultCount;
-    }
-    unsigned deliverAck(const Message& ackMessage_, unsigned ackType_)
-    {
-      assert(ackMessage_.getCommand() == "ack");
-      unsigned messagesDelivered = 0;
-      Field key;
-
-      // Call _deliverAck, which will deliver to any waiting handlers
-      // AND remove the route if it's a termination ack
-      if (key = ackMessage_.getCommandId(), !key.empty())
-      {
-        messagesDelivered += _deliverAck(ackMessage_, ackType_, key);
-      }
-      if (key = ackMessage_.getQueryID(),
-          !key.empty() && messagesDelivered == 0)
-      {
-        messagesDelivered += _deliverAck(ackMessage_, ackType_, key);
-      }
-      if (key = ackMessage_.getSubscriptionId(),
-          !key.empty() && messagesDelivered == 0)
-      {
-        messagesDelivered += _deliverAck(ackMessage_, ackType_, key);
-      }
-      return messagesDelivered;
-    }
-
-    // deliverData may only be called by the message handler thread.
-    unsigned deliverData(const Message& dataMessage_, const Field& commandId_)
-    {
-      unsigned messagesDelivered = 0;
-      amps_uint64_t hval = _crc(commandId_.data(), commandId_.len(), 0);
-      if (_previousCommandId == hval &&
-          _lookupGenerationCount == _generationCount)
-      {
-        messagesDelivered += _previousHandler.deliverData(dataMessage_);
-      }
-      else
-      {
-        Lock<Mutex> lock(_lock);
-        RouteMap::iterator it = _routes.find(commandId_);
-        if (it != _routes.end())
-        {
-          _previousCommandId = hval;
-#if __cplusplus >= 201100L || _MSC_VER >= 1900
-          _lookupGenerationCount.store(_generationCount);
-#else
-          _lookupGenerationCount = _generationCount;
-#endif
-          _previousHandler = it->second;
-          messagesDelivered += it->second.deliverData(dataMessage_);
-        }
-      }
-      return messagesDelivered;
-    }
-
-    void invalidateCache(void)
-    {
-      _previousCommandId = 0;
-    }
-
-    void unsubscribeAll(void)
-    {
-      AMPS_FETCH_ADD(&_generationCount, 1);
-      std::vector<Field> removeIds;
-      std::vector<void*> removeData;
-      Lock<Mutex> lock(_lock);
-      for (RouteMap::iterator it = _routes.begin(); it != _routes.end(); ++it)
-      {
-        if (it->second.isTerminationAck(0))
-        {
-          removeIds.push_back(it->first);
-          removeData.push_back(it->second.getMessageHandler().userData());
-        }
-      }
-      for (size_t i = 0; i < removeIds.size(); ++i)
-      {
-        // it can't be end() b/c we have the lock and found id above
-        RouteMap::iterator it = _routes.find(removeIds[i]);
-        // Make a non-const copy of Field and clear it, which will clear i as well
-        Field f = it->first; // -V783
-        f.clear();
-        _routes.erase(it);
-      }
-      Unlock<Mutex> u(_lock);
-      for (size_t i = 0; i < removeData.size(); ++i)
-      {
-        amps_invoke_remove_route_function(removeData[i]);
-      }
-    }
-
-  private:
-    typedef std::map<Field, MessageRoute> RouteMap;
-    RouteMap _routes;
-    mutable Mutex _lock;
-
-    MessageRoute                       _previousHandler;
-    amps_uint64_t                      _previousCommandId;
-#if __cplusplus >= 201100L || _MSC_VER >= 1900
-    mutable std::atomic<uint_fast64_t> _lookupGenerationCount;
-    mutable std::atomic<uint_fast64_t> _generationCount;
-#else
-    mutable AMPS_ATOMIC_TYPE                _lookupGenerationCount;
-    mutable AMPS_ATOMIC_TYPE                _generationCount;
-#endif
-
-
-    // Deliver the ack to any waiting handlers
-    // AND remove the route if it's a termination ack
-    unsigned _deliverAck(const Message& ackMessage_, unsigned ackType_, Field& commandId_)
-    {
-      Lock<Mutex> lock(_lock);
-      unsigned messagesDelivered = 0;
-      RouteMap::iterator it = _routes.find(commandId_);
-      if (it != _routes.end())
-      {
-        MessageRoute& route = it->second;
-        messagesDelivered += route.deliverAck(ackMessage_, ackType_);
-        if (route.isTerminationAck(ackType_))
-        {
-          _removeRoute(it);
-          ++messagesDelivered;
-        }
-      }
-      return messagesDelivered;
-    }
-    unsigned _processAckForRemoval(unsigned ackType_, Field& commandId_)
-    {
-      Lock<Mutex> lock(_lock);
-      RouteMap::iterator it = _routes.find(commandId_);
-      if (it != _routes.end())
-      {
-        MessageRoute& route = it->second;
-        if (route.isTerminationAck(ackType_))
-        {
-          _removeRoute(it);
-          return 1U;
-        }
-      }
-      return 0U;
-    }
-
-    // returns true if a route was removed.
-    bool _removeRoute(RouteMap::iterator& it_)
-    {
-      // Called with lock already held
-      AMPS_FETCH_ADD(&_generationCount, 1);
-      // Make a non-const copy of Field and clear it, which will clear i as well
-      Field f = it_->first;
-      void* routeData = it_->second.getMessageHandler().userData();
-      _routes.erase(it_);
-      f.clear();
-      if (routeData)
-      {
-        Unlock<Mutex> u(_lock);
-        amps_invoke_remove_route_function(routeData);
-      }
-      return true;
-    }
-
-  };
-
-
-}
-
-#endif