struct MyObjectWithList : public Qul::Object
{
    Qul::ListProperty<int> list1;
    Qul::ListProperty<MyData *> list2;
    MyObjectWithList()
    {
        static Qul::StaticListFixed<int, 100> buffer;
        buffer.replace(0, 1);
        // ... further initialization
        list1.setList(&buffer);
    }
};

MyObjectWithList {
    // list1 is declared and initiated in c++
    property int value: list1[0]
    // list2 is declared in c++ and initiated here
    list2: [
        MyData { val: 100 },
        MyData { val: 200 }
    ]
}

struct MyObject : public Qul::Object
{
    struct Grouped
    {
        Qul::Property<int> val1;
        Qul::Property<int> val2;
        Qul::ListProperty<int> list1;
    };
    Grouped group;
};

Qul::ListProperty<int> list;
list.setList(new Qul::DynamicList<int>());

//... declaration
Qul::ListProperty<int> list;
int data[10];
Qul::StaticList<int> storage;
//... initialization
storage.size = 10;
storage.data = data;
list.setList(storage);

// ... declaration
Qul::ListProperty<int> list;
// T t[N=10] will be added as a member of the StaticListFixed
Qul::StaticListFixed<int, 10> staticList;
// ... initialization and usage
list.setList(&staticList);

Member Function Documentation

ListProperty::ListProperty()

Creates a ListProperty without a specific List Storage type.

void ListProperty::append(T t)

Adds a new item to the end of the list and set it's value to t .

typename IList<T>::const_reference ListProperty::at(int index) const

Returns the item at the specified index.

Use ListProperty::replace instead if you want to change a basic type.

bool ListProperty::canGrow() const

Returns true if the list storage supports growing (has the IListFlag_CanGrow flag set), otherwise returns false. Lists that can grow support operations like append() and resize().

void ListProperty::clear()

Removes all nodes on the DynamicList's LinkedList.

int ListProperty::count() const

Returns the number of items in the list.

T ListProperty::get(int index) const

Returns the item at the specified index. This is equivalent to using the operator[] or at() functions.

Qul::IList<T> &ListProperty::getList() const

Returns a reference to the underlying list storage (IList implementation). This provides direct access to the list storage for advanced operations.

bool ListProperty::hasList() const

Returns true if the list has been initialized with a valid storage, otherwise returns false. A list without storage cannot be used for most operations.

template <typename U> void ListProperty::load(const Qul::ListProperty<U> &otherList)

Copies the items from otherList into this list, following same rules that are used with Qul::ListProperty::operator=.

bool ListProperty::removeAt(int index)

Removes the item at the specified index and returns true if successful, otherwise returns false.

void ListProperty::removeLast()

Removes the last item in the list.

void ListProperty::replace(int index, T newValue)

Sets the value of the item at the specified index to newValue.

void ListProperty::resize(int newSize)

Resizes the list to newSize. If the new size is smaller, items are removed from the end. If the new size is larger and the list can grow, new default-constructed items are appended.

void ListProperty::setList(Qul::IList<T> *l, bool silent = false)

Use l IList as the list's storage. The l parameter can be any implementation of IList, such as DynamicList or StaticList. Use silent to control whether the bindings to the list should be updated. Qt Quick Ultralite calls this function implicitly when initializing a list QML, and pick the correct storage type

See also hasList().

void ListProperty::syncList()

Synchronizes the length property with the current list count and emits the dataChanged signal with a reset notification. Use this function after manually modifying the underlying list storage.

template <typename L> Qul::ListProperty<T> &ListProperty::operator=(const L &otherList)

Load the items from otherList into L, which should also be a ListProperty.

The assignment operator uses the following rules depending on the size of the two lists, L and otherList, irrespective of their storage type:

• If the size of L is greater than the size of otherList, items in L are replaced by items in otherList up to the size of otherList.
• If the size of L is less than the size of otherList, items in L are replaced by items in otherList up to the size of L.
• If the size of L is equal to the size of otherList, items in L are replaced by items in otherList up to the size of L.
• The type of the items in otherList should be the same as the type of the items in L list.

The assignment operator is based on Qul::ListProperty::load

typename IList<T>::reference ListProperty::operator[](int index)

Returns a reference to the item at the specified index.

This triggers copy-on-write for shared list storage.

typename IList<T>::const_reference ListProperty::operator[](int index) const

Returns a const reference to the item at the specified index.

Use ListProperty::replace instead if you want to change a basic type.