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.



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

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.



227
228
229
230
231
232
 
# File 'lib/thrift/protocol/json_protocol.rb', line 227

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 



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
219
220
221
 
# File 'lib/thrift/protocol/json_protocol.rb', line 189

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
  elsif (name == "uid")
    result = Types::UUID
  else
    result = Types::STOP
  end
  if (result == Types::STOP)
    raise NotImplementedError
  end
  return result
end

#get_type_name_for_type_id(id) ⇒ Object 



158
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
187
 
# File 'lib/thrift/protocol/json_protocol.rb', line 158

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"
  when Types::UUID
    "uid"
  else
    raise NotImplementedError
  end
end

#is_json_numeric(ch) ⇒ Object

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



235
236
237
238
239
240
241
242
 
# File 'lib/thrift/protocol/json_protocol.rb', line 235

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

#pop_context ⇒ Object 



249
250
251
 
# File 'lib/thrift/protocol/json_protocol.rb', line 249

def pop_context
  @context = @contexts.pop
end

#push_context(context) ⇒ Object 



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

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

#read_binary ⇒ Object 



771
772
773
 
# File 'lib/thrift/protocol/json_protocol.rb', line 771

def read_binary
  read_json_base64
end

#read_bool ⇒ Object 



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

def read_bool
  byte = read_byte
  byte != 0
end

#read_byte ⇒ Object 



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

def read_byte
  read_json_integer
end

#read_double ⇒ Object 



763
764
765
 
# File 'lib/thrift/protocol/json_protocol.rb', line 763

def read_double
  read_json_double
end

#read_field_begin ⇒ Object 



693
694
695
696
697
698
699
700
701
702
703
704
 
# File 'lib/thrift/protocol/json_protocol.rb', line 693

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 



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

def read_field_end
  read_json_object_end
end

#read_i16 ⇒ Object 



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

def read_i16
  read_json_integer
end

#read_i32 ⇒ Object 



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

def read_i32
  read_json_integer
end

#read_i64 ⇒ Object 



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

def read_i64
  read_json_integer
end

#read_json_array_end ⇒ Object 



660
661
662
663
664
 
# File 'lib/thrift/protocol/json_protocol.rb', line 660

def read_json_array_end
  read_json_syntax_char(@@kJSONArrayEnd)
  pop_context
  nil
end

#read_json_array_start ⇒ Object 



653
654
655
656
657
658
 
# File 'lib/thrift/protocol/json_protocol.rb', line 653

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



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

def read_json_base64
  str = read_json_string
  m = str.length % 4
  if m != 0
    # Add missing padding
    (4 - m).times do
      str += '='
    end
  end
  str.unpack1('m0')
end

#read_json_double ⇒ Object

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



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
627
628
629
630
631
632
633
634
635
636
637
638
 
# File 'lib/thrift/protocol/json_protocol.rb', line 602

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



502
503
504
505
506
507
508
 
# File 'lib/thrift/protocol/json_protocol.rb', line 502

def read_json_escape_char
  str = @reader.read
  str += @reader.read
  str += @reader.read
  str += @reader.read
  str.hex.chr(Encoding::UTF_8)
end

#read_json_integer ⇒ Object

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



581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/thrift/protocol/json_protocol.rb', line 581

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.



566
567
568
569
570
571
572
573
574
575
576
577
 
# File 'lib/thrift/protocol/json_protocol.rb', line 566

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 



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

def read_json_object_end
  read_json_syntax_char(@@kJSONObjectEnd)
  pop_context
  nil
end

#read_json_object_start ⇒ Object 



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

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



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
546
547
548
549
 
# File 'lib/thrift/protocol/json_protocol.rb', line 511

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 -> it is. See RFC 4627
  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.



492
493
494
 
# File 'lib/thrift/protocol/json_protocol.rb', line 492

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

#read_list_begin ⇒ Object 



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

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 



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

def read_list_end
  read_json_array_end
end

#read_map_begin ⇒ Object 



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

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 



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

def read_map_end
  read_json_object_end
  read_json_array_end
end

#read_message_begin ⇒ Object 



666
667
668
669
670
671
672
673
674
675
676
 
# File 'lib/thrift/protocol/json_protocol.rb', line 666

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 



678
679
680
681
 
# File 'lib/thrift/protocol/json_protocol.rb', line 678

def read_message_end
  read_json_array_end
  nil
end

#read_set_begin ⇒ Object 



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

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

#read_set_end ⇒ Object 



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

def read_set_end
  read_json_array_end
end

#read_string ⇒ Object 



767
768
769
 
# File 'lib/thrift/protocol/json_protocol.rb', line 767

def read_string
  read_json_string
end

#read_struct_begin ⇒ Object 



683
684
685
686
 
# File 'lib/thrift/protocol/json_protocol.rb', line 683

def read_struct_begin
  read_json_object_start
  nil
end

#read_struct_end ⇒ Object 



