开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
CreateEvnt.hpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：11k
源码类别：

MySQL数据库

开发平台：

Visual C++

CreateEvnt.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef CREATE_EVNT_HPP
  18. #define CREATE_EVNT_HPP
  20. #include "SignalData.hpp"
  21. #include <NodeBitmask.hpp>
  22. #include <signaldata/DictTabInfo.hpp>
  24. /**
  25.  * DropEvntReq.
  26.  */
  27. class DropEvntReq {
  28.   friend bool printDROP_EVNT_REQ(FILE*, const Uint32*, Uint32, Uint16);
  30. public:
  31.   STATIC_CONST( SignalLength = 2 );
  32.   SECTION( EVENT_NAME_SECTION = 0 );
  34.   union {             // user block reference
  35.     Uint32 senderRef;
  36.     Uint32 m_userRef;
  37.   };
  38.   union {
  39.     Uint32 senderData;
  40.     Uint32 m_userData;            // user 
  41.   };
  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. };
  57. /**
  58.  * DropEvntConf.
  59.  */
  60. class DropEvntConf {
  61.   friend bool printDROP_EVNT_CONF(FILE*, const Uint32*, Uint32, Uint16);
  63. public:
  64.   STATIC_CONST( SignalLength = 2 );
  66.   union {             // user block reference
  67.     Uint32 senderRef;
  68.     Uint32 m_userRef;
  69.   };
  70.   union {
  71.     Uint32 senderData;
  72.     Uint32 m_userData;            // user 
  73.   };
  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. };
  89. /**
  90.  * DropEvntRef.
  91.  */
  92. class DropEvntRef {
  93.   friend bool printDROP_EVNT_REF(FILE*, const Uint32*, Uint32, Uint16);
  95. public:
  96.   enum ErrorCode {
  97.     NoError = 0,
  98.     Undefined = 1,
  99.     UndefinedTCError = 2,
  100.     NF_FakeErrorREF = 11,
  101.     Busy = 701,
  102.     NotMaster = 702,
  103.     SeizeError = 703,
  104.     EventNotFound = 4238,
  105.     EventNameTooLong = 4241,
  106.     TooManyEvents = 4242,
  107.     BadRequestType = 4247,
  108.     InvalidName = 4248,
  109.     InvalidPrimaryTable = 4249,
  110.     InvalidEventType = 4250,
  111.     NotUnique = 4251,
  112.     AllocationError = 4252,
  113.     CreateEventTableFailed = 4253,
  114.     InvalidAttributeOrder = 4255,
  115.     Temporary = 0x1 << 16
  116.   };
  118.   STATIC_CONST( SignalLength = 5 );
  120.   union {             // user block reference
  121.     Uint32 senderRef;
  122.     Uint32 m_userRef;
  123.   };
  124.   union {
  125.     Uint32 senderData;
  126.     Uint32 m_userData;            // user 
  127.   };
  128.   union {
  129.     Uint32 errorCode;
  130.     Uint32 m_errorCode;
  131.   };
  132.   Uint32 m_errorLine;
  133.   Uint32 m_errorNode;
  135.   bool isTemporary() const
  136.   { return (errorCode &  Temporary) > 0; }
  138.   void setTemporary()
  139.   { errorCode |=  Temporary; }
  141.   ErrorCode setTemporary(ErrorCode ec)
  142.   { return (ErrorCode) (errorCode = ((Uint32) ec | (Uint32)Temporary)); }
  144.   Uint32 getUserRef() const {
  145.     return m_userRef;
  146.   }
  147.   void setUserRef(Uint32 val) {
  148.     m_userRef = val;
  149.   }
  150.   Uint32 getUserData() const {
  151.     return m_userData;
  152.   }
  153.   void setUserData(Uint32 val) {
  154.     m_userData = val;
  155.   }
  156.   DropEvntRef::ErrorCode getErrorCode() const {
  157.     return (DropEvntRef::ErrorCode)m_errorCode;
  158.   }
  159.   void setErrorCode(DropEvntRef::ErrorCode val) {
  160.     m_errorCode = (Uint32)val;
  161.   }
  162.   Uint32 getErrorLine() const {
  163.     return m_errorLine;
  164.   }
  165.   void setErrorLine(Uint32 val) {
  166.     m_errorLine = val;
  167.   }
  168.   Uint32 getErrorNode() const {
  169.     return m_errorNode;
  170.   }
  171.   void setErrorNode(Uint32 val) {
  172.     m_errorNode = val;
  173.   }
  174. };
  176. /**
  177.  * CreateEvntReq.
  178.  */
  179. struct CreateEvntReq {
  180.   friend bool printCREATE_EVNT_REQ(FILE*, const Uint32*, Uint32, Uint16);
  182.   enum RequestType {
  183.     RT_UNDEFINED = 0,
  184.     RT_USER_CREATE = 1,
  185.     RT_USER_GET = 2,
  187.     RT_DICT_AFTER_GET = 0x1 << 4
  188.     //    RT_DICT_MASTER    = 0x2 << 4,
  190.     //    RT_DICT_COMMIT = 0xC << 4,
  191.     //    RT_DICT_ABORT = 0xF << 4,
  192.     //    RT_TC = 5 << 8
  193.   };
  194.   STATIC_CONST( SignalLengthGet = 3 );
  195.   STATIC_CONST( SignalLengthCreate = 5+MAXNROFATTRIBUTESINWORDS );
  196.   STATIC_CONST( SignalLength = 7+MAXNROFATTRIBUTESINWORDS );
  197.   //  SECTION( ATTRIBUTE_LIST_SECTION = 0 );
  198.   SECTION( EVENT_NAME_SECTION = 0 );
  200.   union {
  201.     Uint32 m_userRef;             // user block reference
  202.     Uint32 senderRef;             // user block reference
  203.   };
  204.   union {
  205.     Uint32 m_userData;            // user 
  206.     Uint32 senderData;            // user 
  207.   };
  208.   Uint32 m_requestInfo;
  209.   Uint32 m_tableId;             // table to event
  210.   AttributeMask::Data m_attrListBitmask;
  211.   Uint32 m_eventType;           // from DictTabInfo::TableType
  212.   Uint32 m_eventId;             // event table id set by DICT/SUMA
  213.   Uint32 m_eventKey;            // event table key set by DICT/SUMA
  215.   Uint32 getUserRef() const {
  216.     return m_userRef;
  217.   }
  218.   void setUserRef(Uint32 val) {
  219.     m_userRef = val;
  220.   }
  221.   Uint32 getUserData() const {
  222.     return m_userData;
  223.   }
  224.   void setUserData(Uint32 val) {
  225.     m_userData = val;
  226.   }
  227.   CreateEvntReq::RequestType getRequestType() const {
  228.     const Uint32 val = BitmaskImpl::getField(1, &m_requestInfo, 0, 16);
  229.     return (CreateEvntReq::RequestType)val;
  230.   }
  231.   void setRequestType(CreateEvntReq::RequestType val) {
  232.     m_requestInfo = (Uint32)val;
  233.   }
  234.   Uint32 getRequestFlag() const {
  235.     return BitmaskImpl::getField(1, &m_requestInfo, 16, 16);
  236.   };
  237.   void addRequestFlag(Uint32 val) {
  238.     val |= BitmaskImpl::getField(1, &m_requestInfo, 16, 16);
  239.     BitmaskImpl::setField(1, &m_requestInfo, 16, 16, val);
  240.   };
  241.   Uint32 getTableId() const {
  242.     return m_tableId;
  243.   }
  244.   void setTableId(Uint32 val) {
  245.     m_tableId = val;
  246.   }
  247.   AttributeMask getAttrListBitmask() const {
  248.     AttributeMask tmp;
  249.     tmp.assign(m_attrListBitmask);
  250.     return tmp;
  251.   }
  252.   void setAttrListBitmask(const AttributeMask & val) {
  253.     AttributeMask::assign(m_attrListBitmask.data, val);
  254.   }
  255.   Uint32 getEventType() const {
  256.     return m_eventType;
  257.   }
  258.   void setEventType(Uint32 val) {
  259.     m_eventType = (Uint32)val;
  260.   }
  261.   Uint32 getEventId() const {
  262.     return m_eventId;
  263.   }
  264.   void setEventId(Uint32 val) {
  265.     m_eventId = val;
  266.   }
  267.   Uint32 getEventKey() const {
  268.     return m_eventKey;
  269.   }
  270.   void setEventKey(Uint32 val) {
  271.     m_eventKey = val;
  272.   }
  273. };
  275. /**
  276.  * CreateEvntConf.
  277.  */
  278. class CreateEvntConf {
  279.   friend bool printCREATE_EVNT_CONF(FILE*, const Uint32*, Uint32, Uint16);
  281. public:
  282.   //  STATIC_CONST( InternalLength = 3 );
  283.   STATIC_CONST( SignalLength = 7+MAXNROFATTRIBUTESINWORDS );
  285.   union {
  286.     Uint32 m_userRef;             // user block reference
  287.     Uint32 senderRef;             // user block reference
  288.   };
  289.   union {
  290.     Uint32 m_userData;            // user 
  291.     Uint32 senderData;            // user 
  292.   };
  293.   Uint32 m_requestInfo;
  294.   Uint32 m_tableId;
  295.   AttributeMask m_attrListBitmask;
  296.   Uint32 m_eventType;
  297.   Uint32 m_eventId;
  298.   Uint32 m_eventKey;
  300.   Uint32 getUserRef() const {
  301.     return m_userRef;
  302.   }
  303.   void setUserRef(Uint32 val) {
  304.     m_userRef = val;
  305.   }
  306.   Uint32 getUserData() const {
  307.     return m_userData;
  308.   }
  309.   void setUserData(Uint32 val) {
  310.     m_userData = val;
  311.   }
  312.   CreateEvntReq::RequestType getRequestType() const {
  313.     return (CreateEvntReq::RequestType)m_requestInfo;
  314.   }
  315.   void setRequestType(CreateEvntReq::RequestType val) {
  316.     m_requestInfo = (Uint32)val;
  317.   }
  318.   Uint32 getTableId() const {
  319.     return m_tableId;
  320.   }
  321.   void setTableId(Uint32 val) {
  322.     m_tableId = val;
  323.   }
  324.   AttributeMask getAttrListBitmask() const {
  325.     return m_attrListBitmask;
  326.   }
  327.   void setAttrListBitmask(const AttributeMask & val) {
  328.     m_attrListBitmask = val;
  329.   }
  330.   Uint32 getEventType() const {
  331.     return m_eventType;
  332.   }
  333.   void setEventType(Uint32 val) {
  334.     m_eventType = (Uint32)val;
  335.   }
  336.   Uint32 getEventId() const {
  337.     return m_eventId;
  338.   }
  339.   void setEventId(Uint32 val) {
  340.     m_eventId = val;
  341.   }
  342.   Uint32 getEventKey() const {
  343.     return m_eventKey;
  344.   }
  345.   void setEventKey(Uint32 val) {
  346.     m_eventKey = val;
  347.   }
  348. };
  350. /**
  351.  * CreateEvntRef.
  352.  */
  353. struct CreateEvntRef {
  354.   friend class SafeCounter;
  355.   friend bool printCREATE_EVNT_REF(FILE*, const Uint32*, Uint32, Uint16);
  357.   STATIC_CONST( SignalLength = 10 );
  358.   enum ErrorCode {
  359.     NoError = 0,
  360.     Undefined = 1,
  361.     UndefinedTCError = 2,
  362.     NF_FakeErrorREF = 11,
  363.     Busy = 701,
  364.     NotMaster = 702,
  365.     SeizeError = 703,
  366.     EventNotFound = 4238,
  367.     EventExists = 4239,
  368.     EventNameTooLong = 4241,
  369.     TooManyEvents = 4242,
  370.     //    EventExists = 4244,
  371.     AttributeNotStored = 4245,
  372.     AttributeNullable = 4246,
  373.     BadRequestType = 4247,
  374.     InvalidName = 4248,
  375.     InvalidPrimaryTable = 4249,
  376.     InvalidEventType = 4250,
  377.     NotUnique = 4251,
  378.     AllocationError = 4252,
  379.     CreateEventTableFailed = 4253,
  380.     InvalidAttributeOrder = 4255,
  381.     Temporary = 0x1 << 16
  382.   };
  383.   bool isTemporary() const;
  384.   void setTemporary();
  385.   ErrorCode setTemporary(ErrorCode ec);
  386.   static ErrorCode makeTemporary(ErrorCode ec);
  388.   union {
  389.     Uint32 m_userRef;             // user block reference
  390.     Uint32 senderRef;             // user block reference
  391.   };
  392.   union {
  393.     Uint32 m_userData;            // user 
  394.     Uint32 senderData;            // user 
  395.   };
  397.   Uint32 m_requestInfo;
  398.   Uint32 m_tableId;
  399.   Uint32 m_eventType;
  400.   Uint32 m_eventId;
  401.   Uint32 m_eventKey;
  402.   Uint32 errorCode;
  403.   Uint32 m_errorLine;
  404.   Uint32 m_errorNode;
  406. #if 0
  407.   CreateEvntConf* getConf() {
  408.     return &m_conf;
  409.   }
  410.   const CreateEvntConf* getConf() const {
  411.     return &m_conf;
  412.   }
  413. #endif
  414.   Uint32 getUserRef() const {
  415.     return m_userRef;
  416.   }
  417.   void setUserRef(Uint32 val) {
  418.     m_userRef = val;
  419.   }
  420.   Uint32 getUserData() const {
  421.     return m_userData;
  422.   }
  423.   void setUserData(Uint32 val) {
  424.     m_userData = val;
  425.   }
  426.   CreateEvntReq::RequestType getRequestType() const {
  427.     return (CreateEvntReq::RequestType)m_requestInfo;
  428.   }
  429.   void setRequestType(CreateEvntReq::RequestType val) {
  430.     m_requestInfo = (Uint32)val;
  431.   }
  432.   Uint32 getTableId() const {
  433.     return m_tableId;
  434.   }
  435.   void setTableId(Uint32 val) {
  436.     m_tableId = val;
  437.   }
  439.   Uint32 getEventType() const {
  440.     return m_eventType;
  441.   }
  442.   void setEventType(Uint32 val) {
  443.     m_eventType = (Uint32)val;
  444.   }
  445.   Uint32 getEventId() const {
  446.     return m_eventId;
  447.   }
  448.   void setEventId(Uint32 val) {
  449.     m_eventId = val;
  450.   }
  451.   Uint32 getEventKey() const {
  452.     return m_eventKey;
  453.   }
  454.   void setEventKey(Uint32 val) {
  455.     m_eventKey = val;
  456.   }
  458.   CreateEvntRef::ErrorCode getErrorCode() const {
  459.     return (CreateEvntRef::ErrorCode)errorCode;
  460.   }
  461.   void setErrorCode(CreateEvntRef::ErrorCode val) {
  462.     errorCode = (Uint32)val;
  463.   }
  464.   Uint32 getErrorLine() const {
  465.     return m_errorLine;
  466.   }
  467.   void setErrorLine(Uint32 val) {
  468.     m_errorLine = val;
  469.   }
  470.   Uint32 getErrorNode() const {
  471.     return m_errorNode;
  472.   }
  473.   void setErrorNode(Uint32 val) {
  474.     m_errorNode = val;
  475.   }
  476. };
  477. inline bool CreateEvntRef::isTemporary() const
  478. { return (errorCode &  CreateEvntRef::Temporary) > 0; }
  479. inline void CreateEvntRef::setTemporary()
  480. { errorCode |=  CreateEvntRef::Temporary; }
  481. inline CreateEvntRef::ErrorCode CreateEvntRef::setTemporary(ErrorCode ec)
  482. { return (CreateEvntRef::ErrorCode) 
  483.     (errorCode = ((Uint32) ec | (Uint32)CreateEvntRef::Temporary)); }
  484. inline CreateEvntRef::ErrorCode CreateEvntRef::makeTemporary(ErrorCode ec)
  485. { return (CreateEvntRef::ErrorCode) 
  486.     ( (Uint32) ec | (Uint32)CreateEvntRef::Temporary ); }
  488. #endif