Quick: use const (and const APIs) more

For CoW types, prefer const methods to avoid needless detach()ing.

Change-Id: I270cdc6eb8c5946f5c20b379bbb7c60f0ba518eb
Reviewed-by: Shawn Rutledge <shawn.rutledge@qt.io>
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

1 files changed, 57 insertions, 57 deletions

diff --git a/src/quick/items/qquickspriteengine.cpp b/src/quick/items/qquickspriteengine.cpp
index 083e02fe3f..db04a83afc 100644
--- a/src/quick/items/qquickspriteengine.cpp
+++ b/src/quick/items/qquickspriteengine.cpp
@@ -94,7 +94,7 @@ QQuickStochasticEngine::QQuickStochasticEngine(QObject *parent) :
     setCount(1);
 }
 
-QQuickStochasticEngine::QQuickStochasticEngine(QList<QQuickStochasticState*> states, QObject *parent) :
+QQuickStochasticEngine::QQuickStochasticEngine(const QList<QQuickStochasticState *> &states, QObject *parent) :
     QObject(parent), m_states(states), m_timeOffset(0), m_addAdvance(false)
 {
     //Default size 1
@@ -122,7 +122,7 @@ QQuickSpriteEngine::~QQuickSpriteEngine()
 }
 
 
-int QQuickSpriteEngine::maxFrames()
+int QQuickSpriteEngine::maxFrames() const
 {
     return m_maxFrames;
 }
@@ -140,7 +140,7 @@ TODO: Above idea needs to have the varying duration offset added to it
     m_startTimes will be set in advance/restart to 0->(m_framesPerRow-1) and can be used directly as extra.
     This makes it 'frame' instead, but is more memory efficient than two arrays and less hideous than a vector of unions.
 */
-int QQuickSpriteEngine::pseudospriteProgress(int sprite, int state, int* rowDuration)
+int QQuickSpriteEngine::pseudospriteProgress(int sprite, int state, int* rowDuration) const
 {
     int myRowDuration = m_duration[sprite] * m_sprites[state]->m_framesPerRow / m_sprites[state]->m_frames;
     if (rowDuration)
@@ -153,7 +153,7 @@ int QQuickSpriteEngine::pseudospriteProgress(int sprite, int state, int* rowDura
         return (m_timeOffset - m_startTimes[sprite]) / myRowDuration;
 }
 
-int QQuickSpriteEngine::spriteState(int sprite)
+int QQuickSpriteEngine::spriteState(int sprite) const
 {
     if (!m_loaded)
         return 0;
@@ -174,7 +174,7 @@ int QQuickSpriteEngine::spriteState(int sprite)
     return state + extra;
 }
 
-int QQuickSpriteEngine::spriteStart(int sprite)
+int QQuickSpriteEngine::spriteStart(int sprite) const
 {
     if (!m_duration[sprite] || !m_loaded)
         return m_timeOffset;
@@ -188,7 +188,7 @@ int QQuickSpriteEngine::spriteStart(int sprite)
     return m_startTimes[sprite] + extra*rowDuration;
 }
 
-int QQuickSpriteEngine::spriteFrames(int sprite)
+int QQuickSpriteEngine::spriteFrames(int sprite) const
 {
     if (!m_loaded)
         return 1;
@@ -215,7 +215,7 @@ int QQuickSpriteEngine::spriteFrames(int sprite)
     return m_sprites[state]->m_framesPerRow;
 }
 
-int QQuickSpriteEngine::spriteDuration(int sprite)//Full duration, not per frame
+int QQuickSpriteEngine::spriteDuration(int sprite) const //Full duration, not per frame
 {
     if (!m_duration[sprite] || !m_loaded)
         return m_duration[sprite];
@@ -235,7 +235,7 @@ int QQuickSpriteEngine::spriteDuration(int sprite)//Full duration, not per frame
     return rowDuration;
 }
 
-int QQuickSpriteEngine::spriteY(int sprite)
+int QQuickSpriteEngine::spriteY(int sprite) const
 {
     if (!m_loaded)
         return 0;
@@ -257,7 +257,7 @@ int QQuickSpriteEngine::spriteY(int sprite)
     return m_sprites[state]->m_rowY + m_sprites[state]->m_frameHeight * extra;
 }
 
-int QQuickSpriteEngine::spriteX(int sprite)
+int QQuickSpriteEngine::spriteX(int sprite) const
 {
     if (!m_loaded)
         return 0;
@@ -280,24 +280,24 @@ int QQuickSpriteEngine::spriteX(int sprite)
     return m_sprites[state]->m_rowStartX;
 }
 
-QQuickSprite* QQuickSpriteEngine::sprite(int sprite)
+QQuickSprite* QQuickSpriteEngine::sprite(int sprite) const
 {
     return m_sprites[m_things[sprite]];
 }
 
-int QQuickSpriteEngine::spriteWidth(int sprite)
+int QQuickSpriteEngine::spriteWidth(int sprite) const
 {
     int state = m_things[sprite];
     return m_sprites[state]->m_frameWidth;
 }
 
-int QQuickSpriteEngine::spriteHeight(int sprite)
+int QQuickSpriteEngine::spriteHeight(int sprite) const
 {
     int state = m_things[sprite];
     return m_sprites[state]->m_frameHeight;
 }
 
-int QQuickSpriteEngine::spriteCount()//TODO: Actually image state count, need to rename these things to make sense together
+int QQuickSpriteEngine::spriteCount() const //TODO: Actually image state count, need to rename these things to make sense together
 {
     return m_imageStateCount;
 }
@@ -312,14 +312,14 @@ void QQuickStochasticEngine::setGoal(int state, int sprite, bool jump)
         return;
     }
 
