Class: Thrift::JsonProtocol

Inherits:
BaseProtocol show all
Defined in:
lib/thrift/protocol/json_protocol.rb

Constant Summary collapse

@@kJSONObjectStart = 
'{'
@@kJSONObjectEnd = 
'}'
@@kJSONArrayStart = 
'['
@@kJSONArrayEnd = 
']'
@@kJSONNewline = 
'\n'
@@kJSONBackslash = 
'\\'
@@kJSONStringDelimiter = 
'"'
@@kThriftVersion1 = 
1
@@kThriftNan = 
"NaN"
@@kThriftInfinity = 
"Infinity"
@@kThriftNegativeInfinity = 
"-Infinity"

Instance Attribute Summary

Attributes inherited from BaseProtocol

#trans

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from BaseProtocol

#native?, #read_type, #skip, #write_field, #write_type

Constructor Details

#initialize(trans) ⇒ JsonProtocol

Returns a new instance of JsonProtocol.



152
153
154
155
156
157
 
# File 'lib/thrift/protocol/json_protocol.rb', line 152

def initialize(trans)
  super(trans)
  @context = JSONContext.new
  @contexts = Array.new
  @reader = LookaheadReader.new(trans)
end

Class Method Details

.read_syntax_char(reader, ch) ⇒ Object

Read 1 character from the trans and verify that it is the expected character ch. Throw a protocol exception if it is not.



224
225
226
227
228
229
 
# File 'lib/thrift/protocol/json_protocol.rb', line 224

def self.read_syntax_char(reader, ch)
  ch2 = reader.read
  if (ch2 != ch)
    raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected \'#{ch}\' got \'#{ch2}\'.")
  end
end

Instance Method Details

#get_type_id_for_type_name(name) ⇒ Object 



188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/thrift/protocol/json_protocol.rb', line 188

def get_type_id_for_type_name(name)
  if (name == "tf")
    result = Types::BOOL
  elsif (name == "i8")
    result = Types::BYTE
  elsif (name == "i16")
    result = Types::I16
  elsif (name == "i32")
    result = Types::I32
  elsif (name == "i64")
    result = Types::I64
  elsif (name == "dbl")
    result = Types::DOUBLE
  elsif (name == "str")
    result = Types::STRING
  elsif (name == "rec")
    result = Types::STRUCT
  elsif (name == "map")
    result = Types::MAP
  elsif (name == "set")
    result = Types::SET
  elsif (name == "lst")
    result = Types::LIST
  else
    result = Types::STOP
  end
  if (result == Types::STOP)
    raise NotImplementedError
  end
  return result
end

#get_type_name_for_type_id(id) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/thrift/protocol/json_protocol.rb', line 159

def get_type_name_for_type_id(id)
  case id
  when Types::BOOL
    "tf"
  when Types::BYTE
    "i8"
  when Types::I16
    "i16"
  when Types::I32
    "i32"
  when Types::I64
    "i64"
  when Types::DOUBLE
    "dbl"
  when Types::STRING
    "str"
  when Types::STRUCT
    "rec"
  when Types::MAP
    "map"
  when Types::SET
    "set"
  when Types::LIST
    "lst"
  else
    raise NotImplementedError
  end
end

#is_json_numeric(ch) ⇒ Object

Return true if the character ch is in [-+0-9.Ee]; false otherwise



232
233
234
235
236
237
238
239
 
# File 'lib/thrift/protocol/json_protocol.rb', line 232

def is_json_numeric(ch)
  case ch
  when '+', '-', '.', '0' .. '9', 'E', "e"
    return true
  else
    return false
  end
end

#pop_context ⇒ Object 



246
247
248
 
# File 'lib/thrift/protocol/json_protocol.rb', line 246

def pop_context
  @context = @contexts.pop
end

#push_context(context) ⇒ Object 



241
242
243
244
 
# File 'lib/thrift/protocol/json_protocol.rb', line 241

def push_context(context)
  @contexts.push(@context)
  @context = context
end

#read_binary ⇒ Object 



758
759
760
 
# File 'lib/thrift/protocol/json_protocol.rb', line 758

def read_binary
  read_json_base64
end

#read_bool ⇒ Object 



729
730
731
732
 
# File 'lib/thrift/protocol/json_protocol.rb', line 729

def read_bool
  byte = read_byte
  byte != 0
end

#read_byte ⇒ Object 



734
735
736
 
# File 'lib/thrift/protocol/json_protocol.rb', line 734

def read_byte
  read_json_integer
end

#read_double ⇒ Object 



750
751
752
 
# File 'lib/thrift/protocol/json_protocol.rb', line 750

def read_double
  read_json_double
end

#read_field_begin ⇒ Object 



681
682
683
684
685
686
687
688
689
690
691
692
 
# File 'lib/thrift/protocol/json_protocol.rb', line 681

def read_field_begin
  # Check if we hit the end of the list
  ch = @reader.peek
  if (ch == @@kJSONObjectEnd)
    field_type = Types::STOP
  else
    field_id = read_json_integer
    read_json_object_start
    field_type = get_type_id_for_type_name(read_json_string)
  end
  [nil, field_type, field_id]
end

#read_field_end ⇒ Object 



694
695
696
 
# File 'lib/thrift/protocol/json_protocol.rb', line 694

def read_field_end
  read_json_object_end
end

#read_i16 ⇒ Object 



738
739
740
 
# File 'lib/thrift/protocol/json_protocol.rb', line 738

def read_i16
  read_json_integer
end

#read_i32 ⇒ Object 



742
743
744
 
# File 'lib/thrift/protocol/json_protocol.rb', line 742

def read_i32
  read_json_integer
end

#read_i64 ⇒ Object 



746
747
748
 
# File 'lib/thrift/protocol/json_protocol.rb', line 746

def read_i64
  read_json_integer
end

#read_json_array_end ⇒ Object 



648
649
650
651
652
 
# File 'lib/thrift/protocol/json_protocol.rb', line 648

def read_json_array_end
  read_json_syntax_char(@@kJSONArrayEnd)
  pop_context
  nil
end

#read_json_array_start ⇒ Object 



641
642
643
644
645
646
 
# File 'lib/thrift/protocol/json_protocol.rb', line 641

def read_json_array_start
  @context.read(@reader)
  read_json_syntax_char(@@kJSONArrayStart)
  push_context(JSONListContext.new)
  nil
end

#read_json_base64 ⇒ Object

Reads a block of base64 characters, decoding it, and returns via str



548
549
550
 
# File 'lib/thrift/protocol/json_protocol.rb', line 548

def read_json_base64
  read_json_string.unpack("m")[0]
end

#read_json_double ⇒ Object

Reads a JSON number or string and interprets it as a double.



590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
 
# File 'lib/thrift/protocol/json_protocol.rb', line 590

def read_json_double
  @context.read(@reader)
  num = 0
  if (@reader.peek == @@kJSONStringDelimiter)
    str = read_json_string(true)
    # Check for NaN, Infinity and -Infinity
    if (str == @@kThriftNan)
      num = (+1.0/0.0)/(+1.0/0.0)
    elsif (str == @@kThriftInfinity)
      num = +1.0/0.0
    elsif (str == @@kThriftNegativeInfinity)
      num = -1.0/0.0
    else
      if (!@context.escapeNum)
        # Raise exception -- we should not be in a string in this case
        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Numeric data unexpectedly quoted")
      end
      begin
        num = Float(str)
      rescue
        raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
      end
    end
  else
    if (@context.escapeNum)
      # This will throw - we should have had a quote if escapeNum == true
      read_json_syntax_char(@@kJSONStringDelimiter)
    end
    str = read_json_numeric_chars
    begin
      num = Float(str)
    rescue
      raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
    end
  end
  return num
end

#read_json_escape_char ⇒ Object

Decodes the four hex parts of a JSON escaped string character and returns the character via out.

