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

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 UTIL_LOCK_HPP
  14. #define UTIL_LOCK_HPP
  15. #include "SignalData.hpp"
  16. class UtilLockReq {
  17.   
  18.   /**
  19.    * Receiver
  20.    */
  21.   friend class DbUtil;
  22.   
  23.   /**
  24.    * Sender
  25.    */
  26.   friend class Dbdih;
  27.   friend class MutexManager;
  28.   friend bool printUTIL_LOCK_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  29. public:
  30.   STATIC_CONST( SignalLength = 4 );
  31.   enum RequestInfo {
  32.     TryLock = 1
  33.   };
  34. public:
  35.   Uint32 senderData;  
  36.   Uint32 senderRef;
  37.   Uint32 lockId;
  38.   Uint32 requestInfo;
  39. };
  40. class UtilLockConf {
  41.   
  42.   /**
  43.    * Receiver
  44.    */
  45.   friend class Dbdih;
  46.   friend class MutexManager;  
  47.   /**
  48.    * Sender
  49.    */
  50.   friend class DbUtil;
  51.   friend bool printUTIL_LOCK_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  52. public:
  53.   STATIC_CONST( SignalLength = 4 );
  54.   
  55. public:
  56.   Uint32 senderData;
  57.   Uint32 senderRef;
  58.   Uint32 lockId;
  59.   Uint32 lockKey;
  60. };
  61. class UtilLockRef {
  62.   
  63.   /**
  64.    * Reciver
  65.    */
  66.   friend class Dbdih;
  67.   friend class MutexManager;
  68.   
  69.   /**
  70.    * Sender
  71.    */
  72.   friend class DbUtil;
  73.   
  74.   friend bool printUTIL_LOCK_REF(FILE *, const Uint32 *, Uint32, Uint16);
  75. public:
  76.   STATIC_CONST( SignalLength = 4 );
  77.   
  78.   enum ErrorCode {
  79.     OK = 0,
  80.     NoSuchLock = 1,
  81.     OutOfLockRecords = 2,
  82.     DistributedLockNotSupported = 3,
  83.     LockAlreadyHeld = 4
  84.     
  85.   };
  86. public:
  87.   Uint32 senderData;
  88.   Uint32 senderRef;
  89.   Uint32 lockId;
  90.   Uint32 errorCode;
  91. };
  92. class UtilUnlockReq {
  93.   
  94.   /**
  95.    * Receiver
  96.    */
  97.   friend class DbUtil;
  98.   
  99.   /**
  100.    * Sender
  101.    */
  102.   friend class Dbdih;
  103.   friend class MutexManager;
  104.   friend bool printUTIL_UNLOCK_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  105. public:
  106.   STATIC_CONST( SignalLength = 4 );
  107.   
  108. public:
  109.   Uint32 senderData;  
  110.   Uint32 senderRef;
  111.   Uint32 lockId;
  112.   Uint32 lockKey;
  113. };
  114. class UtilUnlockConf {
  115.   
  116.   /**
  117.    * Receiver
  118.    */
  119.   friend class Dbdih;
  120.   friend class MutexManager;  
  121.   /**
  122.    * Sender
  123.    */
  124.   friend class DbUtil;
  125.   friend bool printUTIL_UNLOCK_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  126. public:
  127.   STATIC_CONST( SignalLength = 3 );
  128.   
  129. public:
  130.   Uint32 senderData;
  131.   Uint32 senderRef;
  132.   Uint32 lockId;
  133. };
  134. class UtilUnlockRef {
  135.   
  136.   /**
  137.    * Reciver
  138.    */
  139.   friend class Dbdih;
  140.   friend class MutexManager;
  141.   
  142.   /**
  143.    * Sender
  144.    */
  145.   friend class DbUtil;
  146.   
  147.   friend bool printUTIL_UNLOCK_REF(FILE *, const Uint32 *, Uint32, Uint16);
  148. public:
  149.   STATIC_CONST( SignalLength = 4 );
  150.   
  151.   enum ErrorCode {
  152.     OK = 0,
  153.     NoSuchLock = 1,
  154.     NotLockOwner = 2
  155.   };
  156. public:
  157.   Uint32 senderData;
  158.   Uint32 senderRef;
  159.   Uint32 lockId;
  160.   Uint32 errorCode;
  161. };
  162. /**
  163.  * Creating a lock
  164.  */
  165. class UtilCreateLockReq {
  166.   /**
  167.    * Receiver
  168.    */
  169.   friend class DbUtil;
  170.   
  171.   /**
  172.    * Sender
  173.    */
  174.   friend class MutexManager;
  175.   
  176.   friend bool printUTIL_CREATE_LOCK_REQ(FILE *, const Uint32*, Uint32, Uint16);
  177. public:
  178.   enum LockType {
  179.     Mutex = 0 // Lock with only exclusive locks
  180.   };
  181.   STATIC_CONST( SignalLength = 4 );
  182. public:
  183.   Uint32 senderData;
  184.   Uint32 senderRef;
  185.   Uint32 lockId;
  186.   Uint32 lockType;
  187. };
  188. class UtilCreateLockRef {
  189.   /**
  190.    * Sender
  191.    */
  192.   friend class DbUtil;
  193.   
  194.   /**
  195.    * Receiver
  196.    */
  197.   friend class MutexManager;
  198.   friend bool printUTIL_CREATE_LOCK_REF(FILE *, const Uint32*, Uint32, Uint16);
  199. public:
  200.   enum ErrorCode {
  201.     OK = 0,
  202.     OutOfLockQueueRecords = 1,
  203.     LockIdAlreadyUsed = 2,
  204.     UnsupportedLockType = 3
  205.   };
  206.   STATIC_CONST( SignalLength = 4 );
  207. public:
  208.   Uint32 senderData;
  209.   Uint32 senderRef;
  210.   Uint32 lockId;
  211.   Uint32 errorCode;
  212. };
  213. class UtilCreateLockConf {
  214.   /**
  215.    * Sender
  216.    */
  217.   friend class DbUtil;
  218.   
  219.   /**
  220.    * Receiver
  221.    */
  222.   friend class MutexManager;
  223.   friend bool printUTIL_CREATE_LOCK_CONF(FILE*, const Uint32*, Uint32, Uint16);
  224. public:
  225.   STATIC_CONST( SignalLength = 3 );
  226. public:
  227.   Uint32 senderData;
  228.   Uint32 senderRef;
  229.   Uint32 lockId;
  230. };
  231. /**
  232.  * Creating a lock
  233.  */
  234. class UtilDestroyLockReq {
  235.   /**
  236.    * Receiver
  237.    */
  238.   friend class DbUtil;
  239.   
  240.   /**
  241.    * Sender
  242.    */
  243.   friend class MutexManager;
  244.   
  245.   friend bool printUTIL_DESTROY_LOCK_REQ(FILE *, const Uint32*, Uint32, Uint16);
  246. public:
  247.   STATIC_CONST( SignalLength = 4 );
  248. public:
  249.   Uint32 senderData;
  250.   Uint32 senderRef;
  251.   Uint32 lockId;
  252.   Uint32 lockKey;
  253. };
  254. class UtilDestroyLockRef {
  255.   /**
  256.    * Sender
  257.    */
  258.   friend class DbUtil;
  259.   
  260.   /**
  261.    * Receiver
  262.    */
  263.   friend class MutexManager;
  264.   friend bool printUTIL_DESTROY_LOCK_REF(FILE *, const Uint32*, Uint32, Uint16);
  265. public:
  266.   enum ErrorCode {
  267.     OK = 0,
  268.     NoSuchLock = 1,
  269.     NotLockOwner = 2
  270.   };
  271.   STATIC_CONST( SignalLength = 4 );
  272. public:
  273.   Uint32 senderData;
  274.   Uint32 senderRef;
  275.   Uint32 lockId;
  276.   Uint32 errorCode;
  277. };
  278. class UtilDestroyLockConf {
  279.   /**
  280.    * Sender
  281.    */
  282.   friend class DbUtil;
  283.   
  284.   /**
  285.    * Receiver
  286.    */
  287.   friend class MutexManager;
  288.   friend bool printUTIL_DESTROY_LOCK_CONF(FILE*, const Uint32*, Uint32, Uint16);
  289. public:
  290.   STATIC_CONST( SignalLength = 3 );
  291. public:
  292.   Uint32 senderData;
  293.   Uint32 senderRef;
  294.   Uint32 lockId;
  295. };
  296. #endif