Class: Vertx::RecordParser

Inherits:
Object
  • Object
show all
Includes:
ReadStream
Defined in:
/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb

Overview

A helper class which allows you to easily parse protocols which are delimited by a sequence of bytes, or fixed size records.

Instances of this class take as input Buffer instances containing raw bytes, and output records.

For example, if I had a simple ASCII text protocol delimited by '\n' and the input was the following:


 buffer1:HELLO\nHOW ARE Y
 buffer2:OU?\nI AM
 buffer3: DOING OK
 buffer4:\n
 
Then the output would be:


 buffer1:HELLO
 buffer2:HOW ARE YOU?
 buffer3:I AM DOING OK
 
Instances of this class can be changed between delimited mode and fixed size record mode on the fly as individual records are read, this allows you to parse protocols where, for example, the first 5 records might all be fixed size (of potentially different sizes), followed by some delimited records, followed by more fixed size records.

Instances of this class can't currently be used for protocols where the text is encoded with something other than a 1-1 byte-char mapping.

Please see the documentation for more information.

Constant Summary

@@j_api_type =
Object.new

Class Method Summary (collapse)

Instance Method Summary (collapse)

Class Method Details

+ (Boolean) accept?(obj)

Returns:

  • (Boolean)


52
53
54
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 52

def @@j_api_type.accept?(obj)
  obj.class == RecordParser
end

+ (Object) j_api_type



61
62
63
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 61

def self.j_api_type
  @@j_api_type
end

+ (Object) j_class



64
65
66
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 64

def self.j_class
  Java::IoVertxCoreParsetools::RecordParser.java_class
end

+ (::Vertx::RecordParser) newDelimited(delim) + (::Vertx::RecordParser) newDelimited(delim) + (::Vertx::RecordParser) newDelimited(delim, output) { ... } + (::Vertx::RecordParser) newDelimited(delim, stream) + (::Vertx::RecordParser) newDelimited(delim, output) { ... } + (::Vertx::RecordParser) newDelimited(delim, stream)

Like #new_delimited but wraps the stream. The stream handlers will be set/unset when the #handler is set.

The pause()/resume() operations are propagated to the stream.

Overloads:

Returns:



190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 190

def self.new_delimited(*args)
  if args[0].class == String && !block_given? && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newDelimited, [Java::java.lang.String.java_class]).call(args[0]),::Vertx::RecordParser)
  elsif args[0].class.method_defined?(:j_del) && !block_given? && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newDelimited, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(args[0].j_del),::Vertx::RecordParser)
  elsif args[0].class == String && true && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newDelimited, [Java::java.lang.String.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],(Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) unless !block_given? })),::Vertx::RecordParser)
  elsif args[0].class == String && args[1].class.method_defined?(:j_del) && !block_given?
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newDelimited, [Java::java.lang.String.java_class,Java::IoVertxCoreStreams::ReadStream.java_class]).call(args[0],args[1].j_del),::Vertx::RecordParser)
  elsif args[0].class.method_defined?(:j_del) && true && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newDelimited, [Java::IoVertxCoreBuffer::Buffer.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0].j_del,(Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) unless !block_given? })),::Vertx::RecordParser)
  elsif args[0].class.method_defined?(:j_del) && args[1].class.method_defined?(:j_del) && !block_given?
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newDelimited, [Java::IoVertxCoreBuffer::Buffer.java_class,Java::IoVertxCoreStreams::ReadStream.java_class]).call(args[0].j_del,args[1].j_del),::Vertx::RecordParser)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling new_delimited(#{args[0]},#{args[1]})"
  end
end

+ (::Vertx::RecordParser) newFixed(size) + (::Vertx::RecordParser) newFixed(size, output) { ... } + (::Vertx::RecordParser) newFixed(size, stream)

Like #new_fixed but wraps the stream. The stream handlers will be set/unset when the #handler is set.

The pause()/resume() operations are propagated to the stream.

Overloads:

Returns:



107
108
109
110
111
112
113
114
115
116
117
118
119
120
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 107

def self.new_fixed(*args)
  if args[0].class == Fixnum && !block_given? && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newFixed, [Java::int.java_class]).call(args[0]),::Vertx::RecordParser)
  elsif args[0].class == Fixnum && true && args[1] == nil
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newFixed, [Java::int.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0],(Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) unless !block_given? })),::Vertx::RecordParser)
  elsif args[0].class == Fixnum && args[1].class.method_defined?(:j_del) && !block_given?
    return ::Vertx::Util::Utils.safe_create(Java::IoVertxCoreParsetools::RecordParser.java_method(:newFixed, [Java::int.java_class,Java::IoVertxCoreStreams::ReadStream.java_class]).call(args[0],args[1].j_del),::Vertx::RecordParser)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling new_fixed(#{args[0]},#{args[1]})"
  end
end

+ (Object) unwrap(obj)



58
59
60
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 58

def @@j_api_type.unwrap(obj)
  obj.j_del
end

+ (Object) wrap(obj)



55
56
57
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 55

def @@j_api_type.wrap(obj)
  RecordParser.new(obj)
end

Instance Method Details

- (void) delimitedMode(delim) - (void) delimitedMode(delim)

This method returns an undefined value.

Flip the parser into delimited mode, and where the delimiter can be represented by the delimiter delim.

This method can be called multiple times with different values of delim while data is being parsed.

Overloads:

  • - (void) delimitedMode(delim)

    Parameters:

    • delim (String)
      the new delimeter
  • - (void) delimitedMode(delim)

    Parameters:



144
145
146
147
148
149
150
151
152
153
154
155
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 144

def delimited_mode(*args)
  if args[0].class == String && !block_given?
    return @j_del.java_method(:delimitedMode, [Java::java.lang.String.java_class]).call(args[0])
  elsif args[0].class.method_defined?(:j_del) && !block_given?
    return @j_del.java_method(:delimitedMode, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(args[0].j_del)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling delimited_mode(#{args[0]})"
  end
end

- (self) endHandler(endHandler) { ... }

Yields:

Returns:

  • (self)


239
240
241
242
243
244
245
246
247
248
249
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 239

def end_handler
  if true
    @j_del.java_method(:endHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(nil) unless !block_given? }))
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling end_handler()"
  end
end

- (self) exceptionHandler(handler) { ... }

Yields:

Returns:

  • (self)


316
317
318
319
320
321
322
323
324
325
326
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 316

def exception_handler
  if true
    @j_del.java_method(:exceptionHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.from_throwable(event)) unless !block_given? }))
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling exception_handler()"
  end
