← Back to branch summary

~ubuntu-branches/ubuntu/karmic/kst/karmic

« back to all changes in this revision

Viewing changes to kst/kst/kstdataobject.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel T Chen
  • Date: 2006-06-30 19:11:30 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060630191130-acumuar75bz4puty
Tags: 1.2.1-1ubuntu1
Merge from debian unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
kst/kst/kstdataobject.cpp
16
16
 *                                                                         *
17
17
 ***************************************************************************/
18
18
 
 
19
#include "kstvcurve.h"
 
20
 
 
21
   
19
22
#include "kstdatacollection.h"
20
23
#include "kstdataobject.h"
21
24
#include "kstdebug.h"
39
42
  _curveHints = new KstCurveHintList;
40
43
}
41
44
 
 
45
 
42
46
KstDataObject::~KstDataObject() {
43
 
  // Remove our slave vectors, scalars, and strings
 
47
  // Remove our slave vectors, scalars, and strings, and matrices
44
48
  KST::stringList.lock().writeLock();
45
49
  for (KstStringMap::Iterator it = _outputStrings.begin();
46
50
                               it != _outputStrings.end();
64
68
    KST::vectorList.remove(it.data());
65
69
  }
66
70
  KST::vectorList.lock().writeUnlock();
67
 
  //kdDebug() << "+++ DESTROYING DATA OBJECT: " << (void*)this << endl;
 
71
  
 
72
  KST::matrixList.lock().writeLock();
 
73
  for (KstMatrixMap::Iterator it = _outputMatrices.begin();
 
74
       it != _outputMatrices.end();
 
75
       ++it) {
 
76
    KST::matrixList.remove(it.data());       
 
77
  }
 
78
  KST::matrixList.lock().writeUnlock();
 
79
  //kstdDebug() << "+++ DESTROYING DATA OBJECT: " << (void*)this << endl;
68
80
  delete _curveHints;
69
81
}
70
82
 
124
136
    }
125
137
  }
126
138
  KST::stringList.lock().readUnlock();
 
139
  
 
140
  KST::matrixList.lock().readLock();
 
141
  for (i = _inputMatrixLoadQueue.begin(); i != _inputMatrixLoadQueue.end(); ++i) {
 
142
    KstMatrixList::Iterator it = KST::matrixList.findTag((*i).second);
 
143
    if (it != KST::matrixList.end()) {
 
144
      _inputMatrices.insert((*i).first, *it);
 
145
    } else {
 
146
      KstDebug::self()->log(i18n("Unable to find required matrix [%1] for data object %2.").arg((*i).second).arg(tagName()), KstDebug::Error);
 
147
      rc = false;
 
148
    }
 
149
  }
 
150
  KST::matrixList.lock().readUnlock();
127
151
 
128
152
  _inputVectorLoadQueue.clear();
129
153
  _inputScalarLoadQueue.clear();
130
154
  _inputStringLoadQueue.clear();
 
155
  _inputMatrixLoadQueue.clear();
131
156
  
132
157
  setDirty();
133
158
 
154
179
      rc += i.data()->getUsage() - 1;
155
180
    }
156
181
  }
 
182
  
 
183
  for (KstMatrixMap::ConstIterator i = _outputMatrices.begin(); i != _outputMatrices.end(); ++i) {
 
184
    if (i.data().data()) {
 
185
      rc += i.data()->getUsage() - 1;  
 
186
    }  
 
187
  }
157
188
 
158
189
  return KstObject::getUsage() + rc;
159
190
}
187
218
  for (KstVectorMap::ConstIterator i = _outputVectors.begin(); i != _outputVectors.end(); ++i) {
188
219
    (*i)->readLock();
189
220
  }
 
221
  for (KstMatrixMap::ConstIterator i = _inputMatrices.begin(); i != _inputMatrices.end(); ++i) {
 
222
    (*i)->readLock();
 
223
  }
 
224
  for (KstMatrixMap::ConstIterator i = _outputMatrices.begin(); i != _outputMatrices.end(); ++i) {
 
225
    (*i)->readLock();
 
226
  }
190
227
}
191
228
 
192
229
 
212
249
  for (KstStringMap::ConstIterator i = _inputStrings.begin(); i != _inputStrings.end(); ++i) {
213
250
    (*i)->readUnlock();
214
251
  }
 
