LCOV - code coverage report
Current view: top level - gi - arg.h (source / functions) Hit Total Coverage
Test: gjs- Code Coverage Lines: 15 15 100.0 %
Date: 2023-09-17 02:39:54 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 2 2 100.0 %

           Branch data     Line data    Source code
       1                 :            : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :            : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :            : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :            : 
       5                 :            : #ifndef GI_ARG_H_
       6                 :            : #define GI_ARG_H_
       7                 :            : 
       8                 :            : #include <config.h>
       9                 :            : 
      10                 :            : #include <stddef.h>  // for size_t
      11                 :            : #include <stdint.h>
      12                 :            : 
      13                 :            : #include <girepository.h>
      14                 :            : #include <glib-object.h>
      15                 :            : #include <glib.h>  // for GHashTable
      16                 :            : 
      17                 :            : #include <js/RootingAPI.h>
      18                 :            : #include <js/TypeDecls.h>
      19                 :            : 
      20                 :            : #include "gjs/macros.h"
      21                 :            : 
      22                 :            : // Different roles for a GIArgument; currently used only in exception and debug
      23                 :            : // messages.
      24                 :            : typedef enum {
      25                 :            :     GJS_ARGUMENT_ARGUMENT,
      26                 :            :     GJS_ARGUMENT_RETURN_VALUE,
      27                 :            :     GJS_ARGUMENT_FIELD,
      28                 :            :     GJS_ARGUMENT_LIST_ELEMENT,
      29                 :            :     GJS_ARGUMENT_HASH_ELEMENT,
      30                 :            :     GJS_ARGUMENT_ARRAY_ELEMENT
      31                 :            : } GjsArgumentType;
      32                 :            : 
      33                 :            : enum class GjsArgumentFlags : uint8_t {
      34                 :            :     NONE = 0,
      35                 :            :     MAY_BE_NULL = 1 << 0,
      36                 :            :     CALLER_ALLOCATES = 1 << 1,
      37                 :            :     SKIP_IN = 1 << 2,
      38                 :            :     SKIP_OUT = 1 << 3,
      39                 :            :     SKIP_ALL = SKIP_IN | SKIP_OUT,
      40                 :            :     ARG_IN = 1 << 4,
      41                 :            :     ARG_OUT = 1 << 5,
      42                 :            :     ARG_INOUT = ARG_IN | ARG_OUT,
      43                 :            : };
      44                 :            : 
      45                 :            : // Overload operator| so that Visual Studio won't complain
      46                 :            : // when converting unsigned char to GjsArgumentFlags
      47                 :            : GjsArgumentFlags operator|(GjsArgumentFlags const& v1, GjsArgumentFlags const& v2);
      48                 :            : 
      49                 :            : [[nodiscard]] char* gjs_argument_display_name(const char* arg_name,
      50                 :            :                                               GjsArgumentType arg_type);
      51                 :            : 
      52                 :            : GJS_JSAPI_RETURN_CONVENTION
      53                 :            : bool gjs_value_to_callback_out_arg(JSContext* context, JS::HandleValue value,
      54                 :            :                                    GIArgInfo* arg_info, GIArgument* arg);
      55                 :            : 
      56                 :            : GJS_JSAPI_RETURN_CONVENTION
      57                 :            : bool gjs_array_to_explicit_array(JSContext* cx, JS::HandleValue value,
      58                 :            :                                  GITypeInfo* type_info, const char* arg_name,
      59                 :            :                                  GjsArgumentType arg_type, GITransfer transfer,
      60                 :            :                                  GjsArgumentFlags flags, void** contents,
      61                 :            :                                  size_t* length_p);
      62                 :            : 
      63                 :            : size_t gjs_type_get_element_size(GITypeTag element_type, GITypeInfo* type_info);
      64                 :            : 
      65                 :            : void gjs_gi_argument_init_default(GITypeInfo* type_info, GIArgument* arg);
      66                 :            : 
      67                 :            : GJS_JSAPI_RETURN_CONVENTION
      68                 :            : bool gjs_value_to_g_argument(JSContext* cx, JS::HandleValue value,
      69                 :            :                              GITypeInfo* type_info, const char* arg_name,
      70                 :            :                              GjsArgumentType argument_type, GITransfer transfer,
      71                 :            :                              GjsArgumentFlags flags, GIArgument* arg);
      72                 :            : 
      73                 :            : GJS_JSAPI_RETURN_CONVENTION
      74                 :        394 : bool inline gjs_value_to_g_argument(JSContext* cx, JS::HandleValue value,
      75                 :            :                                     GITypeInfo* type_info,
      76                 :            :                                     GjsArgumentType argument_type,
      77                 :            :                                     GITransfer transfer, GIArgument* arg) {
      78                 :        394 :     return gjs_value_to_g_argument(cx, value, type_info, nullptr /* arg_name */,
      79                 :            :                                    argument_type, transfer,
      80                 :        394 :                                    GjsArgumentFlags::NONE, arg);
      81                 :            : }
      82                 :            : 
      83                 :            : GJS_JSAPI_RETURN_CONVENTION
      84                 :            : bool gjs_value_from_g_argument(JSContext* context,
      85                 :            :                                JS::MutableHandleValue value_p,
      86                 :            :                                GITypeInfo* type_info,
      87                 :            :                                GjsArgumentType argument_type,
      88                 :            :                                GITransfer transfer, GIArgument* arg);
      89                 :            : 
      90                 :            : GJS_JSAPI_RETURN_CONVENTION
      91                 :      37823 : inline bool gjs_value_from_g_argument(JSContext* cx,
      92                 :            :                                       JS::MutableHandleValue value_p,
      93                 :            :                                       GITypeInfo* type_info, GIArgument* arg,
      94                 :            :                                       bool copy_structs) {
      95         [ +  + ]:      37823 :     return gjs_value_from_g_argument(
      96                 :            :         cx, value_p, type_info, GJS_ARGUMENT_ARGUMENT,
      97                 :      37823 :         copy_structs ? GI_TRANSFER_EVERYTHING : GI_TRANSFER_NOTHING, arg);
      98                 :            : }
      99                 :            : 
     100                 :            : GJS_JSAPI_RETURN_CONVENTION
     101                 :            : bool gjs_value_from_explicit_array(JSContext* context,
     102                 :            :                                    JS::MutableHandleValue value_p,
     103                 :            :                                    GITypeInfo* type_info, GITransfer transfer,
     104                 :            :                                    GIArgument* arg, int length);
     105                 :            : 
     106                 :            : GJS_JSAPI_RETURN_CONVENTION
     107                 :          2 : inline bool gjs_value_from_explicit_array(JSContext* context,
     108                 :            :                                           JS::MutableHandleValue value_p,
     109                 :            :                                           GITypeInfo* type_info,
     110                 :            :                                           GIArgument* arg, int length) {
     111                 :          2 :     return gjs_value_from_explicit_array(context, value_p, type_info,
     112                 :          2 :                                          GI_TRANSFER_EVERYTHING, arg, length);
     113                 :            : }
     114                 :            : 
     115                 :            : GJS_JSAPI_RETURN_CONVENTION
     116                 :            : bool gjs_g_argument_release(JSContext*, GITransfer, GITypeInfo*,
     117                 :            :                             GjsArgumentFlags, GIArgument*);
     118                 :            : GJS_JSAPI_RETURN_CONVENTION
     119                 :      34703 : inline bool gjs_g_argument_release(JSContext* cx, GITransfer transfer,
     120                 :            :                                    GITypeInfo* type_info, GIArgument* arg) {
     121                 :      34703 :     return gjs_g_argument_release(cx, transfer, type_info,
     122                 :      34703 :                                   GjsArgumentFlags::NONE, arg);
     123                 :            : }
     124                 :            : GJS_JSAPI_RETURN_CONVENTION
     125                 :            : bool gjs_g_argument_release_out_array(JSContext* cx, GITransfer transfer,
     126                 :            :                                       GITypeInfo* type_info, unsigned length,
     127                 :            :                                       GIArgument* arg);
     128                 :            : GJS_JSAPI_RETURN_CONVENTION
     129                 :            : bool gjs_g_argument_release_out_array(JSContext* cx, GITransfer transfer,
     130                 :            :                                       GITypeInfo* type_info, GIArgument* arg);
     131                 :            : GJS_JSAPI_RETURN_CONVENTION
     132                 :            : bool gjs_g_argument_release_in_array(JSContext* cx, GITransfer transfer,
     133                 :            :                                      GITypeInfo* type_info, unsigned length,
     134                 :            :                                      GIArgument* arg);
     135                 :            : GJS_JSAPI_RETURN_CONVENTION
     136                 :            : bool gjs_g_argument_release_in_array(JSContext* cx, GITransfer transfer,
     137                 :            :                                      GITypeInfo* type_info, GIArgument* arg);
     138                 :            : GJS_JSAPI_RETURN_CONVENTION
     139                 :            : bool gjs_g_argument_release_in_arg(JSContext*, GITransfer, GITypeInfo*,
     140                 :            :                                    GjsArgumentFlags, GIArgument*);
     141                 :            : GJS_JSAPI_RETURN_CONVENTION
     142                 :         75 : inline bool gjs_g_argument_release_in_arg(JSContext* cx, GITransfer transfer,
     143                 :            :                                           GITypeInfo* type_info,
     144                 :            :                                           GIArgument* arg) {
     145                 :         75 :     return gjs_g_argument_release_in_arg(cx, transfer, type_info,
     146                 :         75 :                                          GjsArgumentFlags::ARG_IN, arg);
     147                 :            : }
     148                 :            : 
     149                 :            : GJS_JSAPI_RETURN_CONVENTION
     150                 :            : bool _gjs_flags_value_is_valid(JSContext* cx, GType gtype, int64_t value);
     151                 :            : 
     152                 :            : [[nodiscard]] int64_t _gjs_enum_from_int(GIEnumInfo* enum_info, int int_value);
     153                 :            : 
     154                 :            : GJS_JSAPI_RETURN_CONVENTION
     155                 :            : bool gjs_array_from_strv(JSContext             *context,
     156                 :            :                          JS::MutableHandleValue value_p,
     157                 :            :                          const char           **strv);
     158                 :            : 
     159                 :            : GJS_JSAPI_RETURN_CONVENTION
     160                 :            : bool gjs_array_to_strv (JSContext   *context,
     161                 :            :                         JS::Value    array_value,
     162                 :            :                         unsigned int length,
     163                 :            :                         void       **arr_p);
     164                 :            : 
     165                 :            : GJS_JSAPI_RETURN_CONVENTION
     166                 :            : bool gjs_array_from_g_value_array(JSContext* cx, JS::MutableHandleValue value_p,
     167                 :            :                                   GITypeInfo* param_info, GITransfer,
     168                 :            :                                   const GValue* gvalue);
     169                 :            : 
     170                 :            : GJS_JSAPI_RETURN_CONVENTION
     171                 :            : bool gjs_object_from_g_hash(JSContext* cx, JS::MutableHandleValue,
     172                 :            :                             GITypeInfo* key_param_info,
     173                 :            :                             GITypeInfo* val_param_info, GITransfer transfer,
     174                 :            :                             GHashTable* hash);
     175                 :            : 
     176                 :            : #endif  // GI_ARG_H_

Generated by: LCOV version 1.14