end

- (self) fetch(amount)

Parameters:

  • amount (Fixnum)

Returns:

  • (self)


269
270
271
272
273
274
275
276
277
278
279
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 269

def fetch(*args)
  if args[0].class == Fixnum && !block_given?
    @j_del.java_method(:fetch, [Java::long.java_class]).call(args[0])
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling fetch(#{args[0]})"
  end
end

- (void) fixedSizeMode(size)

This method returns an undefined value.

Flip the parser into fixed size mode, where the record size is specified by size in bytes.

This method can be called multiple times with different values of size while data is being parsed.

Parameters:

  • size (Fixnum)
    the new record size


256
257
258
259
260
261
262
263
264
265
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 256

def fixed_size_mode(*args)
  if args[0].class == Fixnum && !block_given?
    return @j_del.java_method(:fixedSizeMode, [Java::int.java_class]).call(args[0])
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling fixed_size_mode(#{args[0]})"
  end
end

- (void) handle(buffer)

This method returns an undefined value.

This method is called to provide the parser with data.

Parameters:



125
126
127
128
129
130
131
132
133
134
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 125

def handle(*args)
  if args[0].class.method_defined?(:j_del) && !block_given?
    return @j_del.java_method(:handle, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(args[0].j_del)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling handle(#{args[0]})"
  end
end

- (self) handler(handler) { ... }

Yields:

Returns:

  • (self)


83
84
85
86
87
88
89
90
91
92
93
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 83

def handler
  if true
    @j_del.java_method(:handler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) unless !block_given? }))
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling handler()"
  end
end

- (self) maxRecordSize(size)

Set the maximum allowed size for a record when using the delimited mode. The delimiter itself does not count for the record size.

If a record is longer than specified, an IllegalStateException will be thrown.

Parameters:

  • size (Fixnum)
    the maximum record size

Returns:

  • (self)


287
288
289
290
291
292
293
294
295
296
297
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 287

def max_record_size(*args)
  if args[0].class == Fixnum && !block_given?
    @j_del.java_method(:maxRecordSize, [Java::int.java_class]).call(args[0])
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling max_record_size(#{args[0]})"
  end
end

- (self) pause

Returns:

  • (self)


158
159
160
161
162
163
164
165
166
167
168
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 158

def pause
  if !block_given?
    @j_del.java_method(:pause, []).call()
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling pause()"
  end
end

- (::Vertx::Pipe) pipe

Pause this stream and return a to transfer the elements of this stream to a destination .

The stream will be resumed when the pipe will be wired to a WriteStream.

Returns:



303
304
305
306
307
308
309
310
311
312
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 303

def pipe
  if !block_given?
    return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:pipe, []).call(),::Vertx::Pipe,::Vertx::Buffer.j_api_type)
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling pipe()"
  end
end

- (void) pipeTo(dst, handler) { ... }

This method returns an undefined value.

Pipe this ReadStream to the WriteStream.

Elements emitted by this stream will be written to the write stream until this stream ends or fails.

Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

Parameters:

Yields:



220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 220

def pipe_to(*args)
  if args[0].class.method_defined?(:j_del) && true
    if (block_given?)
      return @j_del.java_method(:pipeTo, [Java::IoVertxCoreStreams::WriteStream.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0].j_del,block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? nil : nil) } : promise)
    else
      promise = ::Vertx::Util::Utils.promise
      @j_del.java_method(:pipeTo, [Java::IoVertxCoreStreams::WriteStream.java_class,Java::IoVertxCore::Handler.java_class]).call(args[0].j_del,block_given? ? Proc.new { |ar| yield(ar.failed ? ar.cause : nil, ar.succeeded ? nil : nil) } : promise)
      return ::Vertx::Util::Utils.safe_create(promise.future(),::Vertx::Future, nil)
    end
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling pipe_to(#{args[0]})"
  end
end

- (self) resume

Returns:

  • (self)


69
70
71
72
73
74
75
76
77
78
79
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 69

def resume
  if !block_given?
    @j_del.java_method(:resume, []).call()
    return self
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling resume()"
  end
end

- (void) setOutput(output) { ... }

This method returns an undefined value.

Yields:



330
331
332
333
334
335
336
337
338
339
# File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx/record_parser.rb', line 330

def set_output
  if true
    return @j_del.java_method(:setOutput, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) unless !block_given? }))
  end
  if defined?(super)
    super
  else
    raise ArgumentError, "Invalid arguments when calling set_output()"
  end
end