252
  for (KstMatrixMap::ConstIterator i = _outputMatrices.begin(); i != _outputMatrices.end(); ++i) {
 
253
    (*i)->readUnlock();
 
254
  }
 
255
  for (KstMatrixMap::ConstIterator i = _inputMatrices.begin(); i != _inputMatrices.end(); ++i) {
 
256
    (*i)->readUnlock();
 
257
  }
 
258
  
215
259
  KstObject::readUnlock();
216
260
}
217
261
 
242
286
  for (KstVectorMap::ConstIterator i = _outputVectors.begin(); i != _outputVectors.end(); ++i) {
243
287
    (*i)->writeLock();
244
288
  }
 
289
  for (KstMatrixMap::ConstIterator i = _outputMatrices.begin(); i != _outputMatrices.end(); ++i) {
 
290
    (*i)->writeLock();
 
291
  }
 
292
  for (KstMatrixMap::ConstIterator i = _inputMatrices.begin(); i != _inputMatrices.end(); ++i) {
 
293
    (*i)->writeLock();
 
294
  }
245
295
}
246
296
 
247
297
 
267
317
  for (KstStringMap::ConstIterator i = _inputStrings.begin(); i != _inputStrings.end(); ++i) {
268
318
    (*i)->writeUnlock();
269
319
  }
 
320
  for (KstMatrixMap::ConstIterator i = _outputMatrices.begin(); i != _outputMatrices.end(); ++i) {
 
321
    (*i)->writeUnlock();
 
322
  }
 
323
  for (KstMatrixMap::ConstIterator i = _inputMatrices.begin(); i != _inputMatrices.end(); ++i) {
 
324
    (*i)->writeUnlock();
 
325
  }
270
326
  KstRWLock::writeUnlock();
271
327
}
272
328
 
311
367
}
312
368
 
313
369
 
 
370
bool KstDataObject::duplicateDependents(QMap<KstDataObjectPtr, KstDataObjectPtr> &duplicatedMap) {
 
371
  // work with a copy of the data object list
 
372
  KST::dataObjectList.lock().readLock();
 
373
  KstDataObjectList dol = QDeepCopy<KstDataObjectList>(KST::dataObjectList);
 
374
  KST::dataObjectList.lock().readUnlock();
 
375
  
 
376
  for (KstDataObjectList::Iterator i = dol.begin(); i != dol.end(); ++i) { 
 
377
    if ((*i)->uses(this)) {
 
378
      if (duplicatedMap.contains(*i)) {
 
379
        (duplicatedMap[*i])->replaceDependency(this, duplicatedMap[this]);
 
380
      } else {
 
381
        KstDataObjectPtr newObject = (*i)->makeDuplicate(duplicatedMap);
 
382
        KST::dataObjectList.lock().writeLock();
 
383
        KST::dataObjectList.append(newObject.data());
 
384
        KST::dataObjectList.lock().writeUnlock();
 
385
        (duplicatedMap[*i])->replaceDependency(this, duplicatedMap[this]);
 
386
        (*i)->duplicateDependents(duplicatedMap);
 
387
      }
 
388
    }
 
389
  }
 
390
  return true;
 
391
}
 
392
 
 
393
 
 
394
void KstDataObject::replaceDependency(KstDataObjectPtr oldObject, KstDataObjectPtr newObject) {
 
395
  
 
396
  // find all connections from this object to old object
 
397
  
 
398
  // vectors
 
399
  for (KstVectorMap::Iterator j = oldObject->outputVectors().begin(); j != oldObject->outputVectors().end(); ++j) {
 
400
    for (KstVectorMap::Iterator k = _inputVectors.begin(); k != _inputVectors.end(); ++k) {
 
401
      if (j.data().data() == k.data().data()) {
 
402
        // replace input with the output from newObject
 
403
        _inputVectors[k.key()] = (newObject->outputVectors())[j.key()]; 
 
404
      }
 
405
    }
 
406
    // also replace dependencies on vector stats
 
407
    QDictIterator<KstScalar> scalarDictIter(j.data()->scalars());
 
408
    for (KstScalarMap::Iterator k = _inputScalars.begin(); k != _inputScalars.end(); ++k) {
 
409
      for (; scalarDictIter.current(); ++scalarDictIter) {
 
410
        if (scalarDictIter.current() == k.data()) {
 
411
          _inputScalars[k.key()] = (((newObject->outputVectors())[j.key()])->scalars())[scalarDictIter.currentKey()];
 
412
        }  
 
413
      }
 
414
    }
 
415
  }
 
416
  
 
417
  // matrices
 
418
  for (KstMatrixMap::Iterator j = oldObject->outputMatrices().begin(); j != oldObject->outputMatrices().end(); ++j) {
 
419
    for (KstMatrixMap::Iterator k = _inputMatrices.begin(); k != _inputMatrices.end(); ++k) {
 
420
      if (j.data().data() == k.data().data()) {
 
421
        // replace input with the output from newObject
 
422
        _inputMatrices[k.key()] = (newObject->outputMatrices())[j.key()]; 
 
423
      }
 
424
    }
 
425
    // also replace dependencies on matrix stats
 
426
    QDictIterator<KstScalar> scalarDictIter(j.data()->scalars());
 
427
    for (KstScalarMap::Iterator k = _inputScalars.begin(); k != _inputScalars.end(); ++k) {
 
428
      for (; scalarDictIter.current(); ++scalarDictIter) {
 
429
        if (scalarDictIter.current() == k.data()) {
 
430
          _inputScalars[k.key()] = (((newObject->outputMatrices())[j.key()])->scalars())[scalarDictIter.currentKey()];
 
431
        }  
 
432
      }
 
433
    }
 
434
  }
 
435
 
 
436
  // scalars
 
437
  for (KstScalarMap::Iterator j = oldObject->outputScalars().begin(); j != oldObject->outputScalars().end(); ++j) {
 
438
    for (KstScalarMap::Iterator k = _inputScalars.begin(); k != _inputScalars.end(); ++k) {
 
439
      if (j.data().data() == k.data().data()) {
 
440
        // replace input with the output from newObject
 
441
        _inputScalars[k.key()] = (newObject->outputScalars())[j.key()];  
 
442
      }
 
443
    } 
 
444
  }
 
445
  
 
446
  // strings 
 
447
  for (KstStringMap::Iterator j = oldObject->outputStrings().begin(); j != oldObject->outputStrings().end(); ++j) {
 
448
    for (KstStringMap::Iterator k = _inputStrings.begin(); k != _inputStrings.end(); ++k) {
 
449
      if (j.data().data() == k.data().data()) {
 
450
        // replace input with the output from newObject
 
451
        _inputStrings[k.key()] = (newObject->outputStrings())[j.key()];  
 
452
      }
 
453
    }
 
454
  }
 
455
}
 
456
 
 
457
 
 
458
void KstDataObject::replaceDependency(KstVectorPtr oldVector, KstVectorPtr newVector) {
 
459
  for (KstVectorMap::Iterator j = _inputVectors.begin(); j != _inputVectors.end(); ++j) {
 
460
    if (j.data() == oldVector) {
 
461
      _inputVectors[j.key()] = newVector;  
 
462
    }      
 
463
  }
 
464
  
 
465
  QDictIterator<KstScalar> scalarDictIter(oldVector->scalars());
 
466
  for (KstScalarMap::Iterator j = _inputScalars.begin(); j != _inputScalars.end(); ++j) {
 
467
    for (; scalarDictIter.current(); ++ scalarDictIter) {
 
468
      if (scalarDictIter.current() == j.data()) {
 
469
        _inputScalars[j.key()] = (newVector->scalars())[scalarDictIter.currentKey()];
 
470
      }  
 
471
    }
 
472
  }
 
473
}
 
474
 
 
475
 
 
476
void KstDataObject::replaceDependency(KstMatrixPtr oldMatrix, KstMatrixPtr newMatrix) {
 
477
  for (KstMatrixMap::Iterator j = _inputMatrices.begin(); j != _inputMatrices.end(); ++j) {
 
478
    if (j.data() == oldMatrix) {
 
479
      _inputMatrices[j.key()] = newMatrix;  
 
480
    }      
 
481
  }
 
482
  
 
483
  QDictIterator<KstScalar> scalarDictIter(oldMatrix->scalars());
 
484
  for (KstScalarMap::Iterator j = _inputScalars.begin(); j != _inputScalars.end(); ++j) {
 
485
    for (; scalarDictIter.current(); ++ scalarDictIter) {
 
486
      if (scalarDictIter.current() == j.data()) {
 
487
        _inputScalars[j.key()] = (newMatrix->scalars())[scalarDictIter.currentKey()];
 
488
      }  
 
489
    }
 
490
  }
 
491
}
 
492
 
 
493
 