Note - this only supports Unicode characters in the BMP (U+0000 to U+FFFF); characters above the BMP are encoded as two escape sequences (surrogate pairs), which is not yet implemented



494
495
496
497
498
499
500
501
502
503
504
 
# File 'lib/thrift/protocol/json_protocol.rb', line 494

def read_json_escape_char
  str = @reader.read
  str += @reader.read
  str += @reader.read
  str += @reader.read
  if RUBY_VERSION >= '1.9'
    str.hex.chr(Encoding::UTF_8)
  else
    str.hex.chr
  end
end

#read_json_integer ⇒ Object

Reads a sequence of characters and assembles them into a number, returning them via num



569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
 
# File 'lib/thrift/protocol/json_protocol.rb', line 569

def read_json_integer
  @context.read(@reader)
  if (@context.escapeNum)
    read_json_syntax_char(@@kJSONStringDelimiter)
  end
  str = read_json_numeric_chars

  begin
    num = Integer(str);
  rescue
    raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected numeric value; got \"#{str}\"")
  end

  if (@context.escapeNum)
    read_json_syntax_char(@@kJSONStringDelimiter)
  end

  return num
end

#read_json_numeric_chars ⇒ Object

Reads a sequence of characters, stopping at the first one that is not a valid JSON numeric character.



554
555
556
557
558
559
560
561
562
563
564
565
 
# File 'lib/thrift/protocol/json_protocol.rb', line 554

def read_json_numeric_chars
  str = ""
  while (true)
    ch = @reader.peek
    if (!is_json_numeric(ch))
      break;
    end
    ch = @reader.read
    str += ch
  end
  return str
end

#read_json_object_end ⇒ Object 



635
636
637
638
639
 
# File 'lib/thrift/protocol/json_protocol.rb', line 635

def read_json_object_end
  read_json_syntax_char(@@kJSONObjectEnd)
  pop_context
  nil
end

#read_json_object_start ⇒ Object 



628
629
630
631
632
633
 
# File 'lib/thrift/protocol/json_protocol.rb', line 628

def read_json_object_start
  @context.read(@reader)
  read_json_syntax_char(@@kJSONObjectStart)
  push_context(JSONPairContext.new)
  nil
end

#read_json_string(skipContext = false) ⇒ Object

Decodes a JSON string, including unescaping, and returns the string via str



507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
 
# File 'lib/thrift/protocol/json_protocol.rb', line 507

def read_json_string(skipContext = false)
  # This string's characters must match up with the elements in escape_char_vals.
  # I don't have '/' on this list even though it appears on www.json.org --
  # it is not in the RFC
  escape_chars = "\"\\bfnrt"

  # The elements of this array must match up with the sequence of characters in
  # escape_chars
  escape_char_vals = [
    '"', '\\', '\b', '\f', '\n', '\r', '\t',
  ]

  if !skipContext
    @context.read(@reader)
  end
  read_json_syntax_char(@@kJSONStringDelimiter)
  ch = ""
  str = ""
  while (true)
    ch = @reader.read
    if (ch == @@kJSONStringDelimiter)
      break
    end
    if (ch == @@kJSONBackslash)
      ch = @reader.read
      if (ch == 'u')
        ch = read_json_escape_char
      else
        pos = escape_chars.index(ch);
        if (pos.nil?) # not found
          raise ProtocolException.new(ProtocolException::INVALID_DATA, "Expected control char, got \'#{ch}\'.")
        end
        ch = escape_char_vals[pos]
      end
    end
    str += ch
  end
  return str
end

#read_json_syntax_char(ch) ⇒ Object

Reads 1 byte and verifies that it matches ch.



484
485
486
 
# File 'lib/thrift/protocol/json_protocol.rb', line 484

def read_json_syntax_char(ch)
  JsonProtocol::read_syntax_char(@reader, ch)
end

#read_list_begin ⇒ Object 



712
713
714
715
 
# File 'lib/thrift/protocol/json_protocol.rb', line 712

