virtual class queue #( type T = bit, int SIZE = 1 )
A parameterized class that manages a queue.
| T | optional The type of a queue. The default type is bit. |
| SIZE | optional The size of an unpacked array. This parameter is used only if a queue is converted from/to an unpacked array. The default is 1. |
| queue | A parameterized class that manages a queue. |
| Common Arguments | |
| Types | |
| ua_type | The shorthand of the unpacked array of type T. |
| da_type | The shorthand of the dynamic array of type T. |
| q_type | The shorthand of the queue of type T. |
| Functions | |
| from_unpacked_array | static Converts an unpacked array of type T to a queue of the same type. |
| to_unpacked_array | static Converts a queue of type T to an unpacked array of the same type. |
| from_dynamic_array | static Converts a dynamic array of type T to a queue of the same type. |
| to_dynamic_array | static Converts a queue of type T to a dynamic array of the same type. |
| ua_to_q | static Converts an unpacked array of type T to a queue of the same type. |
| q_to_ua | static Converts a queue of type T to an unpacked array of the same type. |
| da_to_q | static Converts a dynamic array of type T to a queue of the same type. |
| q_to_da | static Converts a queue of type T to a dynamic array of the same type. |
| init | static Initializes the each element of the given queue to the specified value. |
| reverse | static Reverses the order of the elements of the given queue. |
| split | static Splits the given queue into two queues. |
| merge | static Merges two queues into one by alternating the elements from the two queues. |
| concat | static Concatenates two queues into one. |
| extract | static Returns a new queue by extracting a part of the given queue. |
| append | static Appends the specified element to the given queue. |
| compare | static Compares two queues. |
| clone | static Returns a copy of the given queue. |
| to_string | static Converts a queue to the form of a string. |
| from_index | The index of the first element of a queue to be processed. If negative, the index counts from the last. For example, if from_index is -9, a function starts at the ninth element (inclusive) from the last. The default is 0 (starts at the first element). |
| to_index | The index of the last element of a queue to be processed. If negative, the index counts from the last. For example, if to_index is -3, a function ends at the third element (inclusive) from the last. The default is -1 (ends at the last element). |
static function q_type from_unpacked_array( const ref ua_type ua, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type.
| ua | An unpacked array to be converted. |
| reverse | optional If 0, the element at the index 0 of ua is positioned to the index 0 of the queue. If 1, the elements are positioned in the reverse order. The default is 0. |
A queue converted from ua.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // same as ua[0:7]
bit q0[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q1[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
assert( queue#(bit,8)::from_unpacked_array( ua ) == q0 );
assert( queue#(bit,8)::from_unpacked_array( ua, .reverse( 1 ) ) == q1 );
static function ua_type to_unpacked_array( const ref q_type q, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type.
| q | A queue to be converted. |
| reverse | optional If 0, the element at the index 0 of q is positioned to the index 0 of the unpacked array. If 1, the elements are positioned in the reverse order. The default is 0. |
An unpacked array converted from q.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 }; // q[0] to q[7]
bit ua0[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua1[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
assert( queue#(bit,8)::to_unpacked_array( q ) == ua0 );
assert( queue#(bit,8)::to_unpacked_array( q, .reverse( 1 ) ) == ua1 );
static function q_type from_dynamic_array( const ref da_type da, input bit reverse = 0 )
static Converts a dynamic array of type T to a queue of the same type.
| da | A dynamic array to be converted. |
| reverse | optional If 0, the element at the index 0 of da is positioned to the index 0 of the queue. If 1, the elements are positioned in the reverse order. The default is 0. |
A queue converted from da.
bit da[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } );
bit q0[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q1[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
assert( queue#(bit)::from_dynamic_array( da ) == q0 );
assert( queue#(bit)::from_dynamic_array( da, .reverse( 1 ) ) == q1 );
static function da_type to_dynamic_array( const ref q_type q, input bit reverse = 0 )
static Converts a queue of type T to a dynamic array of the same type.
| q | A queue to be converted. |
| reverse | optional If 0, the element at the index 0 of q is positioned to the index 0 of the dynamic array. If 1, the elements are positioned in the reverse order. The default is 0. |
A dynamic array converted from q.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 }; // q[0] to q[7]
bit da0[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } );
bit da1[] = new[8]( '{ 1, 1, 0, 1, 1, 0, 0, 0 } );
assert( queue#(bit)::to_dynamic_array( q ) == da0 );
assert( queue#(bit)::to_dynamic_array( q, .reverse( 1 ) ) == da1 );
static function void ua_to_q( const ref ua_type ua, ref q_type q, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type. Unlike from_unpacked_array, this function populates the queue passed by reference instead of returning a new queue.
| ua | An unpacked array to be converted. |
| q | A queue to be populated. |
| reverse | optional If 0, the element at the index 0 of ua is positioned to the index 0 of q. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit ua[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 }; // assigned to ua[0:7]
bit q0[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q1[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
bit q[$];
queue#(bit,8)::ua_to_q( ua, q );
assert( q == q0 );
q.delete();
queue#(bit,8)::ua_to_q( ua, q, .reverse( 1 ) );
assert( q == q1 );
static function void q_to_ua( const ref q_type q, ref ua_type ua, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type. Unlike to_unpacked_array, this function populates the unpacked array passed by reference, instead of returning a new unpacked array. If the size of the queue is larger than SIZE, the excess elements are ignored. If the size of the queue is smaller than SIZE, the default valus of type T is used for the missing elements.
| q | A queue to be converted. |
| ua | An unpacked array to be populated. |
| reverse | optional If 0, the element at the index 0 of q is positioned to the index 0 of ua. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 }; // q[0] to q[7]
bit ua0[8] = '{ 0, 0, 0, 1, 1, 0, 1, 1 };
bit ua1[8] = '{ 1, 1, 0, 1, 1, 0, 0, 0 };
bit ua[8];
queue#(bit,8)::q_to_ua( q, ua );
assert( ua == ua0 );
queue#(bit,8)::q_to_ua( q, ua, .reverse( 1 ) );
assert( ua == ua1 );
static function void da_to_q( const ref da_type da, ref q_type q, input bit reverse = 0 )
static Converts a dynamic array of type T to a queue of the same type. Unlike from_dynamic_array, this function populates the queue passed by reference instead of returning a new queue.
| da | A dynamic array to be converted. |
| q | A queue to be populated. |
| reverse | optional If 0, the element at the index 0 of da is positioned to the index 0 of q. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit da[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } ); // da[0] to da[7]
bit q0[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q1[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
bit q[$];
queue#(bit)::da_to_q( da, q );
assert( q == q0 );
q.delete();
queue#(bit)::da_to_q( da, q, .reverse( 1 ) );
assert( q == q1 );
static function void q_to_da( const ref q_type q, ref da_type da, input bit reverse = 0 )
static Converts a queue of type T to a dynamic array of the same type. Unlike to_dynamic_array, this function populates the dynamic array passed by reference, instead of returning a new dynamic array.
| q | A queue to be converted. |
| da | A dynamic array to be populated. |
| reverse | optional If 0, the element at the index 0 of q is positioned to the index 0 of da. If 1, the elements are positioned in the reverse order. The default is 0. |
None.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 }; // q[0] to q[7]
bit da0[] = new[8]( '{ 0, 0, 0, 1, 1, 0, 1, 1 } );
bit da1[] = new[8]( '{ 1, 1, 0, 1, 1, 0, 0, 0 } );
bit da [] = new[8]; // set the size of da[]
queue#(bit)::q_to_da( q, da );
assert( da == da0 );
queue#(bit)::q_to_da( q, da, .reverse( 1 ) );
assert( da == da1 );
static function void init( ref q_type q, input T val )
static Initializes the each element of the given queue to the specified value.
| q | A queue to be initialized. All the elements of q are initialized, but this function does not change the size of q. |
| val | A value to initialize the elements of q. |
None.
bit q[$] = { 0, 0, 0, 0, 0, 0, 0, 0 };
bit expected[$] = { 1, 1, 1, 1, 1, 1, 1, 1 };
queue#(bit)::init( q, 1'b1 );
assert( q == expected );
static function void split( q_type q, ref q_type q0, ref q_type q1, input bit pad = 0 )
static Splits the given queue into two queues.
| q | A queue to be split. |
| q0 | A new queue that contains the elements at the even index of q. |
| q1 | A new queue that contains the elements at the odd index of q. |
| pad | optional If the size of q is odd and pad is 1, the size of q1 is expanded to be the same size as q0. The padded element is initialized with the default value of type T. If 0, no padding element is added. The default is 0. |
bit q[$] = { 0, 0, 0, 1, 1, 0, 1 }; // q[0] to q[6]
bit q0[$], q1[$], expected_q0[$], expected_q1[$];
expected_q0 = { 0, 0, 1, 1 }; // q[0], q[2], q[4], q[6]
expected_q1 = { 0, 1, 0 }; // q[1], q[3], q[5]
queue#(bit)::split( q, q0, q1 );
assert( q0 == expected_q0 );
assert( q1 == expected_q1 );
q0.delete();
q1.delete();
expected_q0 = { 0, 0, 1, 1 }; // q[0], q[2], q[4], q[6]
expected_q1 = { 0, 1, 0, 0 }; // q[1], q[3], q[5], 0 (padded with the default value of bit type)
queue#(bit)::split( q, q0, q1, .pad( 1 ) );
assert( q0 == expected_q0 );
assert( q1 == expected_q1 );
static function q_type merge( q_type q0, q_type q1, bit truncate = 0 )
static Merges two queues into one by alternating the elements from the two queues.
| q0 | A queue to be merged. The first element of this queue becomes the first element of the merged queue. |
| q1 | Another queue to be merged. The first element of this queue becomes the second element of the merged queue. |
| truncate | optional If the sizes of q0 and q1 are different and truncate is 1, the merging stops when all the elements of the smaller queue are merged. The remaining elements of the larger queue are ignored. If truncate is 0, the remaining elements are appended to the merged queue. The default is 0. |
A new merged queue.
int q0[$] = { 0, 0, 0, 0 };
int q1[$] = { 1, 2, 3, 4, 5, 6 };
int expected[$];
expected = { 0, 1, 0, 2, 0, 3, 0, 4, 5, 6 };
assert( queue#(int)::merge( q0, q1 ) == expected );
expected = { 0, 1, 0, 2, 0, 3, 0, 4 };
assert( queue#(int)::merge( q0, q1, .truncate( 1 ) ) == expected );
static function q_type concat( q_type q0, q_type q1 )
static Concatenates two queues into one.
| q0 | A queue. This queue becomes the first part of the concatenated queue. |
| q1 | Another queue. The elements of this queue are appended to q0. |
A new queue created by concatenating q0 and q1.
int q0[$] = { 0, 0, 0, 0 };
int q1[$] = { 1, 2, 3, 4, 5, 6 };
int expected[$] = { 0, 0, 0, 0, 1, 2, 3, 4, 5, 6 };
assert( queue#(int)::concat( q0, q1 ) == expected );
static function q_type extract( q_type q, int from_index = 0, int to_index = -1 )
static Returns a new queue by extracting a part of the given queue.
| q | A queue to be extracted. |
| from_index | optional The index of the first element of q to be extracted. See Common Arguments. The default is 0. |
| to_index | optional The index of the last element of q to be extracted. See Common Arguments. The default is -1. |
A new queue extracted from q.
int q[$] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int expected[$] = { 3, 4, 5, 6, 7 };
assert( queue#(int)::extract( q, 3, 7 ) == expected );
assert( queue#(int)::extract( q, 3, -3 ) == expected );
static function q_type append( q_type q, T e )
static Appends the specified element to the given queue.
| q | A queue to be appended. |
| e | An element to append. |
A copy of q appended with e. The input q is not modified.
int q[$] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int original[$] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int expected[$] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
assert( queue#(int)::append( q, 10 ) == expected );
assert( q == original ); // not modified
static function bit compare( const ref q_type q1, const ref q_type q2, input int from_index1 = 0, int to_index1 = -1, int from_index2 = 0, int to_index2 = -1, comparator#(T) cmp = null )
static Compares two queues.
| q1 | A queue. |
| q2 | Another queue to compare with q1. |
| from_index1 | optional The first index of the q1 to compare. See Common Arguments. The default is 0. |
| to_index1 | optional The last index of the q1 to compare. See Common Arguments. The default is -1. |
| from_index2 | optional The first index of the q2 to compare. See Common Arguments. The default is 0. |
| to_index2 | optional The last index of the q2 to compare. See Common Arguments. The default is -1. |
| cmp | optional A strategy object used to compare two queues. If not specified or null, comparator#(T) is used. The default is null. |
If the numbers of elements to compare (to_index1-from_index1+1 and to_index2-from_index2+1) are different, 0 is returned. If the two queues contain the same data in the specified range, 1 is returned. Otherwise, 0 is returned.
bit q1[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
bit q2[$] = { 1, 1, 0, 1, 1, 0, 0, 0 };
// |<------>|
// 2 5
assert( queue#(bit)::compare( q1, q2 ) == 0 );
assert( queue#(bit)::compare( q1, q2,
.from_index1( 2 ), .to_index1( 5 ),
.from_index2( 2 ), .to_index2( 5 ) ) == 1 );
static function string to_string( const ref q_type q, input string separator = " ", int from_index = 0, int to_index = -1, formatter#(T) fmtr = null )
static Converts a queue to the form of a string.
| q | An queue to be converted. |
| separator | optional A string to separate each element of q. The default is a space (“ “). |
| from_index | optional The index of the first element of q to convert. See Common Arguments. The default is 0. |
| to_index | optional The index of the last element of q to convert. See Common Arguments. The default is -1. |
| fmtr | optional A strategy object used to format q. If not specified or null, hex_formatter #(T) is used. The default is null. |
A string to represent q.
bit q[$] = { 0, 0, 0, 1, 1, 0, 1, 1 };
assert( queue#(bit,8)::to_string( q ) == "0 0 0 1 1 0 1 1" );
assert( queue#(bit,8)::to_string( q, .separator( "-" ) ) == "0-0-0-1-1-0-1-1" );
assert( queue#(bit,8)::to_string( q, .from_index( 4 ) ) == "1 0 1 1" );A parameterized class that manages a queue.
virtual class queue #( type T = bit, int SIZE = 1 )
The shorthand of the unpacked array of type T.
typedef T ua_type[SIZE]
The shorthand of the dynamic array of type T.
typedef T da_type[]
The shorthand of the queue of type T.
typedef T q_type[$]
static Converts an unpacked array of type T to a queue of the same type.
static function q_type from_unpacked_array( const ref ua_type ua, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type.
static function ua_type to_unpacked_array( const ref q_type q, input bit reverse = 0 )
static Converts a dynamic array of type T to a queue of the same type.
static function q_type from_dynamic_array( const ref da_type da, input bit reverse = 0 )
static Converts a queue of type T to a dynamic array of the same type.
static function da_type to_dynamic_array( const ref q_type q, input bit reverse = 0 )
static Converts an unpacked array of type T to a queue of the same type.
static function void ua_to_q( const ref ua_type ua, ref q_type q, input bit reverse = 0 )
static Converts a queue of type T to an unpacked array of the same type.
static function void q_to_ua( const ref q_type q, ref ua_type ua, input bit reverse = 0 )
static Converts a dynamic array of type T to a queue of the same type.
static function void da_to_q( const ref da_type da, ref q_type q, input bit reverse = 0 )
static Converts a queue of type T to a dynamic array of the same type.
static function void q_to_da( const ref q_type q, ref da_type da, input bit reverse = 0 )
static Initializes the each element of the given queue to the specified value.
static function void init( ref q_type q, input T val )
static Reverses the order of the elements of the given queue.
static function void reverse( ref q_type q )
static Splits the given queue into two queues.
static function void split( q_type q, ref q_type q0, ref q_type q1, input bit pad = 0 )
static Merges two queues into one by alternating the elements from the two queues.
static function q_type merge( q_type q0, q_type q1, bit truncate = 0 )
static Concatenates two queues into one.
static function q_type concat( q_type q0, q_type q1 )
static Returns a new queue by extracting a part of the given queue.
static function q_type extract( q_type q, int from_index = 0, int to_index = -1 )
static Appends the specified element to the given queue.
static function q_type append( q_type q, T e )
static Compares two queues.
static function bit compare( const ref q_type q1, const ref q_type q2, input int from_index1 = 0, int to_index1 = -1, int from_index2 = 0, int to_index2 = -1, comparator#(T) cmp = null )
static Returns a copy of the given queue.
static function q_type clone( q_type q )
static Converts a queue to the form of a string.
static function string to_string( const ref q_type q, input string separator = " ", int from_index = 0, int to_index = -1, formatter#(T) fmtr = null )
singleton Provides a strategy to convert an object of type T to a string using a hexadecimal format.
class hex_formatter #( type T = int ) extends formatter#( T )