688
689
690
691
 
# File 'lib/thrift/protocol/json_protocol.rb', line 688

def read_struct_end
  read_json_object_end
  nil
end

#read_uuid ⇒ Object

Raises:

  • (EOFError) 


775
776
777
778
779
780
 
# File 'lib/thrift/protocol/json_protocol.rb', line 775

def read_uuid
  uuid = read_json_string
  raise EOFError.new if uuid.length < 36
  UUID.validate_uuid!(uuid)
  uuid.tap(&:downcase!)
end

#to_s ⇒ Object 



782
783
784
 
# File 'lib/thrift/protocol/json_protocol.rb', line 782

def to_s
  "json(#{super.to_s})"
end

#write_binary(str) ⇒ Object 



478
479
480
 
# File 'lib/thrift/protocol/json_protocol.rb', line 478

def write_binary(str)
  write_json_base64(str)
end

#write_bool(bool) ⇒ Object 



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

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

#write_byte(byte) ⇒ Object 



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

def write_byte(byte)
  write_json_integer(byte)
end

#write_double(dub) ⇒ Object 



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

def write_double(dub)
  write_json_double(dub)
end

#write_field_begin(name, type, id) ⇒ Object 



405
406
407
408
409
 
# File 'lib/thrift/protocol/json_protocol.rb', line 405

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 



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

def write_field_end
  write_json_object_end
end

#write_field_stop ⇒ Object 



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

def write_field_stop; nil; end

#write_i16(i16) ⇒ Object 



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

def write_i16(i16)
  write_json_integer(i16)
end

#write_i32(i32) ⇒ Object 



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

def write_i32(i32)
  write_json_integer(i32)
end

#write_i64(i64) ⇒ Object 



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

def write_i64(i64)
  write_json_integer(i64)
end

#write_json_array_end ⇒ Object 



380
381
382
383
 
# File 'lib/thrift/protocol/json_protocol.rb', line 380

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

#write_json_array_start ⇒ Object 



374
375
376
377
378
 
# File 'lib/thrift/protocol/json_protocol.rb', line 374

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



313
314
315
316
317
318
 
# File 'lib/thrift/protocol/json_protocol.rb', line 313

def write_json_base64(str)
  @context.write(trans)
  trans.write(@@kJSONStringDelimiter)
  trans.write([str].pack('m0'))
  trans.write(@@kJSONStringDelimiter)
end

#write_json_char(ch) ⇒ Object

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



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
297
298
299
 
# File 'lib/thrift/protocol/json_protocol.rb', line 264

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”.



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

def write_json_double(num)
  @context.write(trans)
  # Normalize output of thrift::to_string 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”)



254
255
256
257
258
259
260
261
 
# File 'lib/thrift/protocol/json_protocol.rb', line 254

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).



322
323
324
325
326
327
328
329
330
331
332
 
# File 'lib/thrift/protocol/json_protocol.rb', line 322

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 



369
370
371
372
 
# File 'lib/thrift/protocol/json_protocol.rb', line 369

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

#write_json_object_start ⇒ Object 



363
364
365
366
367
 
# File 'lib/thrift/protocol/json_protocol.rb', line 363

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.



302
303
304
305
306
307
308
309
 
# File 'lib/thrift/protocol/json_protocol.rb', line 302

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 



430
431
432
433
434
 
# File 'lib/thrift/protocol/json_protocol.rb', line 430

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 



436
437
438
 
# File 'lib/thrift/protocol/json_protocol.rb', line 436

def write_list_end
  write_json_array_end
end

#write_map_begin(ktype, vtype, size) ⇒ Object 



417
418
419
420
421
422
423
 
# File 'lib/thrift/protocol/json_protocol.rb', line 417

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 



425
426
427
428
 
# File 'lib/thrift/protocol/json_protocol.rb', line 425

def write_map_end
  write_json_object_end
  write_json_array_end
end

#write_message_begin(name, type, seqid) ⇒ Object 



385
386
387
388
389
390
391
 
# File 'lib/thrift/protocol/json_protocol.rb', line 385

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 



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

def write_message_end
  write_json_array_end
end

#write_set_begin(etype, size) ⇒ Object 



440
441
442
443
444
 
# File 'lib/thrift/protocol/json_protocol.rb', line 440

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 



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

def write_set_end
  write_json_array_end
end

#write_string(str) ⇒ Object 



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

def write_string(str)
  write_json_string(str)
end

#write_struct_begin(name) ⇒ Object 



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

def write_struct_begin(name)
  write_json_object_start
end

#write_struct_end ⇒ Object 



401
402
403
 
# File 'lib/thrift/protocol/json_protocol.rb', line 401

def write_struct_end
  write_json_object_end
end

#write_uuid(uuid) ⇒ Object 



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

def write_uuid(uuid)
  UUID.validate_uuid!(uuid)
  write_json_string(uuid.downcase)
end