def read_list_begin
  read_json_array_start
  [get_type_id_for_type_name(read_json_string), read_json_integer]
end

#read_list_end ⇒ Object 



717
718
719
 
# File 'lib/thrift/protocol/json_protocol.rb', line 717

def read_list_end
  read_json_array_end
end

#read_map_begin ⇒ Object 



698
699
700
701
702
703
704
705
 
# File 'lib/thrift/protocol/json_protocol.rb', line 698

def read_map_begin
  read_json_array_start
  key_type = get_type_id_for_type_name(read_json_string)
  val_type = get_type_id_for_type_name(read_json_string)
  size = read_json_integer
  read_json_object_start
  [key_type, val_type, size]
end

#read_map_end ⇒ Object 



707
708
709
710
 
# File 'lib/thrift/protocol/json_protocol.rb', line 707

def read_map_end
  read_json_object_end
  read_json_array_end
end

#read_message_begin ⇒ Object 



654
655
656
657
658
659
660
661
662
663
664
 
# File 'lib/thrift/protocol/json_protocol.rb', line 654

def read_message_begin
  read_json_array_start
  version = read_json_integer
  if (version != @@kThriftVersion1)
    raise ProtocolException.new(ProtocolException::BAD_VERSION, 'Message contained bad version.')
  end
  name = read_json_string
  message_type = read_json_integer
  seqid = read_json_integer
  [name, message_type, seqid]
end

#read_message_end ⇒ Object 



666
667
668
669
 
# File 'lib/thrift/protocol/json_protocol.rb', line 666

def read_message_end
  read_json_array_end
  nil
end

#read_set_begin ⇒ Object 



721
722
723
 
# File 'lib/thrift/protocol/json_protocol.rb', line 721

def read_set_begin
  read_json_array_start
end

#read_set_end ⇒ Object 



725
726
727
 
# File 'lib/thrift/protocol/json_protocol.rb', line 725

def read_set_end
  read_json_array_end
end

#read_string ⇒ Object 



754
755
756
 
# File 'lib/thrift/protocol/json_protocol.rb', line 754

def read_string
  read_json_string
end

#read_struct_begin ⇒ Object 



671
672
673
674
 
# File 'lib/thrift/protocol/json_protocol.rb', line 671

def read_struct_begin
  read_json_object_start
  nil
end

#read_struct_end ⇒ Object 



676
677
678
679
 
# File 'lib/thrift/protocol/json_protocol.rb', line 676

def read_struct_end
  read_json_object_end
  nil
end

#write_binary(str) ⇒ Object 



475
476
477
 
# File 'lib/thrift/protocol/json_protocol.rb', line 475

def write_binary(str)
  write_json_base64(str)
end

#write_bool(bool) ⇒ Object 



447
448
449
 
# File 'lib/thrift/protocol/json_protocol.rb', line 447

def write_bool(bool)
  write_json_integer(bool ? 1 : 0)
end

#write_byte(byte) ⇒ Object 



451
452
453
 
# File 'lib/thrift/protocol/json_protocol.rb', line 451

def write_byte(byte)
  write_json_integer(byte)
end

#write_double(dub) ⇒ Object 



467
468
469
 
# File 'lib/thrift/protocol/json_protocol.rb', line 467

def write_double(dub)
  write_json_double(dub)
end

#write_field_begin(name, type, id) ⇒ Object 



402
403
404
405
406
 
# File 'lib/thrift/protocol/json_protocol.rb', line 402

def write_field_begin(name, type, id)
  write_json_integer(id)
  write_json_object_start
  write_json_string(get_type_name_for_type_id(type))
end

#write_field_end ⇒ Object 



408
409
410
 
# File 'lib/thrift/protocol/json_protocol.rb', line 408

def write_field_end
  write_json_object_end
end

#write_field_stop ⇒ Object 



412
 
# File 'lib/thrift/protocol/json_protocol.rb', line 412

def write_field_stop; nil; end

