/node_modules/grpc/src/core/lib/surface/completion_queue.h

https://gitlab.com/AshleyMcVeigh/cloudComputingAssignment · C Header · 100 lines · 44 code · 12 blank · 44 comment · 0 complexity · 2734dc8b14baebc46dfc77fb4424b9a6 MD5 · raw file 

    

  1. /*
    2. 

  2.  *
    3. 

  3.  * Copyright 2015-2016, Google Inc.
    4. 

  4.  * All rights reserved.
    5. 

  5.  *
    6. 

  6.  * Redistribution and use in source and binary forms, with or without
    7. 

  7.  * modification, are permitted provided that the following conditions are
    8. 

  8.  * met:
    9. 

  9.  *
    10. 

  10.  *     * Redistributions of source code must retain the above copyright
    11. 

  11.  * notice, this list of conditions and the following disclaimer.
    12. 

  12.  *     * Redistributions in binary form must reproduce the above
    13. 

  13.  * copyright notice, this list of conditions and the following disclaimer
    14. 

  14.  * in the documentation and/or other materials provided with the
    15. 

  15.  * distribution.
    16. 

  16.  *     * Neither the name of Google Inc. nor the names of its
    17. 

  17.  * contributors may be used to endorse or promote products derived from
    18. 

  18.  * this software without specific prior written permission.
    19. 

  19.  *
    20. 

  20.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    21. 

  21.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    22. 

  22.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    23. 

  23.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    24. 

  24.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    25. 

  25.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    26. 

  26.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    27. 

  27.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    28. 

  28.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    29. 

  29.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    30. 

  30.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    31. 

  31.  *
    32. 

  32.  */
    33. 

  33. 

  34. #ifndef GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H
    35. 

  35. #define GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H
    36. 

  36. 

  37. /* Internal API for completion queues */
    38. 

  38. 

  39. #include <grpc/grpc.h>
    40. 

  40. #include "src/core/lib/iomgr/pollset.h"
    41. 

  41. 

  42. /* These trace flags default to 1. The corresponding lines are only traced
    43. 

  43.    if grpc_api_trace is also truthy */
    44. 

  44. extern int grpc_cq_pluck_trace;
    45. 

  45. extern int grpc_cq_event_timeout_trace;
    46. 

  46. extern int grpc_trace_operation_failures;
    47. 

  47. 

  48. typedef struct grpc_cq_completion {
    49. 

  49.   /** user supplied tag */
    50. 

  50.   void *tag;
    51. 

  51.   /** done callback - called when this queue element is no longer
    52. 

  52.       needed by the completion queue */
    53. 

  53.   void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
    54. 

  54.                struct grpc_cq_completion *c);
    55. 

  55.   void *done_arg;
    56. 

  56.   /** next pointer; low bit is used to indicate success or not */
    57. 

  57.   uintptr_t next;
    58. 

  58. } grpc_cq_completion;
    59. 

  59. 

  60. #ifdef GRPC_CQ_REF_COUNT_DEBUG
    61. 

  61. void grpc_cq_internal_ref(grpc_completion_queue *cc, const char *reason,
    62. 

  62.                           const char *file, int line);
    63. 

  63. void grpc_cq_internal_unref(grpc_completion_queue *cc, const char *reason,
    64. 

  64.                             const char *file, int line);
    65. 

  65. #define GRPC_CQ_INTERNAL_REF(cc, reason) \
    66. 

  66.   grpc_cq_internal_ref(cc, reason, __FILE__, __LINE__)
    67. 

  67. #define GRPC_CQ_INTERNAL_UNREF(cc, reason) \
    68. 

  68.   grpc_cq_internal_unref(cc, reason, __FILE__, __LINE__)
    69. 

  69. #else
    70. 

  70. void grpc_cq_internal_ref(grpc_completion_queue *cc);
    71. 

  71. void grpc_cq_internal_unref(grpc_completion_queue *cc);
    72. 

  72. #define GRPC_CQ_INTERNAL_REF(cc, reason) grpc_cq_internal_ref(cc)
    73. 

  73. #define GRPC_CQ_INTERNAL_UNREF(cc, reason) grpc_cq_internal_unref(cc)
    74. 

  74. #endif
    75. 

  75. 

  76. /* Flag that an operation is beginning: the completion channel will not finish
    77. 

  77.    shutdown until a corrensponding grpc_cq_end_* call is made.
    78. 

  78.    \a tag is currently used only in debug builds. */
    79. 

  79. void grpc_cq_begin_op(grpc_completion_queue *cc, void *tag);
    80. 

  80. 

  81. /* Queue a GRPC_OP_COMPLETED operation; tag must correspond to the tag passed to
    82. 

  82.    grpc_cq_begin_op */
    83. 

  83. void grpc_cq_end_op(grpc_exec_ctx *exec_ctx, grpc_completion_queue *cc,
    84. 

  84.                     void *tag, grpc_error *error,
    85. 

  85.                     void (*done)(grpc_exec_ctx *exec_ctx, void *done_arg,
    86. 

  86.                                  grpc_cq_completion *storage),
    87. 

  87.                     void *done_arg, grpc_cq_completion *storage);
    88. 

  88. 

  89. grpc_pollset *grpc_cq_pollset(grpc_completion_queue *cc);
    90. 

  90. grpc_completion_queue *grpc_cq_from_pollset(grpc_pollset *ps);
    91. 

  91. 

  92. void grpc_cq_mark_non_listening_server_cq(grpc_completion_queue *cc);
    93. 

  93. bool grpc_cq_is_non_listening_server_cq(grpc_completion_queue *cc);
    94. 

  94. void grpc_cq_mark_server_cq(grpc_completion_queue *cc);
    95. 

  95. int grpc_cq_is_server_cq(grpc_completion_queue *cc);
    96. 

  96. 

  97. void grpc_cq_global_init(void);
    98. 

  98. void grpc_cq_global_shutdown(void);
    99. 

  99. 

  100. #endif /* GRPC_CORE_LIB_SURFACE_COMPLETION_QUEUE_H */
    101.