-    if (m_things[sprite] == state)
+    if (m_things.at(sprite) == state)
         return;//Already there
     m_things[sprite] = state;
-    m_duration[sprite] = m_states[state]->variedDuration();
+    m_duration[sprite] = m_states.at(state)->variedDuration();
     m_goals[sprite] = -1;
     restart(sprite);
     emit stateChanged(sprite);
-    emit m_states[state]->entered();
+    emit m_states.at(state)->entered();
     return;
 }
 
@@ -516,8 +516,8 @@ void QQuickStochasticEngine::start(int index, int state)
     if (index >= m_things.count())
         return;
     m_things[index] = state;
-    m_duration[index] = m_states[state]->variedDuration();
-    if (m_states[state]->randomStart())
+    m_duration[index] = m_states.at(state)->variedDuration();
+    if (m_states.at(state)->randomStart())
         m_startTimes[index] = NINF;
     else
         m_startTimes[index] = 0;
@@ -538,33 +538,33 @@ void QQuickStochasticEngine::stop(int index)
 
 void QQuickStochasticEngine::restart(int index)
 {
-    bool randomStart = (m_startTimes[index] == NINF);
+    bool randomStart = (m_startTimes.at(index) == NINF);
     m_startTimes[index] = m_timeOffset;
     if (m_addAdvance)
         m_startTimes[index] += m_advanceTime.elapsed();
     if (randomStart)
-        m_startTimes[index] -= qrand() % m_duration[index];
-    int time = m_duration[index] + m_startTimes[index];
+        m_startTimes[index] -= qrand() % m_duration.at(index);
+    int time = m_duration.at(index) + m_startTimes.at(index);
     for (int i=0; i<m_stateUpdates.count(); i++)
         m_stateUpdates[i].second.removeAll(index);
-    if (m_duration[index] >= 0)
+    if (m_duration.at(index) >= 0)
         addToUpdateList(time, index);
 }
 
 void QQuickSpriteEngine::restart(int index) //Reimplemented to recognize and handle pseudostates
 {
-    bool randomStart = (m_startTimes[index] == NINF);
-    if (m_loaded && m_sprites[m_things[index]]->frameSync()) {//Manually advanced
+    bool randomStart = (m_startTimes.at(index) == NINF);
+    if (m_loaded && m_sprites.at(m_things.at(index))->frameSync()) {//Manually advanced
         m_startTimes[index] = 0;
-        if (randomStart && m_sprites[m_things[index]]->m_generatedCount)
-            m_startTimes[index] += qrand() % m_sprites[m_things[index]]->m_generatedCount;
+        if (randomStart && m_sprites.at(m_things.at(index))->m_generatedCount)
+            m_startTimes[index] += qrand() % m_sprites.at(m_things.at(index))->m_generatedCount;
     } else {
         m_startTimes[index] = m_timeOffset;
         if (m_addAdvance)
             m_startTimes[index] += m_advanceTime.elapsed();
         if (randomStart)
-            m_startTimes[index] -= qrand() % m_duration[index];
-        int time = spriteDuration(index) + m_startTimes[index];
+            m_startTimes[index] -= qrand() % m_duration.at(index);
+        int time = spriteDuration(index) + m_startTimes.at(index);
         if (randomStart) {
             int curTime = m_timeOffset + (m_addAdvance ? m_advanceTime.elapsed() : 0);
             while (time < curTime) //Fast forward through psuedostates as needed
@@ -581,11 +581,11 @@ void QQuickStochasticEngine::advance(int idx)
 {
     if (idx >= m_things.count())
         return;//TODO: Proper fix(because this has happened and I just ignored it)
-    int nextIdx = nextState(m_things[idx],idx);
+    int nextIdx = nextState(m_things.at(idx), idx);
     m_things[idx] = nextIdx;
-    m_duration[idx] = m_states[nextIdx]->variedDuration();
+    m_duration[idx] = m_states.at(nextIdx)->variedDuration();
     restart(idx);
-    emit m_states[nextIdx]->entered();
+    emit m_states.at(nextIdx)->entered();
     emit stateChanged(idx);
 }
 
@@ -598,29 +598,29 @@ void QQuickSpriteEngine::advance(int idx) //Reimplemented to recognize and handl
 
     if (idx >= m_things.count())
         return;//TODO: Proper fix(because this has happened and I just ignored it)
-    if (m_duration[idx] == 0) {
-        if (m_sprites[m_things[idx]]->frameSync()) {
+    if (m_duration.at(idx) == 0) {
+        if (m_sprites.at(m_things.at(idx))->frameSync()) {
             //Manually called, advance inner substate count
             m_startTimes[idx]++;
-            if (m_startTimes[idx] < m_sprites[m_things[idx]]->m_generatedCount) {
+            if (m_startTimes.at(idx) < m_sprites.at(m_things.at(idx))->m_generatedCount) {
                 //only a pseudostate ended
                 emit stateChanged(idx);
                 return;
             }
         }
         //just go past the pseudostate logic
-    } else if (m_startTimes[idx] + m_duration[idx]
+    } else if (m_startTimes.at(idx) + m_duration.at(idx)
             > int(m_timeOffset + (m_addAdvance ? m_advanceTime.elapsed() : 0))) {
         //only a pseduostate ended
         emit stateChanged(idx);
         addToUpdateList(spriteStart(idx) + spriteDuration(idx) + (m_addAdvance ? m_advanceTime.elapsed() : 0), idx);
         return;
     }
-    int nextIdx = nextState(m_things[idx],idx);
+    int nextIdx = nextState(m_things.at(idx), idx);
     m_things[idx] = nextIdx;
-    m_duration[idx] = m_states[nextIdx]->variedDuration();
+    m_duration[idx] = m_states.at(nextIdx)->variedDuration();
     restart(idx);
-    emit m_states[nextIdx]->entered();
+    emit m_states.at(nextIdx)->entered();
     emit stateChanged(idx);
 }
 
@@ -631,16 +631,16 @@ int QQuickStochasticEngine::nextState(int curState, int curThing)
     if (goalPath == -1){//Random
         qreal r =(qreal) qrand() / (qreal) RAND_MAX;
         qreal total = 0.0;
-        for (QVariantMap::const_iterator iter=m_states[curState]->m_to.constBegin();
-            iter!=m_states[curState]->m_to.constEnd(); ++iter)
+        for (QVariantMap::const_iterator iter=m_states.at(curState)->m_to.constBegin();
+            iter!=m_states.at(curState)->m_to.constEnd(); ++iter)
             total += (*iter).toReal();
         r*=total;
-        for (QVariantMap::const_iterator iter= m_states[curState]->m_to.constBegin();
-                iter!=m_states[curState]->m_to.constEnd(); ++iter){
+        for (QVariantMap::const_iterator iter= m_states.at(curState)->m_to.constBegin();
+                iter!=m_states.at(curState)->m_to.constEnd(); ++iter){
             if (r < (*iter).toReal()){
                 bool superBreak = false;
                 for (int i=0; i<m_states.count(); i++){
-                    if (m_states[i]->name() == iter.key()){
+                    if (m_states.at(i)->name() == iter.key()){
                         nextIdx = i;
                         superBreak = true;
                         break;
@@ -664,8 +664,8 @@ uint QQuickStochasticEngine::updateSprites(uint time)//### would returning a lis
     //Sprite State Update;
     m_timeOffset = time;
     m_addAdvance = false;
-    while (!m_stateUpdates.isEmpty() && time >= m_stateUpdates.first().first){
-        foreach (int idx, m_stateUpdates.first().second)
+    while (!m_stateUpdates.isEmpty() && time >= m_stateUpdates.constFirst().first){
+        foreach (int idx, m_stateUpdates.constFirst().second)
             advance(idx);
         m_stateUpdates.pop_front();
     }
@@ -674,14 +674,14 @@ uint QQuickStochasticEngine::updateSprites(uint time)//### would returning a lis
     m_addAdvance = true;
     if (m_stateUpdates.isEmpty())
         return uint(-1);
-    return m_stateUpdates.first().first;
+    return m_stateUpdates.constFirst().first;
 }
 
 int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
 {
     QString goalName;
-    if (m_goals[spriteIdx] != -1)
-        goalName = m_states[m_goals[spriteIdx]]->name();
+    if (m_goals.at(spriteIdx) != -1)
+        goalName = m_states.at(m_goals.at(spriteIdx))->name();
     else
         goalName = m_globalGoal;
     if (goalName.isEmpty())
@@ -689,16 +689,16 @@ int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
     //TODO: caching instead of excessively redoing iterative deepening (which was chosen arbitrarily anyways)
     // Paraphrased - implement in an *efficient* manner
     for (int i=0; i<m_states.count(); i++)
-        if (m_states[curIdx]->name() == goalName)
+        if (m_states.at(curIdx)->name() == goalName)
             return curIdx;
     if (dist < 0)
         dist = m_states.count();
-    QQuickStochasticState* curState = m_states[curIdx];
+    QQuickStochasticState* curState = m_states.at(curIdx);
     for (QVariantMap::const_iterator iter = curState->m_to.constBegin();
         iter!=curState->m_to.constEnd(); ++iter){
         if (iter.key() == goalName)
             for (int i=0; i<m_states.count(); i++)
-                if (m_states[i]->name() == goalName)
+                if (m_states.at(i)->name() == goalName)
                     return i;
     }
     QSet<int> options;
@@ -707,7 +707,7 @@ int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
             iter!=curState->m_to.constEnd(); ++iter){
             int option = -1;
             for (int j=0; j<m_states.count(); j++)//One place that could be a lot more efficient...
-                if (m_states[j]->name() == iter.key())
+                if (m_states.at(j)->name() == iter.key())
                     if (goalSeek(j, spriteIdx, i) != -1)
                         option = j;
             if (option != -1)
@@ -721,13 +721,13 @@ int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
             qreal total = 0;
             for (QSet<int>::const_iterator iter=options.constBegin();
                 iter!=options.constEnd(); ++iter)
-                total += curState->m_to.value(m_states[(*iter)]->name()).toReal();
+                total += curState->m_to.value(m_states.at((*iter))->name()).toReal();
             r *= total;
             for (QVariantMap::const_iterator iter = curState->m_to.constBegin();
                 iter!=curState->m_to.constEnd(); ++iter){
                 bool superContinue = true;
                 for (int j=0; j<m_states.count(); j++)
-                    if (m_states[j]->name() == iter.key())
+                    if (m_states.at(j)->name() == iter.key())
                         if (options.contains(j))
                             superContinue = false;
                 if (superContinue)
@@ -735,7 +735,7 @@ int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
                 if (r < (*iter).toReal()){
                     bool superBreak = false;
                     for (int j=0; j<m_states.count(); j++){
-                        if (m_states[j]->name() == iter.key()){
+                        if (m_states.at(j)->name() == iter.key()){
                             option = j;
                             superBreak = true;
                             break;
@@ -755,10 +755,10 @@ int QQuickStochasticEngine::goalSeek(int curIdx, int spriteIdx, int dist)
 void QQuickStochasticEngine::addToUpdateList(uint t, int idx)
 {
     for (int i=0; i<m_stateUpdates.count(); i++){
-        if (m_stateUpdates[i].first==t){
+        if (m_stateUpdates.at(i).first == t){
             m_stateUpdates[i].second << idx;
             return;
-        }else if (m_stateUpdates[i].first > t){
+        } else if (m_stateUpdates.at(i).first > t) {
             QList<int> tmpList;
             tmpList << idx;
             m_stateUpdates.insert(i, qMakePair(t, tmpList));