text: // Copyright (c) 2010 Satoshi Nakamoto
  // Copyright (c) 2009-2013 The Bitcoin developers
  // Copyright (c) 2017 The SDC developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
  
  #ifndef BITCOIN_ALERT_H
  #define BITCOIN_ALERT_H
  
  #include "serialize.h"
  #include "sync.h"
  
  #include <map>
  #include <set>
  #include <stdint.h>
  #include <string>
  
  class CAlert;
  class CNode;
  class uint256;
  
  extern std::map<uint256, CAlert> mapAlerts;
  extern CCriticalSection cs_mapAlerts;
  
  /** Alerts are for notifying old versions if they become too obsolete and
   * need to upgrade.  The message is displayed in the status bar.
   * Alert messages are broadcast as a vector of signed data.  Unserializing may
   * not read the entire buffer if the alert is for a newer version, but older
   * versions can still relay the original data.
   */
  class CUnsignedAlert
  {
  public:
      int nVersion;
      int64_t nRelayUntil; // when newer nodes stop relaying to newer nodes
      int64_t nExpiration;
      int nID;
      int nCancel;
      std::set<int> setCancel;
      int nMinVer;                     // lowest version inclusive
      int nMaxVer;                     // highest version inclusive
      std::set<std::string> setSubVer; // empty matches all
      int nPriority;
  
      // Actions
      std::string strComment;
      std::string strStatusBar;
      std::string strReserved;
  
      ADD_SERIALIZE_METHODS;
  
      template <typename Stream, typename Operation>
      inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
      {
          READWRITE(this->nVersion);
          nVersion = this->nVersion;
          READWRITE(nRelayUntil);
          READWRITE(nExpiration);
          READWRITE(nID);
          READWRITE(nCancel);
          READWRITE(setCancel);
          READWRITE(nMinVer);
          READWRITE(nMaxVer);
          READWRITE(setSubVer);
          READWRITE(nPriority);
  
          READWRITE(LIMITED_STRING(strComment, 65536));
          READWRITE(LIMITED_STRING(strStatusBar, 256));
          READWRITE(LIMITED_STRING(strReserved, 256));
      }
  
      void SetNull();
  
      std::string ToString() const;
  };
  
  /** An alert is a combination of a serialized CUnsignedAlert and a signature. */
  class CAlert : public CUnsignedAlert
  {
  public:
      std::vector<unsigned char> vchMsg;
      std::vector<unsigned char> vchSig;
  
      CAlert()
      {
          SetNull();
      }
  
      ADD_SERIALIZE_METHODS;
  
      template <typename Stream, typename Operation>
      inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion)
      {
          READWRITE(vchMsg);
          READWRITE(vchSig);
      }
  
      void SetNull();
      bool IsNull() const;
      uint256 GetHash() const;
      bool IsInEffect() const;
      bool Cancels(const CAlert& alert) const;
      bool AppliesTo(int nVersion, std::string strSubVerIn) const;
      bool AppliesToMe() const;
      bool RelayTo(CNode* pnode) const;
      bool CheckSignature() const;
      bool ProcessAlert(bool fThread = true); // fThread means run -alertnotify in a free-running thread
      static void Notify(const std::string& strMessage, bool fThread);
  
      /*
       * Get copy of (active) alert object by hash. Returns a null alert if it is not found.
       */
      static CAlert getAlertByHash(const uint256& hash);
  };
  
  #endif // BITCOIN_ALERT_H
  