#write_i16(i16) ⇒ Object 



455
456
457
 
# File 'lib/thrift/protocol/json_protocol.rb', line 455

def write_i16(i16)
  write_json_integer(i16)
end

#write_i32(i32) ⇒ Object 



459
460
461
 
# File 'lib/thrift/protocol/json_protocol.rb', line 459

def write_i32(i32)
  write_json_integer(i32)
end

#write_i64(i64) ⇒ Object 



463
464
465
 
# File 'lib/thrift/protocol/json_protocol.rb', line 463

def write_i64(i64)
  write_json_integer(i64)
end

#write_json_array_end ⇒ Object 



377
378
379
380
 
# File 'lib/thrift/protocol/json_protocol.rb', line 377

def write_json_array_end
  pop_context
  trans.write(@@kJSONArrayEnd)
end

#write_json_array_start ⇒ Object 



371
372
373
374
375
 
# File 'lib/thrift/protocol/json_protocol.rb', line 371

def write_json_array_start
  @context.write(trans)
  trans.write(@@kJSONArrayStart)
  push_context(JSONListContext.new);
end

#write_json_base64(str) ⇒ Object

Write out the contents of the string as JSON string, base64-encoding the string’s contents, and escaping as appropriate



310
311
312
313
314
315
 
# File 'lib/thrift/protocol/json_protocol.rb', line 310

