release/src/router/mysql/storage/ndb/include/kernel/signaldata/CreateEvnt.hpp

   1 /* Copyright (c) 2003-2006 MySQL AB
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
  15
  16 #ifndef CREATE_EVNT_HPP
  17 #define CREATE_EVNT_HPP
  18
  19 #include <ndberror.h>
  20 #include "SignalData.hpp"
  21 #include <NodeBitmask.hpp>
  22 #include <signaldata/DictTabInfo.hpp>
  23
  24 /**
  25  * DropEvntReq.
  26  */
  27 class DropEvntReq {
  28   friend bool printDROP_EVNT_REQ(FILE*, const Uint32*, Uint32, Uint16);
  29
  30 public:
  31   STATIC_CONST( SignalLength = 2 );
  32   SECTION( EVENT_NAME_SECTION = 0 );
  33
  34   union {             // user block reference
  35     Uint32 senderRef;
  36     Uint32 m_userRef;
  37   };
  38   union {
  39     Uint32 senderData;
  40     Uint32 m_userData;            // user
  41   };
  42
  43   Uint32 getUserRef() const {
  44     return m_userRef;
  45   }
  46   void setUserRef(Uint32 val) {
  47     m_userRef = val;
  48   }
  49   Uint32 getUserData() const {
  50     return m_userData;
  51   }
  52   void setUserData(Uint32 val) {
  53     m_userData = val;
  54   }
  55 };
  56
  57 /**
  58  * DropEvntConf.
  59  */
  60 class DropEvntConf {
  61   friend bool printDROP_EVNT_CONF(FILE*, const Uint32*, Uint32, Uint16);
  62
  63 public:
  64   STATIC_CONST( SignalLength = 2 );
  65
  66   union {             // user block reference
  67     Uint32 senderRef;
  68     Uint32 m_userRef;
  69   };
  70   union {
  71     Uint32 senderData;
  72     Uint32 m_userData;            // user
  73   };
  74
  75   Uint32 getUserRef() const {
  76     return m_userRef;
  77   }
  78   void setUserRef(Uint32 val) {
  79     m_userRef = val;
  80   }
  81   Uint32 getUserData() const {
  82     return m_userData;
  83   }
  84   void setUserData(Uint32 val) {
  85     m_userData = val;
  86   }
  87 };
  88
  89 /**
  90  * DropEvntRef.
  91  */
  92 class DropEvntRef {
  93   friend bool printDROP_EVNT_REF(FILE*, const Uint32*, Uint32, Uint16);
  94
  95 public:
  96   enum ErrorCode {
  97     NoError = 0,
  98     Undefined = 1,
  99     NF_FakeErrorREF = 11,
 100     Busy = 701,
 101     NotMaster = 702
 102   };
 103   STATIC_CONST( SignalLength = 7 );
 104   STATIC_CONST( SignalLength2 = SignalLength+1 );
 105
 106   union {             // user block reference
 107     Uint32 senderRef;
 108     Uint32 m_userRef;
 109   };
 110   union {
 111     Uint32 senderData;
 112     Uint32 m_userData;            // user
 113   };
 114   union {
 115     Uint32 errorCode;
 116     Uint32 m_errorCode;
 117   };
 118   Uint32 m_errorLine;
 119   Uint32 m_errorNode;
 120   // with SignalLength2
 121   Uint32 m_masterNodeId;
 122   Uint32 getUserRef() const {
 123     return m_userRef;
 124   }
 125   void setUserRef(Uint32 val) {
 126     m_userRef = val;
 127   }
 128   Uint32 getUserData() const {
 129     return m_userData;
 130   }
 131   void setUserData(Uint32 val) {
 132     m_userData = val;
 133   }
 134   Uint32 getErrorCode() const {
 135     return m_errorCode;
 136   }
 137   void setErrorCode(Uint32 val) {
 138     m_errorCode = val;
 139   }
 140   Uint32 getErrorLine() const {
 141     return m_errorLine;
 142   }
 143   void setErrorLine(Uint32 val) {
 144     m_errorLine = val;
 145   }
 146   Uint32 getErrorNode() const {
 147     return m_errorNode;
 148   }
 149   void setErrorNode(Uint32 val) {
 150     m_errorNode = val;
 151   }
 152   Uint32 getMasterNode() const {
 153     return m_masterNodeId;
 154   }
 155   void setMasterNode(Uint32 val) {
 156     m_masterNodeId = val;
 157   }
 158 };
 159
 160 /**
 161  * CreateEvntReq.
 162  */
 163 struct CreateEvntReq {
 164   friend bool printCREATE_EVNT_REQ(FILE*, const Uint32*, Uint32, Uint16);
 165
 166   enum RequestType {
 167     RT_UNDEFINED = 0,
 168     RT_USER_CREATE = 1,
 169     RT_USER_GET = 2,
 170
 171     RT_DICT_AFTER_GET = 0x1 << 4
 172     //    RT_DICT_MASTER    = 0x2 << 4,
 173
 174     //    RT_DICT_COMMIT = 0xC << 4,
 175     //    RT_DICT_ABORT = 0xF << 4,
 176     //    RT_TC = 5 << 8
 177   };
 178   enum EventFlags {
 179     EF_REPORT_ALL = 0x1 << 16,
 180     EF_REPORT_SUBSCRIBE = 0x2 << 16,
 181     EF_ALL = 0xFFFF << 16
 182   };
 183   STATIC_CONST( SignalLengthGet = 3 );
 184   STATIC_CONST( SignalLengthCreate = 6+MAXNROFATTRIBUTESINWORDS );
 185   STATIC_CONST( SignalLength = 8+MAXNROFATTRIBUTESINWORDS );
 186   //  SECTION( ATTRIBUTE_LIST_SECTION = 0 );
 187   SECTION( EVENT_NAME_SECTION = 0 );
 188
 189   union {
 190     Uint32 m_userRef;             // user block reference
 191     Uint32 senderRef;             // user block reference
 192   };
 193   union {
 194     Uint32 m_userData;            // user
 195     Uint32 senderData;            // user
 196   };
 197   Uint32 m_requestInfo;
 198   Uint32 m_tableId;             // table to event
 199   Uint32 m_tableVersion;        // table version
 200   AttributeMask::Data m_attrListBitmask;
 201   Uint32 m_eventType;           // EventFlags (16 bits) + from DictTabInfo::TableType (16 bits)
 202   Uint32 m_eventId;             // event table id set by DICT/SUMA
 203   Uint32 m_eventKey;            // event table key set by DICT/SUMA
 204   Uint32 getUserRef() const {
 205     return m_userRef;
 206   }
 207   void setUserRef(Uint32 val) {
 208     m_userRef = val;
 209   }
 210   Uint32 getUserData() const {
 211     return m_userData;
 212   }
 213   void setUserData(Uint32 val) {
 214     m_userData = val;
 215   }
 216   CreateEvntReq::RequestType getRequestType() const {
 217     const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16);
 218     return (CreateEvntReq::RequestType)val;
 219   }
 220   void setRequestType(CreateEvntReq::RequestType val) {
 221     m_requestInfo = (Uint32)val;
 222   }
 223   Uint32 getRequestFlag() const {
 224     return BitmaskImpl::getField(1, &m_requestInfo, 16, 16);
 225   };
 226   void addRequestFlag(Uint32 val) {
 227     val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16);
 228     BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val);
 229   };
 230   Uint32 getTableId() const {
 231     return m_tableId;
 232   }
 233   void setTableId(Uint32 val) {
 234     m_tableId = val;
 235   }
 236   Uint32 getTableVersion() const {
 237     return m_tableVersion;
 238   }
 239   void setTableVersion(Uint32 val) {
 240     m_tableVersion = val;
 241   }
 242   AttributeMask getAttrListBitmask() const {
 243     AttributeMask tmp;
 244     tmp.assign(m_attrListBitmask);
 245     return tmp;
 246   }
 247   void setAttrListBitmask(const AttributeMask & val) {
 248     AttributeMask::assign(m_attrListBitmask.data, val);
 249   }
 250   Uint32 getEventType() const {
 251     return m_eventType & ~EF_ALL;
 252   }
 253   void setEventType(Uint32 val) {
 254     m_eventType = (m_eventType & EF_ALL) | (~EF_ALL & (Uint32)val);
 255   }
 256   Uint32 getEventId() const {
 257     return m_eventId;
 258   }
 259   void setEventId(Uint32 val) {
 260     m_eventId = val;
 261   }
 262   Uint32 getEventKey() const {
 263     return m_eventKey;
 264   }
 265   void setEventKey(Uint32 val) {
 266     m_eventKey = val;
 267   }
 268   void clearFlags() {
 269     m_eventType&= ~EF_ALL;
 270   }
 271   Uint32 getReportFlags() const {
 272     return  m_eventType & EF_ALL;
 273   }
 274   void setReportFlags(Uint32 val) {
 275     m_eventType = (val & EF_ALL) | (m_eventType & ~EF_ALL);
 276   }
 277   Uint32 getReportAll() const {
 278     return  m_eventType & EF_REPORT_ALL ;
 279   }
 280   void setReportAll() {
 281     m_eventType|= EF_REPORT_ALL;
 282   }
 283   Uint32 getReportSubscribe() const {
 284     return  m_eventType & EF_REPORT_SUBSCRIBE ;
 285   }
 286   void setReportSubscribe() {
 287     m_eventType|= EF_REPORT_SUBSCRIBE;
 288   }
 289 };
 290
 291 /**
 292  * CreateEvntConf.
 293  */
 294 class CreateEvntConf {
 295   friend bool printCREATE_EVNT_CONF(FILE*, const Uint32*, Uint32, Uint16);
 296
 297 public:
 298   //  STATIC_CONST( InternalLength = 3 );
 299   STATIC_CONST( SignalLength = 8+MAXNROFATTRIBUTESINWORDS );
 300
 301   union {
 302     Uint32 m_userRef;             // user block reference
 303     Uint32 senderRef;             // user block reference
 304   };
 305   union {
 306     Uint32 m_userData;            // user
 307     Uint32 senderData;            // user
 308   };
 309   Uint32 m_requestInfo;
 310   Uint32 m_tableId;
 311   Uint32 m_tableVersion;        // table version
 312   AttributeMask m_attrListBitmask;
 313   Uint32 m_eventType;
 314   Uint32 m_eventId;
 315   Uint32 m_eventKey;
 316
 317   Uint32 getUserRef() const {
 318     return m_userRef;
 319   }
 320   void setUserRef(Uint32 val) {
 321     m_userRef = val;
 322   }
 323   Uint32 getUserData() const {
 324     return m_userData;
 325   }
 326   void setUserData(Uint32 val) {
 327     m_userData = val;
 328   }
 329   CreateEvntReq::RequestType getRequestType() const {
 330     return (CreateEvntReq::RequestType)m_requestInfo;
 331   }
 332   void setRequestType(CreateEvntReq::RequestType val) {
 333     m_requestInfo = (Uint32)val;
 334   }
 335   Uint32 getTableId() const {
 336     return m_tableId;
 337   }
 338   void setTableId(Uint32 val) {
 339     m_tableId = val;
 340   }
 341   Uint32 getTableVersion() const {
 342     return m_tableVersion;
 343   }
 344   void setTableVersion(Uint32 val) {
 345     m_tableVersion = val;
 346   }
 347   AttributeMask getAttrListBitmask() const {
 348     return m_attrListBitmask;
 349   }
 350   void setAttrListBitmask(const AttributeMask & val) {
 351     m_attrListBitmask = val;
 352   }
 353   Uint32 getEventType() const {
 354     return m_eventType;
 355   }
 356   void setEventType(Uint32 val) {
 357     m_eventType = (Uint32)val;
 358   }
 359   Uint32 getEventId() const {
 360     return m_eventId;
 361   }
 362   void setEventId(Uint32 val) {
 363     m_eventId = val;
 364   }
 365   Uint32 getEventKey() const {
 366     return m_eventKey;
 367   }
 368   void setEventKey(Uint32 val) {
 369     m_eventKey = val;
 370   }
 371 };
 372
 373 /**
 374  * CreateEvntRef.
 375  */
 376 struct CreateEvntRef {
 377   friend class SafeCounter;
 378   friend bool printCREATE_EVNT_REF(FILE*, const Uint32*, Uint32, Uint16);
 379
 380   STATIC_CONST( SignalLength = 11 );
 381   STATIC_CONST( SignalLength2 = SignalLength + 1 );
 382   enum ErrorCode {
 383     NoError = 0,
 384     Undefined = 1,
 385     NF_FakeErrorREF = 11,
 386     Busy = 701,
 387     NotMaster = 702
 388   };
 389   union {
 390     Uint32 m_userRef;             // user block reference
 391     Uint32 senderRef;             // user block reference
 392   };
 393   union {
 394     Uint32 m_userData;            // user
 395     Uint32 senderData;            // user
 396   };
 397
 398   Uint32 m_requestInfo;
 399   Uint32 m_tableId;
 400   Uint32 m_tableVersion;        // table version
 401   Uint32 m_eventType;
 402   Uint32 m_eventId;
 403   Uint32 m_eventKey;
 404   Uint32 errorCode;
 405   Uint32 m_errorLine;
 406   Uint32 m_errorNode;
 407   // with SignalLength2
 408   Uint32 m_masterNodeId;
 409   Uint32 getUserRef() const {
 410     return m_userRef;
 411   }
 412   void setUserRef(Uint32 val) {
 413     m_userRef = val;
 414   }
 415   Uint32 getUserData() const {
 416     return m_userData;
 417   }
 418   void setUserData(Uint32 val) {
 419     m_userData = val;
 420   }
 421   CreateEvntReq::RequestType getRequestType() const {
 422     return (CreateEvntReq::RequestType)m_requestInfo;
 423   }
 424   void setRequestType(CreateEvntReq::RequestType val) {
 425     m_requestInfo = (Uint32)val;
 426   }
 427   Uint32 getTableId() const {
 428     return m_tableId;
 429   }
 430   void setTableId(Uint32 val) {
 431     m_tableId = val;
 432   }
 433   Uint32 getTableVersion() const {
 434     return m_tableVersion;
 435   }
 436   void setTableVersion(Uint32 val) {
 437     m_tableVersion = val;
 438   }
 439
 440   Uint32 getEventType() const {
 441     return m_eventType;
 442   }
 443   void setEventType(Uint32 val) {
 444     m_eventType = (Uint32)val;
 445   }
 446   Uint32 getEventId() const {
 447     return m_eventId;
 448   }
 449   void setEventId(Uint32 val) {
 450     m_eventId = val;
 451   }
 452   Uint32 getEventKey() const {
 453     return m_eventKey;
 454   }
 455   void setEventKey(Uint32 val) {
 456     m_eventKey = val;
 457   }
 458
 459   Uint32 getErrorCode() const {
 460     return errorCode;
 461   }
 462   void setErrorCode(Uint32 val) {
 463     errorCode = val;
 464   }
 465   Uint32 getErrorLine() const {
 466     return m_errorLine;
 467   }
 468   void setErrorLine(Uint32 val) {
 469     m_errorLine = val;
 470   }
 471   Uint32 getErrorNode() const {
 472     return m_errorNode;
 473   }
 474   void setErrorNode(Uint32 val) {
 475     m_errorNode = val;
 476   }
 477   Uint32 getMasterNode() const {
 478     return m_masterNodeId;
 479   }
 480   void setMasterNode(Uint32 val) {
 481     m_masterNodeId = val;
 482   }
 483 };
 484 #endif