314
494
bool KstDataObject::uses(KstObjectPtr p) const {
 
495
  
315
496
  KstVectorPtr v = kst_cast<KstVector>(p);
316
497
  if (v) {
317
498
    for (KstVectorMap::ConstIterator j = _inputVectors.begin(); j != _inputVectors.end(); ++j) {
319
500
        return true;
320
501
      }
321
502
    }
 
503
    QDictIterator<KstScalar> scalarDictIter(v->scalars());
 
504
    for (KstScalarMap::ConstIterator j = _inputScalars.begin(); j != _inputScalars.end(); ++j) {
 
505
      for (; scalarDictIter.current(); ++scalarDictIter) {
 
506
        if (scalarDictIter.current() == j.data()) {
 
507
          return true;  
 
508
        }  
 
509
      }
 
510
    }
 
511
  } else if (KstMatrixPtr matrix = kst_cast<KstMatrix>(p)) {
 
512
    for (KstMatrixMap::ConstIterator j = _inputMatrices.begin(); j != _inputMatrices.end(); ++j) {
 
513
      if (j.data() == matrix) {
 
514
        return true;
 
515
      }
 
516
    }
 
517
    QDictIterator<KstScalar> scalarDictIter(matrix->scalars());
 
518
    for (KstScalarMap::ConstIterator j = _inputScalars.begin(); j != _inputScalars.end(); ++j) {
 
519
      for (; scalarDictIter.current(); ++scalarDictIter) {
 
520
        if (scalarDictIter.current() == j.data()) {
 
521
          return true;  
 
522
        }  
 
523
      }
 
524
    }
 
525
  } else if (KstDataObjectPtr obj = kst_cast<KstDataObject>(p) ) {
 
526
    // check all connections from this object to p
 
527
    for (KstVectorMap::Iterator j = obj->outputVectors().begin(); j != obj->outputVectors().end(); ++j) {
 
528
      for (KstVectorMap::ConstIterator k = _inputVectors.begin(); k != _inputVectors.end(); ++k) {
 
529
        if (j.data() == k.data()) {
 
530
          return true;
 
531
        }
 
532
      }
 
533
      // also check dependencies on vector stats
 
534
      QDictIterator<KstScalar> scalarDictIter(j.data()->scalars());
 
535
      for (KstScalarMap::ConstIterator k = _inputScalars.begin(); k != _inputScalars.end(); ++k) {
 
536
        for (; scalarDictIter.current(); ++scalarDictIter) {
 
537
          if (scalarDictIter.current() == k.data()) {
 
538
            return true;
 
539
          }  
 
540
        }
 
541
      }
 
542
    }
 
543
  
 
544
    for (KstMatrixMap::Iterator j = obj->outputMatrices().begin(); j != obj->outputMatrices().end(); ++j) {
 
545
      for (KstMatrixMap::ConstIterator k = _inputMatrices.begin(); k != _inputMatrices.end(); ++k) {
 
546
        if (j.data() == k.data()) {
 
547
          return true;
 
548
        }
 
549
      }
 
550
      // also check dependencies on vector stats
 
551
      QDictIterator<KstScalar> scalarDictIter(j.data()->scalars());
 
552
      for (KstScalarMap::ConstIterator k = _inputScalars.begin(); k != _inputScalars.end(); ++k) {
 
553
        for (; scalarDictIter.current(); ++scalarDictIter) {
 
554
          if (scalarDictIter.current() == k.data()) {
 
555
            return true;
 
556
          }  
 
557
        }
 
558
      }
 
559
    }
 
560
    
 
561
    for (KstScalarMap::Iterator j = obj->outputScalars().begin(); j != obj->outputScalars().end(); ++j) {
 
562
      for (KstScalarMap::ConstIterator k = _inputScalars.begin(); k != _inputScalars.end(); ++k) {
 
563
        if (j.data() == k.data()) {
 
564
          return true;
 
565
        }
 
566
      } 
 
567
    }
 
568
  
 
569
    for (KstStringMap::Iterator j = obj->outputStrings().begin(); j != obj->outputStrings().end(); ++j) {
 
570
      for (KstStringMap::ConstIterator k = _inputStrings.begin(); k != _inputStrings.end(); ++k) {
 
571
        if (j.data() == k.data()) {
 
572
          return true;
 
573
        }
 
574
      }
 
575
    }
322
576
  }
323
577
  return false;
324
578
}