1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2014 Google Inc. All rights reserved. 3 // https://developers.google.com/protocol-buffers/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 #ifndef __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__ 32 #define __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__ 33 34 #include <ruby/encoding.h> 35 #include <ruby/ruby.h> 36 #include <ruby/vm.h> 37 38 #include "defs.h" 39 #include "ruby-upb.h" 40 41 // These operate on a map field (i.e., a repeated field of submessages whose 42 // submessage type is a map-entry msgdef). 43 const upb_FieldDef* map_field_key(const upb_FieldDef* field); 44 const upb_FieldDef* map_field_value(const upb_FieldDef* field); 45 46 // ----------------------------------------------------------------------------- 47 // Arena 48 // ----------------------------------------------------------------------------- 49 50 // A Ruby object that wraps an underlying upb_Arena. Any objects that are 51 // allocated from this arena should reference the Arena in rb_gc_mark(), to 52 // ensure that the object's underlying memory outlives any Ruby object that can 53 // reach it. 54 55 VALUE Arena_new(); 56 upb_Arena* Arena_get(VALUE arena); 57 58 // Fuses this arena to another, throwing a Ruby exception if this is not 59 // possible. 60 void Arena_fuse(VALUE arena, upb_Arena* other); 61 62 // Pins this Ruby object to the lifetime of this arena, so that as long as the 63 // arena is alive this object will not be collected. 64 // 65 // We use this to guarantee that the "frozen" bit on the object will be 66 // remembered, even if the user drops their reference to this precise object. 67 void Arena_Pin(VALUE arena, VALUE obj); 68 69 // ----------------------------------------------------------------------------- 70 // ObjectCache 71 // ----------------------------------------------------------------------------- 72 73 // Global object cache from upb array/map/message/symtab to wrapper object. 74 // 75 // This is a conceptually "weak" cache, in that it does not prevent "val" from 76 // being collected (though in Ruby <2.7 is it effectively strong, due to 77 // implementation limitations). 78 79 // Adds an entry to the cache. The "arena" parameter must give the arena that 80 // "key" was allocated from. In Ruby <2.7.0, it will be used to remove the key 81 // from the cache when the arena is destroyed. 82 void ObjectCache_Add(const void* key, VALUE val); 83 84 // Returns the cached object for this key, if any. Otherwise returns Qnil. 85 VALUE ObjectCache_Get(const void* key); 86 87 // ----------------------------------------------------------------------------- 88 // StringBuilder, for inspect 89 // ----------------------------------------------------------------------------- 90 91 struct StringBuilder; 92 typedef struct StringBuilder StringBuilder; 93 94 StringBuilder* StringBuilder_New(); 95 void StringBuilder_Free(StringBuilder* b); 96 void StringBuilder_Printf(StringBuilder* b, const char* fmt, ...); 97 VALUE StringBuilder_ToRubyString(StringBuilder* b); 98 99 void StringBuilder_PrintMsgval(StringBuilder* b, upb_MessageValue val, 100 TypeInfo info); 101 102 // ----------------------------------------------------------------------------- 103 // Utilities. 104 // ----------------------------------------------------------------------------- 105 106 extern VALUE cTypeError; 107 108 #ifdef NDEBUG 109 #define PBRUBY_ASSERT(expr) \ 110 do { \ 111 } while (false && (expr)) 112 #else 113 #define PBRUBY_ASSERT(expr) assert(expr) 114 #endif 115 116 #define PBRUBY_MAX(x, y) (((x) > (y)) ? (x) : (y)) 117 118 #define UPB_UNUSED(var) (void)var 119 120 #endif // __GOOGLE_PROTOBUF_RUBY_PROTOBUF_H__ 121