Getting the indexes of a 2D array

[iain-waugh]

Hi, I've made a 2D array of structs, like this:

struct Slice {
  u16 slice_header;
  // std::print("{}", std::core::array_index() );  // <- Debug print the row, column here
};

struct Frame {
    std::Array<std::Array<Slice, rows>, columns> slice;
};

Can you demonstrate the syntax for a print statement that will show the index for rows and columns?

[paxcut]

You have defined the 2d array as an array of an array so there are two indices that need to be dealt with. You could also define the 2-d array as an array of rows*columnsentries so I'll write the code to implement the case you posted and write all the details needed to use one index only.

The following code is a possible implementation of the two indices approach. It has been tested on some random data and it appears to work as expected as shown in the image below.

import std.array;

const u32 rows =4;
const u32 columns = 5;

struct Data {
  u16 slice_header;
  std::print("Row {}, Column {} :    Slice header {} ",std::core::array_index(), parent.parent.sliceIndex,slice_header );
  // std::print("{}", std::core::array_index() );  // <- Debug print the row, column here
};

struct Slice {
    u32 sliceIndex = std::core::array_index();
    std::Array<Data,rows> slice;
};

struct Frame {
    std::Array<Slice, columns> slice;
};

Frame frame@0;

The following is printed to the console:

I kept the names as close as possible to the code you posted but Slice is probably more descriptive if it was called Rpw.
Basically, because of the way the 2d array is defined you have two set of indices each coming from the corresponding Array instance. That forces the definition of a Slice pattern that will store the current row number using array_index(). Note that Array is the parent of Data and Slice is the parent of the Array created in it, so to access the value of a member of Slice from Data you have to go through two parents.

Using only one index for the 2d array would not need the definition of the Slice pattern or the use of parent keyword because there would only be one index to deal with. Besides the exact code you wrote it would also require to decide if the array is going to be row major or column major. If row major then you also need to store the number of columns in a variable (say columnCount). If column major the number of rows needs to be stored (maybe as rowCount). Then the row and column can be easily obtained from the index like so:
Row major:

u32 index = std::core::array_index();
u32 row = index / columnCount; 
u32 column = index % columnCount;

Column major:

u32 index = std::core::array_index();
u32 column= index / rowCount; 
u32 row = index % rowCount;

HTH.

[iain-waugh]

Thank you for taking the time to give such an excellent answer.

Technically I do want to keep it as a 2D array because that's how it's presented in the standard. I agree that a 1D flattened array would make this much easier, but where's the fun in that ;)