nde | The IDE of the future , today | Frontend Framework library

You probably want something like this

As pointed in my comment, I am not sure if this is efficient but posting as an answer for completion sake.

new regex101 link : https://regex101.com/r/wn5moF/6

You first need to perform UNPIVOT, then PIVOT:

Rather than toggling the visible flag of all of your delegates, you should use a QSortFilterProxyModel. The idea is that the proxy model would use your XL.animeListModel as a source model, and then you can give the proxy a regular expression telling it which ones to filter out. Depending on how you want it to filter, you could just call setFilterRole() to tell it which property to compare against your regex, or you could do a custom filter by overriding the filterAcceptsRow() function.

EDIT:

If you don't want to use a proxy, you can still prevent the constant updates by not binding on the visible property directly to the search field. You were on the right track with your onEditingFinished code. You could create a separate text string that just holds the completed search text.

You could add the rows in the array as paths. A path just constitutes a sequence of edges, so the path 1,2,3 translates to the edge list (1,2),(2,3). So iterate over the rows and use nx.add_path:

When we extract a single column with $ or [[, or with [ after a , on a data.frame, it would be a vector. Instead, we can subset the with [

We can use str_remove_all which would make it compact instead of using the replacement argument in str_replace_all with ""

my struct has a lot of data within it (around 50 strings) and copying it over sounds inefficient and a hassle.

...

void printVerbs(verbType verbArray[VERBS], int count);

First, start using C++ containers like std::vector or QVector instead of raw C arrays. The C++ container classes are much easier to manage and debug.

Then, you can cheaply pass arrays around by const reference:

void printVerbs(const QVector &verbArray);

Note: You don't need to pass count! The vector knows how many elements it contains.

This achieves 2 things:

• The reference part ensures that your data is not copied during the function call, because the function is referencing the data that already exists
• The const part ensures that the function cannot accidentally modify your existing data.

QVector is implicitly-shared (also called "copy-on-write"): https://doc.qt.io/qt-5/implicit-sharing.html This means you can pass a copy of QVector from your MainWindow into your TenseSelectionDialog and even store a copy as a member variable in TenseSelectionDialog. As long as neither copy is modified, both vectors will share the same data internally.

Alternatively, if you guarantee that MainWindow will always outlive TenseSelectionDialog, then you can have TenseSelectionDialog store a pointer or reference to MainWindow's member variable.

I also don't know whether I should make it an array of pointers to structs if that'd be the way to go.

Using an array-of-pointers is most useful if:

• Your array will get modified or copied frequently.
  • Inserting or removing elements can cause the array contents to be moved in memory.
  • It is cheaper to move/copy pointers than large structs.
• Your array will be huge.
  • Data in an array is stored in a contiguous memory block, given by N * sizeof where N is the number of elements.
  • If your memory is too fragmented, your PC might not have a large enough contiguous block of RAM to store the data.
  • For large structs, storing pointers reduces the amount of contiguous memory needed.

If these 2 criteria don't apply, then there's less benefit in using an array-of-pointers. (Hint: ~500 elements is tiny)

If you want to use an array-of-pointers, do use std::shared_ptr instead of raw pointers so that you don't need to manage the memory explicitly.

If you're willing to use QString in your core logic, your string manipulation code could be simplified greatly.

Example: