`class Tokens`

Represents a collection of tokens from a source range.

Definitions

`attr_reader :size`

Signature

attribute　Integer: The number of tokens.

`attr_reader :tokens`

Signature

attribute　Array(Token): The array of tokens.

`def initialize(pointer, token_size, translation_unit)`

Initialize a token collection.

Signature

parameter　pointer　FFI::Pointer: The tokens pointer.
parameter　token_size　Integer: The number of tokens.
parameter　translation_unit　TranslationUnit: The parent translation unit.

Implementation

def initialize(pointer, token_size, translation_unit)
	ptr = Lib::TokensPointer.new(pointer,token_size, translation_unit)
	super ptr
	
	@translation_unit = translation_unit
	@size = token_size
	
	@tokens = []
	cur_ptr = pointer
	token_size.times {@tokens << Token.new(cur_ptr, translation_unit)
																			cur_ptr += Lib::CXToken.size
	}
end

`def self.release(pointer)`

Release the tokens pointer.

Signature

parameter　pointer　Lib::TokensPointer: The tokens pointer to release.

Implementation

def self.release(pointer)
	Lib.dispose_tokens(pointer.translation_unit, pointer, pointer.token_size)
end

`def each(&block)`

Iterate over each token.

Signature

yields　{|token| ...}

Each token in the collection.

parameter　token　Token: The token.

Implementation

def each(&block)
	@tokens.each do |token|
		block.call(token)
	end
end

`def cursors`

Get cursors corresponding to each token.

Signature

returns　Array(Cursor): Array of cursors for each token.

Implementation

def cursors
	ptr = MemoryPointer.new(Lib::CXCursor, @size)
	Lib.annotate_tokens(@translation_unit, self, @size, ptr)
	
	cur_ptr = ptr
	arr = []
	@size.times {arr << Cursor.new(cur_ptr, @translation_unit)
														cur_ptr += Lib::CXCursor.size
	}
	arr
end