GrepImpl.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:17k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef GREP_IMPL_HPP
  14. #define GREP_IMPL_HPP
  15. #include "SignalData.hpp"
  16. #include <GrepError.hpp>
  17. #include <NodeBitmask.hpp>
  18. /*****************************************************************************
  19.  * GREP REQ   Request a Global Replication  (between SS and PS)
  20.  *****************************************************************************/
  21. /**
  22.  * @class GrepReq
  23.  * @brief
  24.  */
  25. class GrepReq 
  26. {
  27.   /**
  28.    * Sender(s)/Reciver(s)
  29.    */
  30.   friend class Grep;
  31. public:
  32.   enum Request {
  33.     START = 0,            ///< Start Global Replication (all phases)
  34.     SLOWSTOP = 1,       ///< Stop after finishing applying current GCI epoch
  35.     FASTSTOP = 2,       ///< Stop after finishing applying all PS GCI epochs
  36.     STATUS = 3,           ///< Status
  37.     REMOVE_BUFFERS = 4,   ///< Remove buffers from PS and SS
  38.     START_SUBSCR = 5,
  39.     START_METALOG = 6,    ///< Start Global Replication Logging of Metadata
  40.     START_METASCAN = 7,   ///< Start Global Replication Scanning of Metadata
  41.     START_DATALOG = 8,    ///< Start Global Replication Logging of table data
  42.     START_DATASCAN = 9,   ///< Start Global Replication Scanning of table data
  43.     START_REQUESTOR = 10, ///< Start Global Replication Requestor
  44.     START_TRANSFER = 11,  ///< Start SS-PS transfer
  45.     START_APPLY = 12,     ///< Start applying GCI epochs in SS
  46.     START_DELETE = 13,    ///< Start deleting buffers at PS/SS REP automatic.
  47.     STOP_SUBSCR = 14,     ///< Remove subscription
  48.     STOP_METALOG = 15,    ///< Stop Global Replication Logging of Metadata
  49.     STOP_METASCAN = 16,   ///< Stop Global Replication Scanning of Metadata
  50.     STOP_DATALOG = 17,    ///< Stop Global Replication Logging of table data
  51.     STOP_DATASCAN = 18,   ///< Stop Global Replication Scanning of table data
  52.     STOP_REQUESTOR = 19,  ///< Stop Global Replication Requestor
  53.     STOP_TRANSFER = 20,   ///< Stop SS-PS transfer
  54.     STOP_APPLY = 21,      ///< Stop applying GCI epochs in SS
  55.     STOP_DELETE = 22,     ///< Stop deleting buffers at PS/SS REP automatically
  56.     CREATE_SUBSCR = 23,   ///< Create subscription ID in SUMA
  57.     DROP_TABLE = 24,      ///< Create subscription ID in SUMA
  58.     STOP = 25,
  59.     NO_REQUEST = 0xffffffff
  60.   };
  61.   STATIC_CONST( SignalLength = 2 );
  62.   Uint32 senderRef;
  63.   Uint32 request;
  64. };
  65. /*****************************************************************************
  66.  * CREATE   Between SS and PS  (DB and REP nodes)
  67.  *****************************************************************************/
  68. /**
  69.  * @class GrepSubCreateReq
  70.  * @brief
  71.  */
  72. class GrepSubCreateReq 
  73. {
  74.   /**
  75.    * Sender(s)/Reciver(s)
  76.    */
  77.   friend class Grep;
  78.   
  79.   friend bool printGREP_SUB_CREATE_REQ(FILE *, 
  80.        const Uint32 *, 
  81.        Uint32, 
  82.        Uint16);
  83. public:
  84.   STATIC_CONST( SignalLength = 5 );
  85.   Uint32 subscriptionId;
  86.   Uint32 subscriptionKey;
  87.   Uint32 subscriptionType;
  88.   Uint32 senderRef;
  89.   Uint32 senderData;
  90.   SECTION( TABLE_LIST = 0 );  
  91. };
  92. /**
  93.  * @class GrepSubCreateReq
  94.  * @brief
  95.  */
  96. class GrepSubCreateRef 
  97. {
  98.   /**
  99.    * Sender(s)/Reciver(s)
  100.    */
  101.   friend class Grep;
  102.   
  103.   friend bool printGREP_SUB_CREATE_REF(FILE *, 
  104.        const Uint32 *, 
  105.        Uint32, 
  106.        Uint16);
  107. public:
  108.   STATIC_CONST( SignalLength = 6 );
  109.   Uint32 subscriptionId;
  110.   Uint32 subscriptionKey;
  111.   Uint32 subscriptionType;
  112.   Uint32 err;
  113.   Uint32 senderRef;
  114.   Uint32 senderData;
  115. };
  116. /**
  117.  * @class GrepSubCreateConf
  118.  * @brief
  119.  */
  120. class GrepSubCreateConf 
  121. {
  122.   /**
  123.    * Sender(s)/Reciver(s)
  124.    */
  125.   friend class Grep;
  126.   
  127.   friend bool printGREP_SUB_CREATE_CONF(FILE *, 
  128. const Uint32 *, 
  129. Uint32, 
  130. Uint16);
  131. public:
  132.   STATIC_CONST( SignalLength = 6 );
  133.   Uint32 subscriptionId;
  134.   Uint32 subscriptionKey;
  135.   Uint32 subscriptionType;
  136.   Uint32 senderRef;
  137.   Uint32 senderData;
  138.   Uint32 noOfNodeGroups;
  139. };
  140. /*****************************************************************************
  141.  * CREATE   Internal between PS DB nodes
  142.  *****************************************************************************/
  143. /**
  144.  * @class GrepCreateReq
  145.  * @brief
  146.  */
  147. class GrepCreateReq {
  148.   /**
  149.    * Sender(s)/Reciver(s)
  150.    */
  151.   friend class GrepParticipant;
  152.   
  153.   friend bool printGREP_CREATE_REQ(FILE *, 
  154.    const Uint32 *, 
  155.    Uint32, 
  156.    Uint16);
  157. public:
  158.   STATIC_CONST( SignalLength = 8 );
  159.   Uint32 senderRef;
  160.   Uint32 senderData;
  161.   Uint32 subscriberData;
  162.   Uint32 subscriberRef;
  163.   Uint32 subscriptionId;
  164.   Uint32 subscriptionKey;
  165.   Uint32 subscriptionType;
  166.   SECTION( TABLE_LIST = 0 );  
  167. };
  168. /**
  169.  * @class GrepCreateRef
  170.  * @brief
  171.  */
  172. class GrepCreateRef {
  173.   /**
  174.    * Sender(s)/Reciver(s)
  175.    */
  176.   friend class GrepParticipant;  
  177.   friend bool printGREP_CREATE_REF(FILE *, 
  178.    const Uint32 *, 
  179.    Uint32, 
  180.    Uint16);
  181. public:
  182.   enum ErrorCode {
  183.     NF_FakeErrorREF = GrepError::NF_FakeErrorREF
  184.   };
  185.   STATIC_CONST( SignalLength = 6 );
  186.   Uint32 senderRef;
  187.   Uint32 senderData;
  188.   union {
  189.     Uint32 err;
  190.     Uint32 errorCode;
  191.   };
  192.   Uint32 subscriptionId;
  193.   Uint32 subscriptionKey;
  194.   Uint32 subscriptionType;
  195. };
  196. /**
  197.  * @class GrepCreateConf
  198.  * @brief
  199.  */
  200. class GrepCreateConf {
  201.   /**
  202.    * Sender(s)/Reciver(s)
  203.    */
  204.   friend class GrepParticipant;
  205.   
  206.   friend bool printGREP_CREATE_CONF(FILE *, 
  207.    const Uint32 *, 
  208.    Uint32, 
  209.    Uint16);
  210. public:
  211.   STATIC_CONST( SignalLength = 6 );
  212.   Uint32 senderNodeId;
  213.   Uint32 senderRef;
  214.   Uint32 senderData;
  215.   Uint32 subscriptionId;
  216.   Uint32 subscriptionKey;
  217.   Uint32 subscriptionType;
  218. };
  219. /*****************************************************************************
  220.  * START   Between SS and PS  (DB and REP nodes)
  221.  *****************************************************************************/
  222. /**
  223.  * @class GrepSubStartReq
  224.  * @brief
  225.  */
  226. class GrepSubStartReq {
  227.   /**
  228.    * Sender(s)/Reciver(s)
  229.    */
  230.   friend class Grep;
  231.   
  232.   friend bool printGREP_SUB_START_REQ(FILE *, 
  233.    const Uint32 *, 
  234.    Uint32, 
  235.    Uint16);
  236. public:
  237.   STATIC_CONST( SignalLength = 5 );
  238.   Uint32 subscriptionId;
  239.   Uint32 subscriptionKey;
  240.   Uint32 senderRef;
  241.   Uint32 senderData;
  242.   Uint32 part;
  243. };
  244. /**
  245.  * @class GrepSubStartRef
  246.  * @brief
  247.  */
  248. class GrepSubStartRef {
  249.   /**
  250.    * Sender(s)/Reciver(s)
  251.    */
  252.   friend class Grep;
  253.   
  254.   friend bool printGREP_SUB_START_REF(FILE *, 
  255.    const Uint32 *, 
  256.    Uint32, 
  257.    Uint16);
  258. public:
  259.   STATIC_CONST( SignalLength = 6 );
  260.   Uint32 subscriptionId;
  261.   Uint32 subscriptionKey;
  262.   Uint32 err;
  263.   Uint32 senderRef;
  264.   Uint32 senderData;
  265.   Uint32 part;
  266. };
  267. /**
  268.  * @class GrepSubStartConf
  269.  * @brief
  270.  */
  271. class GrepSubStartConf {
  272.   /**
  273.    * Sender(s)/Reciver(s)
  274.    */
  275.   friend class Grep;
  276.   
  277.   friend bool printGREP_SUB_START_CONF(FILE *, 
  278.        const Uint32 *, 
  279.        Uint32, 
  280.        Uint16);
  281. public:
  282.   STATIC_CONST( SignalLength = 6 );
  283.   Uint32 subscriptionId;
  284.   Uint32 subscriptionKey;
  285.   Uint32 senderRef;
  286.   Uint32 senderData;
  287.   Uint32 part;
  288.   Uint32 firstGCI;
  289. };
  290. /*****************************************************************************
  291.  * START  Internal between PS DB nodes
  292.  *****************************************************************************/
  293. /**
  294.  * @class GrepStartReq
  295.  * @brief
  296.  */
  297. class GrepStartReq {
  298.   /**
  299.    * Sender(s)/Reciver(s)
  300.    */
  301.   friend class GrepParticipant;
  302.   
  303.   friend bool printGREP_START_REQ(FILE *, 
  304.    const Uint32 *, 
  305.    Uint32, 
  306.    Uint16);
  307. public:
  308.   STATIC_CONST( SignalLength = 4 );
  309.  
  310.   Uint32 senderData;
  311.   Uint32 part;
  312.   Uint32 subscriptionId;
  313.   Uint32 subscriptionKey;
  314. };
  315. /**
  316.  * @class GrepStartRef
  317.  * @brief
  318.  */
  319. class GrepStartRef {
  320.   /**
  321.    * Sender(s)/Reciver(s)
  322.    */
  323.   friend class GrepParticipant;  
  324.   friend bool printGREP_START_REF(FILE *, 
  325.   const Uint32 *, 
  326.   Uint32, 
  327.   Uint16);
  328. public:
  329.   enum ErrorCode {
  330.     NF_FakeErrorREF = GrepError::NF_FakeErrorREF
  331.   };
  332.   STATIC_CONST( SignalLength = 6 );
  333.   Uint32 senderRef;
  334.   Uint32 senderData;
  335.   Uint32 part;
  336.   Uint32 subscriptionId;
  337.   Uint32 subscriptionKey;
  338.   union {
  339.     Uint32 err;
  340.     Uint32 errorCode;
  341.   };
  342. };
  343. /**
  344.  * @class GrepStartConf
  345.  * @brief
  346.  */
  347. class GrepStartConf {
  348.    /**
  349.     * Sender(s)/Reciver(s)
  350.     */
  351.    
  352.    friend class GrepParticipant;
  353.    
  354.    friend bool printGREP_START_CONF(FILE *, 
  355.     const Uint32 *, 
  356.     Uint32, 
  357.     Uint16);
  358.  public:
  359.    STATIC_CONST( SignalLength = 7 );
  360.    
  361.    Uint32 senderRef;
  362.    Uint32 senderData;
  363.    Uint32 part;
  364.    Uint32 subscriptionId;
  365.    Uint32 subscriptionKey;
  366.    Uint32 firstGCI;
  367.    Uint32 senderNodeId;
  368.  };
  369. /*****************************************************************************
  370.  * SCAN (SYNC)  Between SS and PS (REP and DB nodes)
  371.  *****************************************************************************/
  372. /**
  373.  * @class GrepSubSyncReq
  374.  * @brief
  375.  */
  376. class GrepSubSyncReq {
  377.   /**
  378.    * Sender(s)/Reciver(s)
  379.    */
  380.   friend class Grep;
  381.   
  382.   friend bool printGREP_SUB_SYNC_REQ(FILE *, 
  383.      const Uint32 *, 
  384.      Uint32, 
  385.      Uint16);
  386. public:
  387.   STATIC_CONST( SignalLength = 5 );
  388.   Uint32 subscriptionId;
  389.   Uint32 subscriptionKey;
  390.   Uint32 senderRef;
  391.   Uint32 senderData;
  392.   Uint32 part;
  393. };
  394. /**
  395.  * @class GrepSubSyncRef
  396.  * @brief
  397.  */
  398. class GrepSubSyncRef {
  399.   /**
  400.    * Sender(s)/Reciver(s)
  401.    */
  402.   friend class Grep;
  403.   
  404.   friend bool printGREP_SUB_SYNC_REF(FILE *, 
  405.      const Uint32 *, 
  406.      Uint32, 
  407.      Uint16);
  408. public:
  409.   STATIC_CONST( SignalLength = 6 );
  410.   Uint32 subscriptionId;
  411.   Uint32 subscriptionKey;
  412.   Uint32 senderRef;
  413.   Uint32 err;
  414.   Uint32 senderData;
  415.   Uint32 part;
  416. };
  417. /**
  418.  * @class GrepSubSyncConf
  419.  * @brief
  420.  */
  421. class GrepSubSyncConf {
  422.    /**
  423.     * Sender(s)/Reciver(s)
  424.    */
  425.    friend class Grep;
  426.    
  427.    friend bool printGREP_SUB_SYNC_CONF(FILE *, 
  428.        const Uint32 *, 
  429.        Uint32, 
  430.        Uint16);
  431.  public:
  432.    STATIC_CONST( SignalLength = 7 );
  433.    Uint32 subscriptionId;
  434.    Uint32 subscriptionKey;
  435.    Uint32 senderRef;
  436.    Uint32 senderData;
  437.    Uint32 part;
  438.    Uint32 firstGCI;
  439.    Uint32 lastGCI;
  440. };
  441. /*****************************************************************************
  442.  * SCAN (SYNC)  Internal between PS DB nodes
  443.  *****************************************************************************/
  444. /**
  445.  * @class GrepSyncReq
  446.  * @brief
  447.  */
  448. class GrepSyncReq {
  449.   /**
  450.    * Sender(s)/Reciver(s)
  451.    */
  452.   friend class GrepParticipant;
  453.   
  454.   friend bool printGREP_SYNC_REQ(FILE *, 
  455.    const Uint32 *, 
  456.    Uint32, 
  457.    Uint16);
  458. public:
  459.   STATIC_CONST( SignalLength = 4 );
  460.  
  461.   Uint32 senderData;
  462.   Uint32 part;
  463.   Uint32 subscriptionId;
  464.   Uint32 subscriptionKey;
  465. };
  466. /**
  467.  * @class GrepSyncRef
  468.  * @brief
  469.  */
  470. class GrepSyncRef {
  471.   /**
  472.    * Sender(s)/Reciver(s)
  473.    */
  474.   friend class GrepParticipant;  
  475.   friend bool printGREP_SYNC_REF(FILE *, 
  476.  const Uint32 *, 
  477.  Uint32, 
  478.  Uint16);
  479. public:
  480.   enum ErrorCode {
  481.     NF_FakeErrorREF = GrepError::NF_FakeErrorREF
  482.   };
  483.   STATIC_CONST( SignalLength = 6 );
  484.   Uint32 senderRef;
  485.   Uint32 senderData;
  486.   Uint32 part;
  487.   Uint32 subscriptionId;
  488.   Uint32 subscriptionKey;
  489.   union {
  490.     Uint32 err;
  491.     Uint32 errorCode;
  492.   };
  493. };
  494. /**
  495.  * @class GrepSyncConf
  496.  * @brief
  497.  */
  498. class GrepSyncConf 
  499. {
  500.   /**
  501.    * Sender(s)/Reciver(s)
  502.    */
  503.   friend class GrepParticipant;
  504.   
  505.   friend bool printGREP_SYNC_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  506. public:
  507.   STATIC_CONST( SignalLength = 8 );
  508.   Uint32 senderRef;
  509.   Uint32 senderData;
  510.   Uint32 part;
  511.   Uint32 subscriptionId;
  512.   Uint32 subscriptionKey;
  513.   Uint32 senderNodeId;
  514.   Uint32 firstGCI;
  515.   Uint32 lastGCI;
  516. };
  517. /*****************************************************************************
  518.  * ABORT - remove subscription
  519.  *****************************************************************************/
  520. /**
  521.  * @class GrepSubRemoveReq
  522.  * @brief Between PS and SS
  523.  */
  524. class GrepSubRemoveReq {
  525.   /**
  526.    * Sender(s)/Reciver(s)
  527.    */
  528.   friend class Grep;
  529.   
  530.   friend bool printGREP_SUB_REMOVE_REQ(FILE *, const Uint32 *, 
  531.        Uint32, Uint16);
  532. public:
  533.   STATIC_CONST( SignalLength = 4 );
  534.   Uint32 senderRef;
  535.   Uint32 senderData;
  536.   Uint32 subscriptionId;
  537.   Uint32 subscriptionKey;
  538. };
  539. /**
  540.  * @class GrepSubRemoveRef
  541.  * @brief Between PS and SS
  542.  */
  543. class GrepSubRemoveRef {
  544.   /**
  545.    * Sender(s)/Reciver(s)
  546.    */
  547.   friend class Grep;
  548.   
  549.   friend bool printGREP_SUB_REMOVE_REF(FILE *, const Uint32 *, 
  550.        Uint32, Uint16);
  551. public:
  552.   STATIC_CONST( SignalLength = 5 );
  553.   Uint32 senderRef;
  554.   Uint32 senderData;
  555.   Uint32 subscriptionId;
  556.   Uint32 subscriptionKey;
  557.   Uint32 err;
  558. };
  559. /**
  560.  * @class 
  561.  * @brief
  562.  */
  563. class GrepSubRemoveConf {
  564.   /**
  565.    * Sender(s)/Reciver(s)
  566.    */
  567.   friend class Grep;
  568.   
  569.   friend bool printGREP_SUB_REMOVE_CONF(FILE *, 
  570.       const Uint32 *, 
  571.       Uint32, 
  572.       Uint16);
  573. public:
  574.   STATIC_CONST( SignalLength = 4 );
  575.   Uint32 senderRef;
  576.   Uint32 senderData;
  577.   Uint32 subscriptionId;
  578.   Uint32 subscriptionKey;
  579. };
  580. /**
  581.  * @class 
  582.  * @brief
  583.  */
  584. class GrepRemoveReq {
  585.   /**
  586.    * Sender(s)/Reciver(s)
  587.    */
  588.   friend class GrepParticipant;
  589.   
  590.   friend bool printGREP_REMOVE_REQ(FILE *, 
  591.    const Uint32 *, 
  592.    Uint32, 
  593.    Uint16);
  594. public:
  595.   STATIC_CONST( SignalLength = 4 );
  596.  
  597.   Uint32 senderRef;
  598.   Uint32 senderData;
  599.   Uint32 subscriptionId;
  600.   Uint32 subscriptionKey;
  601. };
  602. /**
  603.  * @class 
  604.  * @brief
  605.  */
  606. class GrepRemoveRef {
  607.   /**
  608.    * Sender(s)/Reciver(s)
  609.    */
  610.   friend class GrepParticipant;  
  611.   friend bool printGREP_REMOVE_REF(FILE *, 
  612.  const Uint32 *, 
  613.  Uint32, 
  614.  Uint16);
  615. public:
  616.   enum ErrorCode {
  617.     NF_FakeErrorREF = GrepError::NF_FakeErrorREF
  618.   };
  619.   STATIC_CONST( SignalLength = 5 );
  620.   Uint32 senderRef;
  621.   Uint32 senderData;
  622.   Uint32 subscriptionId;
  623.   Uint32 subscriptionKey;
  624.   union {
  625.     Uint32 err;
  626.     Uint32 errorCode;
  627.   };
  628. };
  629. /**
  630.  * @class 
  631.  * @brief
  632.  */
  633. class GrepRemoveConf {
  634.   /**
  635.    * Sender(s)/Reciver(s)
  636.    */
  637.   friend class GrepParticipant;
  638.   
  639.   friend bool printGREP_REMOVE_CONF(FILE *, 
  640.     const Uint32 *, 
  641.     Uint32, 
  642.     Uint16);
  643. public:
  644.   STATIC_CONST( SignalLength = 5 );
  645.   Uint32 senderRef;
  646.   Uint32 senderData; 
  647.   Uint32 subscriptionId;
  648.   Uint32 subscriptionKey;
  649.   Uint32 senderNodeId;
  650. };
  651. /*****************************************************************************
  652.  * WAIT FOR CGP
  653.  *****************************************************************************/
  654. /**
  655.  * @class GrepWaitGcpReq
  656.  * @brief
  657.  */
  658. class GrepWaitGcpReq {
  659.   /**
  660.    * Sender(s)/Reciver(s)
  661.    */
  662.   friend class GrepParticipant;
  663.   
  664.   friend bool printGREP_WAITGCP_REQ(FILE *, const Uint32 *, 
  665.     Uint32, Uint16);
  666. public:
  667.   STATIC_CONST( SignalLength = 5 );
  668.   
  669.   Uint32 senderData;
  670.   Uint32 gcp;
  671.   Uint32 subscriptionId;
  672.   Uint32 subscriptionKey;
  673.   Uint32 senderNodeId;
  674. };
  675. /**
  676.  * @class GrepWaitGcpConf
  677.  * @brief
  678.  */
  679. class GrepWaitGcpConf {
  680.   /**
  681.    * Sender(s)/Reciver(s)
  682.    */
  683.   friend class GrepParticipant;
  684.   
  685.   friend bool printGREP_WAITGCP_CONF(FILE *, 
  686.      const Uint32 *, 
  687.      Uint32, 
  688.      Uint16);
  689. public:
  690.   STATIC_CONST( SignalLength = 4 );
  691.   
  692.   Uint32 senderData;
  693.   Uint32 subscriptionId;
  694.   Uint32 subscriptionKey;
  695.   Uint32 senderNodeId;
  696. };
  697. class GrepCreateSubscriptionIdConf {
  698.   friend class Grep;
  699.   
  700.   friend bool printGREP_CREATE_SUBSCRIPTION_ID_CONF(FILE *, const Uint32 *, 
  701.        Uint32, Uint16);
  702. public:
  703.   STATIC_CONST( SignalLength = 3 );
  704.   
  705.   Uint32 subscriptionId;
  706.   Uint32 subscriptionKey;
  707.   union { // Haven't decide what to call it
  708.     Uint32 senderData;
  709.     Uint32 subscriberData;
  710.   };
  711. };
  712. class GrepStartMe {
  713.   friend class Grep;  
  714.   friend bool printGREP_START_ME(FILE *, const Uint32 *, 
  715.  Uint32, Uint16);
  716. public:
  717.   STATIC_CONST( SignalLength = 1 );
  718.   Uint32 senderRef;
  719. };
  720. /**
  721.  * @class GrepAddSubReq
  722.  * @brief
  723.  */
  724. class GrepAddSubReq {
  725.   /**
  726.    * Sender(s)/Reciver(s)
  727.    */
  728.   friend class GrepParticipant;
  729.   
  730.   friend bool printGREP_ADD_SUB_REQ(FILE *, 
  731.     const Uint32 *, 
  732.     Uint32, 
  733.     Uint16);
  734. public:
  735.   STATIC_CONST( SignalLength = 7 );
  736.   Uint32 senderRef;
  737.   Uint32 senderData;
  738.   Uint32 subscriberData;
  739.   Uint32 subscriberRef;
  740.   Uint32 subscriptionId;
  741.   Uint32 subscriptionKey;
  742.   Uint32 subscriptionType;
  743. };
  744. /**
  745.  * @class GrepAddSubRef
  746.  * @brief
  747.  */
  748. class GrepAddSubRef {
  749.   /**
  750.    * Sender(s)/Reciver(s)
  751.    */
  752.   friend class GrepParticipant;  
  753.   friend bool printGREP_CREATE_REF(FILE *, 
  754.    const Uint32 *, 
  755.    Uint32, 
  756.    Uint16);
  757. public:
  758.   STATIC_CONST( SignalLength = 5 );
  759.   Uint32 senderData;
  760.   Uint32 err;
  761.   Uint32 subscriptionId;
  762.   Uint32 subscriptionKey;
  763.   Uint32 subscriptionType;
  764. };
  765. /**
  766.  * @class GrepAddSubConf
  767.  * @brief
  768.  */
  769. class GrepAddSubConf {
  770.   /**
  771.    * Sender(s)/Reciver(s)
  772.    */
  773.   friend class GrepParticipant;
  774.   
  775.   friend bool printGREP_CREATE_CONF(FILE *, 
  776.    const Uint32 *, 
  777.    Uint32, 
  778.    Uint16);
  779. public:
  780.   STATIC_CONST( SignalLength = 1 );
  781.   Uint32 noOfSub;
  782. };
  783. #endif