Class: RubyHDL::High::TypeTuple

Inherits:
Type
  • Object
show all
Defined in:
lib/HDLRuby/std/sequencer_sw.rb

Overview

Describes a tuple type.

Instance Attribute Summary

Attributes inherited from Type

#name

Instance Method Summary collapse

Methods inherited from Type

#[], #binary, #comp_operator, #constant, #define_operator, #define_operator_with_context, #each_overload, #fixed?, #float?, #hierarchical?, #htype?, #inner, #input, #leaf?, #left, #max, #min, #output, #range?, #register, #right, #signed?, #struct?, #to_c, #to_c_init, #to_python_init, #to_tf_init, #to_type, #to_vector, #typedef, #unary, #unsigned?, #vector?

Methods included from HDLRuby::Tprocess

#&, #*, #+, #+@, #-@, #/, #<<, #==, #abs, #lr, #make, #resolve, #slice, #~

Constructor Details

#initialize(name, direction, *content) ⇒ TypeTuple

Creates a new tuple type named name width direction and whose sub types are given by content.



1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1852

def initialize(name,direction,*content)
  # Initialize the type.
  super(name)

  # Set the direction.
  @direction = direction.to_sym
  unless [:little, :big].include?(@direction)
    raise "Invalid direction for a type: #{direction}"
  end

  # Check and set the content.
  content.each do |sub|
    unless sub.is_a?(Type) then
      raise "Invalid class for a type: #{sub.class}"
    end
  end
  @types = content
end

Instance Method Details

#add_type(type) ⇒ Object

Adds a sub type.



1907
1908
1909
1910
1911
1912
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1907

def add_type(type)
  unless type.is_a?(Type) then
    raise "Invalid class for a type: #{type.class} (#{type})"
  end
  @types << type
end

#base ⇒ Object

Gets the base type.

NOTE: only valid if the tuple is regular (i.e., all its sub types are identical)



1993
1994
1995
1996
1997
1998
1999
2000
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1993

def base
  if regular? then
    # Regular tuple, return the type of its first element.
    return @types[0]
  else
    raise "No base type for type #{self}"
  end
end

#base? ⇒ Boolean

Tells if the type has a base.

NOTE: only if the tuple is regular (i.e., all its sub types are identical)

Returns:

  • (Boolean) 


1985
1986
1987
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1985

def base?
  return regular?
end

#direction ⇒ Object

Get the direction of the type, little or big endian.



1964
1965
1966
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1964

def direction
  return @direction
end

#each(&ruby_block) ⇒ Object

Iterates over the sub name/type pair.

Returns an enumerator if no ruby block is given.



1917
1918
1919
1920
1921
1922
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1917

def each(&ruby_block)
  # No ruby block? Return an enumerator.
  return to_enum(:each) unless ruby_block
  # A ruby block? Apply it on each sub name/type pair.
  @types.each(&ruby_block)
end

#each_type(&ruby_block) ⇒ Object

Iterates over the sub types.

Returns an enumerator if no ruby block is given.



1927
1928
1929
1930
1931
1932
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1927

def each_type(&ruby_block)
  # No ruby block? Return an enumerator.
  return to_enum(:each_type) unless ruby_block
  # A ruby block? Apply it on each sub type.
  @types.each(&ruby_block)
end

#each_type_deep(&ruby_block) ⇒ Object Also known as: each_deep

Iterates over the types deeply if any.



1935
1936
1937
1938
1939
1940
1941
1942
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1935

def each_type_deep(&ruby_block)
  # No ruby block? Return an enumerator.
  return to_enum(:each_type_deep) unless ruby_block
  # A ruby block? First apply it to current.
  ruby_block.call(self)
  # And recurse on the sub types.
  @types.each { |type| type.each_type_deep(&ruby_block) }
end

#eql?(obj) ⇒ Boolean

Comparison for hash: structural comparison.

Returns:

  • (Boolean) 


1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1872

def eql?(obj)
  # # General type comparison.
  # return false unless super(obj)
  return false unless obj.is_a?(TypeTuple)
  # Specific comparison.
  idx = 0
  obj.each_type do |type|
    return false unless @types[idx].eql?(type)
    idx += 1
  end
  return false unless idx == @types.size
  return true
end

#equivalent?(type) ⇒ Boolean

Tell if type is equivalent to current type.

NOTE: type can be compatible while not being equivalent, please refer to hruby_types.rb for type compatibility.

Returns:

  • (Boolean) 


2006
2007
2008
2009
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2006

def equivalent?(type)
  return (type.is_a?(TypeTuple) and
          !@types.zip(type.types).index {|t0,t1| !t0.equivalent?(t1) })
end

#get_all_types ⇒ Object

Gets an array containing all the syb types.



1897
1898
1899
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1897

def get_all_types
  return @types.clone
end

#get_type(index) ⇒ Object

Gets a sub type by index.



1902
1903
1904
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1902

def get_type(index)
  return @types[index.to_i]
end

#hash ⇒ Object

Hash function.



1887
1888
1889
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1887

def hash
  return [super,@types].hash
end

#range ⇒ Object

Gets the range of the type.

NOTE: only valid if the tuple is regular (i.e., all its sub types are identical)



1972
1973
1974
1975
1976
1977
1978
1979
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1972

def range
  if regular? then
    # Regular tuple, return its range as if it was an array.
    return 0..@types.size-1
  else
    raise "No range for type #{self}"
  end
end

#regular? ⇒ Boolean

Tell if the tuple is regular, i.e., all its sub types are equivalent.

NOTE: empty tuples are assumed not to be regular.

Returns:

  • (Boolean) 


1949
1950
1951
1952
1953
1954
1955
1956
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1949

def regular?
  return false if @types.empty?
  t0 = @types[0]
  @types[1..-1].each do |type|
    return false unless t0.equivalent?(type)
  end
  return true
end

#types? ⇒ Boolean

Tells if the type has sub types.

Returns:

  • (Boolean) 


1892
1893
1894
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1892

def types?
  return true
end

#width ⇒ Object

Gets the bitwidth.



1959
1960
1961
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1959

def width
  return @types.reduce(0) { |sum,type| sum + type.width }
end