def write_json_base64(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  write_json_string([str].pack("m"))
  trans.write(@@kJSONStringDelimiter)
end

#write_json_char(ch) ⇒ Object

Write the character ch as part of a JSON string, escaping as appropriate.



261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/thrift/protocol/json_protocol.rb', line 261

def write_json_char(ch)
  # This table describes the handling for the first 0x30 characters
  # 0 : escape using "\u00xx" notation
  # 1 : just output index
  # <other> : escape using "\<other>" notation
  kJSONCharTable = [
      # 0 1 2 3 4 5 6 7 8 9 A B C D E F
      0, 0, 0, 0, 0, 0, 0, 0,'b','t','n', 0,'f','r', 0, 0, # 0
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, # 1
      1, 1,'"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, # 2
  ]

  ch_value = ch[0]
  if (ch_value.kind_of? String)
    ch_value = ch.bytes.first
  end
  if (ch_value >= 0x30)
    if (ch == @@kJSONBackslash) # Only special character >= 0x30 is '\'
      trans.write(@@kJSONBackslash)
      trans.write(@@kJSONBackslash)
    else
      trans.write(ch)
    end
  else
    outCh = kJSONCharTable[ch_value];
    # Check if regular character, backslash escaped, or JSON escaped
    if outCh.kind_of? String
      trans.write(@@kJSONBackslash)
      trans.write(outCh)
    elsif outCh == 1
      trans.write(ch)
    else
      write_json_escape_char(ch)
    end
  end
end

#write_json_double(num) ⇒ Object

Convert the given double to a JSON string, which is either the number, “NaN” or “Infinity” or “-Infinity”.



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/thrift/protocol/json_protocol.rb', line 333

def write_json_double(num)
  @context.write(trans)
  # Normalize output of boost::lexical_cast for NaNs and Infinities
  special = false;
  if (num.nan?)
    special = true;
    val = @@kThriftNan;
  elsif (num.infinite?)
    special = true;
    val = @@kThriftInfinity;
    if (num < 0.0)
      val = @@kThriftNegativeInfinity;
    end
  else
    val = num.to_s
  end

  escapeNum = special || @context.escapeNum
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
  trans.write(val)
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
end

#write_json_escape_char(ch) ⇒ Object

Write the character ch as a JSON escape sequence (“u00xx”)



251
252
253
254
255
256
257
258
 
# File 'lib/thrift/protocol/json_protocol.rb', line 251

def write_json_escape_char(ch)
  trans.write('\\u')
  ch_value = ch[0]
  if (ch_value.kind_of? String)
    ch_value = ch.bytes.first
  end
  trans.write(ch_value.to_s(16).rjust(4,'0'))
end

#write_json_integer(num) ⇒ Object

Convert the given integer type to a JSON number, or a string if the context requires it (eg: key in a map pair).



319
320
321
322
323
324
325
326
327
328
329
 
# File 'lib/thrift/protocol/json_protocol.rb', line 319

def write_json_integer(num)
  @context.write(trans)
  escapeNum = @context.escapeNum
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
  trans.write(num.to_s);
  if (escapeNum)
    trans.write(@@kJSONStringDelimiter)
  end
end

#write_json_object_end ⇒ Object 



366
367
368
369
 
# File 'lib/thrift/protocol/json_protocol.rb', line 366

def write_json_object_end
  pop_context
  trans.write(@@kJSONObjectEnd)
end

#write_json_object_start ⇒ Object 



360
361
362
363
364
 
# File 'lib/thrift/protocol/json_protocol.rb', line 360

def write_json_object_start
  @context.write(trans)
  trans.write(@@kJSONObjectStart)
  push_context(JSONPairContext.new);
end

#write_json_string(str) ⇒ Object

Write out the contents of the string str as a JSON string, escaping characters as appropriate.



299
300
301
302
303
304
305
306
 
# File 'lib/thrift/protocol/json_protocol.rb', line 299

def write_json_string(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  str.split('').each do |ch|
    write_json_char(ch)
  end
  trans.write(@@kJSONStringDelimiter)
end

#write_list_begin(etype, size) ⇒ Object 



427
428
429
430
431
 
# File 'lib/thrift/protocol/json_protocol.rb', line 427

def write_list_begin(etype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(etype))
  write_json_integer(size)
end

#write_list_end ⇒ Object 



433
434
435
 
# File 'lib/thrift/protocol/json_protocol.rb', line 433

def write_list_end
  write_json_array_end
end

#write_map_begin(ktype, vtype, size) ⇒ Object 



414
415
416
417
418
419
420
 
# File 'lib/thrift/protocol/json_protocol.rb', line 414

def write_map_begin(ktype, vtype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(ktype))
  write_json_string(get_type_name_for_type_id(vtype))
  write_json_integer(size)
  write_json_object_start
end

#write_map_end ⇒ Object 



422
423
424
425
 
# File 'lib/thrift/protocol/json_protocol.rb', line 422

def write_map_end
  write_json_object_end
  write_json_array_end
end

#write_message_begin(name, type, seqid) ⇒ Object 



382
383
384
385
386
387
388
 
# File 'lib/thrift/protocol/json_protocol.rb', line 382

def write_message_begin(name, type, seqid)
  write_json_array_start
  write_json_integer(@@kThriftVersion1)
  write_json_string(name)
  write_json_integer(type)
  write_json_integer(seqid)
end

#write_message_end ⇒ Object 



390
391
392
 
# File 'lib/thrift/protocol/json_protocol.rb', line 390

def write_message_end
  write_json_array_end
end

#write_set_begin(etype, size) ⇒ Object 



437
438
439
440
441
 
# File 'lib/thrift/protocol/json_protocol.rb', line 437

def write_set_begin(etype, size)
  write_json_array_start
  write_json_string(get_type_name_for_type_id(etype))
  write_json_integer(size)
end

#write_set_end ⇒ Object 



443
444
445
 
# File 'lib/thrift/protocol/json_protocol.rb', line 443

def write_set_end
  write_json_array_end
end

#write_string(str) ⇒ Object 



471
472
473
 
# File 'lib/thrift/protocol/json_protocol.rb', line 471

def write_string(str)
  write_json_string(str)
end

#write_struct_begin(name) ⇒ Object 



394
395
396
 
# File 'lib/thrift/protocol/json_protocol.rb', line 394

def write_struct_begin(name)
  write_json_object_start
end

#write_struct_end ⇒ Object 



398
399
400
 
# File 'lib/thrift/protocol/json_protocol.rb', line 398

def write_struct_end
  write_json_object_end
end