Пример #1
0
void Card::deleteRecord(void){
    QSqlDatabase    db;

    db.removeDatabase("qt_sql_default_connection");
    db = QSqlDatabase::addDatabase("QMYSQL");
    db.setHostName("www.themindspot.com");
    db.setPort(3306);
    db.setDatabaseName("themind1_AMS");
    db.setUserName("themind1_ams");
    db.setPassword("nerdsrule");
    db.open();

    QSqlQuery record;

    record.prepare("DELETE FROM SurveyPerson WHERE surveyPersonID = ?");
    record.addBindValue(cardID->text().toInt());
    record.exec();

    record.clear();
    db.close();
    clearFields();

    emit newRecord();
    return;
}
Пример #2
0
    StatusWith<DiskLoc> HeapRecordStore::updateRecord(OperationContext* txn,
                                                      const DiskLoc& loc,
                                                      const char* data,
                                                      int len,
                                                      bool enforceQuota,
                                                      UpdateMoveNotifier* notifier ) {
        HeapRecord* oldRecord = recordFor( loc );
        int oldLen = oldRecord->size;

        if (_isCapped && len > oldLen) {
            return StatusWith<DiskLoc>( ErrorCodes::InternalError,
                                        "failing update: objects in a capped ns cannot grow",
                                        10003 );
        }

        HeapRecord newRecord(len);
        memcpy(newRecord.data.get(), data, len);

        txn->recoveryUnit()->registerChange(new RemoveChange(_data, loc, *oldRecord));
        _data->dataSize += len - oldLen;
        *oldRecord = newRecord;

        cappedDeleteAsNeeded(txn);

        return StatusWith<DiskLoc>(loc);
    }
Пример #3
0
void CSMTools::FixLandsAndLandTexturesMergeStage::perform (int stage, CSMDoc::Messages& messages)
{
    if (stage < mState.mTarget->getData().getLand().getSize())
    {
        CSMWorld::IdTable& landTable = dynamic_cast<CSMWorld::IdTable&>(
            *mState.mTarget->getData().getTableModel(CSMWorld::UniversalId::Type_Lands));

        CSMWorld::IdTable& ltexTable = dynamic_cast<CSMWorld::IdTable&>(
            *mState.mTarget->getData().getTableModel(CSMWorld::UniversalId::Type_LandTextures));

        std::string id = mState.mTarget->getData().getLand().getId(stage);

        CSMWorld::TouchLandCommand cmd(landTable, ltexTable, id);
        cmd.redo();

        // Get rid of base data
        const CSMWorld::Record<CSMWorld::Land>& oldRecord =
            mState.mTarget->getData().getLand().getRecord (stage);

        CSMWorld::Record<CSMWorld::Land> newRecord(CSMWorld::RecordBase::State_ModifiedOnly,
            nullptr, &oldRecord.get());

        mState.mTarget->getData().getLand().setRecord(stage, newRecord);
    }
}
Пример #4
0
    Status HeapRecordStore::updateWithDamages( OperationContext* txn,
                                               const DiskLoc& loc,
                                               const RecordData& oldRec,
                                               const char* damageSource,
                                               const mutablebson::DamageVector& damages ) {
        HeapRecord* oldRecord = recordFor( loc );
        const int len = oldRecord->size;

        HeapRecord newRecord(len);
        memcpy(newRecord.data.get(), oldRecord->data.get(), len);

        txn->recoveryUnit()->registerChange(new RemoveChange(_data, loc, *oldRecord));
        *oldRecord = newRecord;

        cappedDeleteAsNeeded(txn);

        char* root = newRecord.data.get();
        mutablebson::DamageVector::const_iterator where = damages.begin();
        const mutablebson::DamageVector::const_iterator end = damages.end();
        for( ; where != end; ++where ) {
            const char* sourcePtr = damageSource + where->sourceOffset;
            char* targetPtr = root + where->targetOffset;
            std::memcpy(targetPtr, sourcePtr, where->size);
        }

        *oldRecord = newRecord;

        return Status::OK();
    }
bool PoitemTableModel::insertRowIntoTable(const QSqlRecord& record)
{
  if (record.isEmpty())
    return true;

  bool isNull = true;
  for (int i = 0; i < record.count(); i++)
  {
    if (i == record.indexOf("poitem_pohead_id") ||
	(record.value(i).toString().isEmpty() &&
	  (i == record.indexOf("poitem_status") ||
	   i == record.indexOf("poitem_vend_item_descrip") ||
	   i == record.indexOf("poitem_vend_uom") ||
	   i == record.indexOf("poitem_vend_item_number") ||
	   i == record.indexOf("poitem_comments") )))
      continue;
    isNull &= record.isNull(i);
  }
  if (isNull)
    return true;

  QSqlRecord newRecord(record);
  if (! validRow(newRecord))
    return false;

  return QSqlRelationalTableModel::insertRowIntoTable(newRecord);
}
Пример #6
0
void MainWindow::setWindowFields(void){
    //card->setMaximumWidth(460);
    card->setMaximumHeight(450);
    //cardList->setMaximumWidth(175);

    connect(card, SIGNAL(newRecord()), this, SLOT(update()));// Refresh list with new entry.
    connect(cardList->theList, SIGNAL(doubleClicked(QModelIndex)), card, SLOT(editFormMapItem(QModelIndex)));// load selected list item to card.
}
Пример #7
0
int main()
{ 
   FILE *cfPtr; /* credit.dat file pointer */
   int choice;  /* user's choice */

   /* fopen opens the file; exits if file cannot be opened */
   if ( ( cfPtr = fopen( "credit.dat", "rb+" ) ) == NULL ) {
      printf( "File could not be opened.\n" );
   } /* end if */
   else { 

      /* enable user to specify action */
      while ( ( choice = enterChoice() ) != 6 ) { 

         switch ( choice ) { 

            /* create text file from record file */
            case 1:
               textFile( cfPtr );
               break;

            /* update record */
            case 2:
               updateRecord( cfPtr );
               break;

            /* create record */
            case 3:
               newRecord( cfPtr );
               break;

            /* delete existing record */
            case 4:
               deleteRecord( cfPtr );
               break;

			/* sum up balances of valid records and record sum in text file */
			case 5:
				sumRecords( cfPtr );
				break;

            /* display message if user does not select valid choice */
            default:
               printf( "Incorrect choice\n" );
               break;
       
         } /* end switch */

      } /* end while */

      fclose( cfPtr ); /* fclose closes the file */
   } /* end else */
 
   return 0; /* indicates successful termination */

} /* end main */
Пример #8
0
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Returns a new record that can be inserted in the
//  folder
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
ptr<directoryRecord> dicomDir::getNewRecord()
{
	ptr<data> recordsTag(m_pDataSet->getTag(0x0004, 0, 0x1220, true));
	ptr<dataSet> recordDataSet(new dataSet);
	recordsTag->appendDataSet(recordDataSet);

	ptr<directoryRecord> newRecord(new directoryRecord(recordDataSet));
	m_recordsList.push_back(newRecord);

	return newRecord;
}
bool PoitemTableModel::updateRowInTable(int row, const QSqlRecord& record)
{
  // touch everything so we can distinguish unchanged fields from NULL/0 as new val
  for (int i = 0; i < columnCount(); i++)
    setData(index(row, i), data(index(row, i)));

  QSqlRecord newRecord(record);
  if (! validRow(newRecord))
    return false;

  return QSqlRelationalTableModel::updateRowInTable(row, newRecord);
}
Пример #10
0
void CSMWorld::RefIdData::copyTo (int index, RefIdData& target) const
{
    LocalIndex localIndex = globalToLocalIndex (index);

    RefIdDataContainerBase *source = mRecordContainers.find (localIndex.second)->second;

    std::string id = source->getId (localIndex.first);

    std::auto_ptr<CSMWorld::RecordBase> newRecord (source->getRecord (localIndex.first).modifiedCopy());

    target.insertRecord (*newRecord, localIndex.second, id);
}
Пример #11
0
int main()
{
    srand(time(0));
    Process* arrivalQueue = randomProcessQueue(PROCESS_COUNT);
    sortProcessesByArrival(arrivalQueue, 0, PROCESS_COUNT - 1);
	Process* readyQueue = (Process*) malloc(PROCESS_COUNT * sizeof(Process));
    int i = 0, size = 0;
	int shortestProcessIndex = 0;
    int currentProcessIndex = 0;
    bool okToEnd = false;
    Record record = newRecord();
    while(!okToEnd)
    {
        Timeslice* timeslice = (Timeslice*) malloc(sizeof(Timeslice));
        (*timeslice).index = i;
		updateReadyQueue(arrivalQueue, readyQueue, i, &size);
		findShortestProcessIndex(readyQueue, &shortestProcessIndex, size);
        if(size > 0 && (readyQueue[shortestProcessIndex].timeRemaining > 0))
        {
            (*timeslice).pid = (char) (65 + shortestProcessIndex);
			readyQueue[shortestProcessIndex].id = (*timeslice).pid;
			if(readyQueue[shortestProcessIndex].runtime == readyQueue[shortestProcessIndex].timeRemaining) 
			{
				readyQueue[shortestProcessIndex].responseTime = ((float) i) - readyQueue[shortestProcessIndex].arrival;
			}
            readyQueue[shortestProcessIndex].timeRemaining = readyQueue[shortestProcessIndex].timeRemaining - 1.0f;
			int j;
            for(j = 0; j < size; j++)
            {
                if(j != shortestProcessIndex) readyQueue[j].waitTime += 1.0f;
            }
            if(readyQueue[shortestProcessIndex].timeRemaining <= 0)
            {
				readyQueue[shortestProcessIndex].timeFinished = i + 1;
				readyQueue[shortestProcessIndex].turnaroundTime = ((float) i + 1) - readyQueue[shortestProcessIndex].arrival + readyQueue[shortestProcessIndex].timeRemaining;
                addProcess(&record, readyQueue[shortestProcessIndex]);
                if(i >= SIMULATION_LENGTH)
                {
                    okToEnd = true;
                }
            }
        } else {
           (*timeslice).pid = '-';
        }
        addTimeslice(&record, (*timeslice));
        i++;
    }
    printRecord(record);
    return 0;
}
Пример #12
0
void Card::addRecord(void){
    if ( readyToSubmit() == false){
        return;
    }

    QSqlDatabase    db;

    db.removeDatabase("qt_sql_default_connection");
    db = QSqlDatabase::addDatabase("QMYSQL");
    db.setHostName("www.themindspot.com");
    db.setPort(3306);
    db.setDatabaseName("themind1_AMS");
    db.setUserName("themind1_ams");
    db.setPassword("nerdsrule");
    db.open();

    QSqlQuery record;

    record.prepare("INSERT INTO `SurveyPerson` (`surveyPersonID`, `surveyID`, `firstName`, `middleInitial`, `lastName`, `emailAddress`, `emailDomain`, `isMember`)"
                      "VALUES (:id, :sid, :f, :mi, :l, :ea, :ed, :member)");
    record.bindValue(":id", NULL);
    record.bindValue(":sid", 1);
    record.bindValue(":f",fnText->text());
    record.bindValue(":mi",miText->text());
    record.bindValue(":l",lnText->text());
    record.bindValue(":ea",eaText->text());
    record.bindValue(":ed",edText->text());
    record.bindValue(":member",isMember->isChecked());
    record.exec();

    int spid = record.lastInsertId().toInt();
    record.prepare("INSERT INTO `SurveyResult` (`surveyResultID`, `surveyPersonID`, `q0`, `q1`, `q2`, `q3`, `q4`, `q5`)"
                      "VALUES (:id, :spid, :q0, :q1, :q2, :q3, :q4, :q5)");
    record.bindValue(":id", NULL);
    record.bindValue(":spid", spid);
    record.bindValue(":q0",q0->isChecked());
    record.bindValue(":q1",q1->isChecked());
    record.bindValue(":q2",q2->isChecked());
    record.bindValue(":q3",q3->isChecked());
    record.bindValue(":q4",q4->isChecked());
    record.bindValue(":q5",q5->isChecked());
    record.exec();

    db.close();
    clearFields();

    emit newRecord();
    return;
}
Пример #13
0
bool BodhiSubtitle::split(int sequence, long timeOffset)
{
    if (timeOffset < m_minTimeLength)
        return false;

    SrtRecordPtr record = getRecord(sequence);
    Q_ASSERT(record);
    if (record->endTime - timeOffset < m_minTimeLength)
        return false;

    SrtRecordPtr newRecord(new SrtRecord(sequence+1, record->startTime + timeOffset, record->endTime));
    record->endTime = newRecord->startTime;
    updateSequence(newRecord->sequence, 1);
    m_data.insert(newRecord->sequence, newRecord);
    m_changed = true;
    return true;
}
Пример #14
0
void Card::editRecord(void){
    if ( readyToSubmit() == false){
        return;
    }

    QSqlDatabase    db;

    db.removeDatabase("qt_sql_default_connection");
    db = QSqlDatabase::addDatabase("QMYSQL");
    db.setHostName("www.themindspot.com");
    db.setPort(3306);
    db.setDatabaseName("themind1_AMS");
    db.setUserName("themind1_ams");
    db.setPassword("nerdsrule");
    db.open();

    QSqlQuery record;

    record.prepare("UPDATE SurveyPerson SET firstName = ?, middleInitial = ?, lastName = ?, emailAddress = ?, emailDomain = ?, isMember = ? WHERE surveyPersonID = ?");
    record.addBindValue(fnText->text());
    record.addBindValue(miText->text());
    record.addBindValue(lnText->text());
    record.addBindValue(eaText->text());
    record.addBindValue(edText->text());
    record.addBindValue(isMember->isChecked());
    record.addBindValue(cardID->text().toInt());
    record.exec();

    record.prepare("UPDATE SurveyResult SET q0 = ?, q1 = ?, q2 = ?, q3 = ?, q4 = ?, q5 = ? WHERE surveyPersonID = ?");
    record.addBindValue(q0->isChecked());
    record.addBindValue(q1->isChecked());
    record.addBindValue(q2->isChecked());
    record.addBindValue(q3->isChecked());
    record.addBindValue(q4->isChecked());
    record.addBindValue(q5->isChecked());
    record.addBindValue(cardID->text().toInt());
    record.exec();

    record.clear();
    db.close();
    clearFields();

    emit newRecord();
    return;
}
void*
JMemoryManager::New
	(
	const size_t      size,
	const JCharacter* file,
	const JUInt32     line,
	const JBoolean    isArray
	)
{
	if (theAbortUnknownAllocFlag && line == 0)
		{
		cout << "Memory allocated by unknown code, aborting...\n" << endl;
		abort();
		}

	const size_t trueSize = size ? size : 1;
	void* newBlock = malloc(trueSize);

	if (newBlock == NULL)
		{
		cout << "failed to allocate block of size " << trueSize << endl;
		}

	assert(newBlock != NULL);
	if (theInitializeFlag)
		{
		memset(newBlock, theAllocateGarbage, trueSize);
		}

	const JBoolean isManager = JI2B(theConstructingFlag || Instance()->itsRecursionDepth > 0 || theInternalFlag);
	JMMRecord newRecord(GetNewID(), newBlock, trueSize, file, line, isArray, isManager);

	if (theConstructingFlag || Instance()->itsRecursionDepth > 0)
		{
		assert(theAllocStackSize < theStackMax);
		theAllocStack[theAllocStackSize] = newRecord;
		theAllocStackSize++;
		}
	else
		{
		Instance()->AddNewRecord(newRecord);
		}

	return newBlock;
}
Пример #16
0
/*
 * ----------------------------------------------------------
 *            RJRead()
 * ----------------------------------------------------------
 */
int  RJRead( RJFILE *rf )
// untill empty
{
    int   i;
    char  *p;

    newRecord( rf );

    for( i=0; i<keynum; i++ )
       {
       if (!(cfg_readLine( rf->handle, rf->buffer, line_buf_size ))) return 0; // end
       if ( strnicmp( rf->buffer, FieldName[i].qkey, strlen(FieldName[i].qkey)) != 0 )
	   return 0;  // error journal record
       p = strchr( rf->buffer, '=' );
       if ( p == NULL )   return 0;
       p++;
       trim(p);
       writeContent( rf, 100+i, p );
       }
    return 1;
}
Пример #17
0
int main(int argc, const char * argv[])
{
    
    //test list
    List *StudentSystem = (List *)malloc(sizeof(List));
    initList(StudentSystem, matchRecord, cmpRecord);

    StudentRecord *studentData = (StudentRecord *)malloc(sizeof(StudentRecord));
    
    newRecord(studentData);
    
    showRecord(studentData);
    
    insertListElmtNext(StudentSystem, StudentSystem->tail, (void *)studentData);
    
    showList(StudentSystem);
    
    removeListElmtNext(StudentSystem, StudentSystem->head, (void **)&studentData);
    
    showList(StudentSystem);
    
    /*test record.h Student func
     
    Student *studentA = (Student *)malloc(sizeof(Student));
    
    newRecord(studentA);
    
    showRecord(studentA);
    
    free(studentA);
    
    if (studentA)
    {
        printf("existing %d", studentA->iNumber);
    }
    */
    return 0;
}
Пример #18
0
TractionTypeView::TractionTypeView(Configuration *cfg, QObject *parent) :
    QObject(parent)
{
    m_parent = parent;
    config = Configuration::instance();
    //sql->setConfig(config);
    sql = SQL::instance();
    mainWindow* myParent = qobject_cast<mainWindow*>(m_parent);
    tableView = myParent->ui->tblTractionTypes;
    tableView->verticalHeader()->resize(2,20);

    QSqlDatabase db = QSqlDatabase::database();
    qDebug()<<db.databaseName();
    connect(tableView->verticalHeader(), SIGNAL(sectionCountChanged(int,int)), this, SLOT(Resize(int,int)));
    tableView->setAlternatingRowColors(true);

    model = new MyTractionTypesTableModel(this, db);
    model->setTable("TractionTypes");
    model->setEditStrategy(QSqlTableModel::OnFieldChange);
    model->query().setForwardOnly(false);
    model->select();
    QString name = model->record(0).value("description").toString();
    tableView->setModel(model);

    menu = new QMenu();
    addAct = new QAction(tr("Add Traction Type"),this);
    addAct->setToolTip(tr("Add a new traction type"));
    connect(addAct, SIGNAL(triggered()), this, SLOT(newRecord()));
    delAct = new QAction(tr("Delete Traction Type"),this);
    delAct->setToolTip(tr("Delete an existing traction type"));
    connect(delAct, SIGNAL(triggered()), this, SLOT(delRecord()));

    tableView->setContextMenuPolicy(Qt::CustomContextMenu);
    connect(tableView, SIGNAL(customContextMenuRequested( const QPoint& )), this, SLOT(tablev_customContextMenu( const QPoint& )));

    tableView->show();
}
int main( void )
{
FILE *cfPtr; // credit.dat file pointer
unsigned int choice; // user's choice
// fopen opens the file; exits if file cannot be opened
if ( ( cfPtr = fopen( "/home/abubakr/test.txt", "rb+" ) ) == NULL ) {
puts( "File could not be opened." );
} // end if
else {
// enable user to specify action
while ( ( choice = enterChoice() ) != 5 ) {
switch ( choice ) {
// create text file from record file
case 1:
textFile( cfPtr );
break;
// update record
case 2:
updateRecord( cfPtr );
break;
// create record
case 3:
newRecord( cfPtr );
break;
// delete existing record
case 4:
deleteRecord( cfPtr );
break;
// display message if user does not select valid choice
default:
puts( "Incorrect choice" );
break;
} // end switch
} // end while
fclose( cfPtr ); // fclose closes the file
} // end else
} // end main
Пример #20
0
// - try to open existing DB file according to params set with setFileInfo
bferr TBinFileBase::open(uInt32 aExtraHeadersize, void *aExtraHeaderP, TUpdateFunc aUpdateFunc)
{
  // make sure it is closed first
  close();
  // save extra header info
  fExtraHeaderSize=aExtraHeadersize;
  fExtraHeaderP=aExtraHeaderP;
  // try to open file for (binary) update
  if (!platformOpenFile(fFilename.c_str(),fopm_update))
    return BFE_NOTFOUND;
  // read header
  fHeaderDirty=false;
  platformSeekFile(0);
  if (!platformReadFile(&fBinFileHeader,sizeof(fBinFileHeader))) {
    close();
    return BFE_BADSTRUCT;
  }
  // check type and Version
  if (fBinFileHeader.idword!=fIdWord) {
    close();
    return BFE_BADTYPE;
  }
  // remember the version we found when trying to open
  fFoundVersion = fBinFileHeader.version;
  // check need for upgrade
  if (fBinFileHeader.version!=fVersion) {
    // try to update file if update-func is provided
    if (aUpdateFunc) {
      // check if we can update (no data provided for update)
      uInt32 newrecordsize=aUpdateFunc(fFoundVersion,fVersion,NULL,NULL,0);
      if (newrecordsize) {
        // we can update from current to requested version
        // - allocate buffer for all records
        uInt32 numrecords = fBinFileHeader.numrecords;
        uInt32 oldrecordsize = fBinFileHeader.recordsize;
        void *oldrecords = malloc(numrecords * oldrecordsize);
        if (!oldrecords) return BFE_MEMORY;
        // - read all current records into memory (relative to old headersize)
        readRecord(0,oldrecords,numrecords);
        // Update header because extra header might have changed in size
        if (fExtraHeaderP && (fBinFileHeader.headersize!=sizeof(TBinFileHeader)+fExtraHeaderSize)) {
          // (extra) header has changed in size
          // - read old extra header (or part of it that will be retained in case it shrinks between versions)
          uInt32 oldEHdrSz = fBinFileHeader.headersize-sizeof(TBinFileHeader);
          platformSeekFile(sizeof(TBinFileHeader));
          platformReadFile(fExtraHeaderP,oldEHdrSz<=fExtraHeaderSize ? oldEHdrSz : fExtraHeaderSize);
          // - adjust the overall header size
          fBinFileHeader.headersize = sizeof(TBinFileHeader)+fExtraHeaderSize;
          // - let the update function handle init of the extra header
          aUpdateFunc(fFoundVersion,fVersion,NULL,fExtraHeaderP,0);
          // - make sure new extra header gets written
          fExtraHeaderDirty = true;
        }
        // - modify header fields
        fBinFileHeader.version=fVersion; // update version
        fBinFileHeader.recordsize=newrecordsize; // update record size
        fHeaderDirty=true; // header must be updated
        // - write new header (to make sure file is at least as long as header+extraheader)
        flushHeader();
        // - truncate the file (taking new extra header size into account already, in case it has changed)
        truncate();
        // - now convert buffered records
        void *newrecord = malloc(newrecordsize);
        for (uInt32 i=0; i<numrecords; i++) {
          // call updatefunc to convert record
          if (aUpdateFunc(fFoundVersion,fVersion,(void *)((uInt8 *)oldrecords+i*oldrecordsize),newrecord,oldrecordsize)) {
            // save new record
            uInt32 newi;
            newRecord(newi,newrecord);
          }
        }
        // - forget buffers
        free(newrecord);
        free(oldrecords);
        // - flush new header
        flushHeader();
      }
      else {
        // cannot update
        close();
        return BFE_BADVERSION;
      }
    }
    else {
      // cannot update
      close();
      return BFE_BADVERSION;
    }
  }
  // check record compatibility
  if (fExpectedRecordSize && fExpectedRecordSize!=fBinFileHeader.recordsize) {
    close();
    return BFE_BADSTRUCT;
  }
  // check extra header compatibility
  if (fBinFileHeader.headersize<sizeof(TBinFileHeader)+fExtraHeaderSize) {
    close();
    return BFE_BADSTRUCT;
  }
  // read extra header
  if (fExtraHeaderP && fExtraHeaderSize>0) {
    platformSeekFile(sizeof(TBinFileHeader));
    platformReadFile(fExtraHeaderP,fExtraHeaderSize);
    fExtraHeaderDirty=false;
  }
  return BFE_OK;
} // TBinFileBase::open
Пример #21
0
int main()
{
    srand(time(0));
    Process* queue = randomProcessQueue(PROCESS_COUNT);
    sortProcessesByArrival(queue, 0, PROCESS_COUNT - 1);
    int i = 0;
    float timer = 0;
    int RevIndex = PROCESS_COUNT - 1;
    int currentProcessIndex = 0;
    bool okToEnd = false;
    float wait = 0;
    Record record = newRecord();
    while(!okToEnd)
    {
        Timeslice* timeslice = (Timeslice*) malloc(sizeof(Timeslice));
        (*timeslice).index = i;
        if(queue[currentProcessIndex].arrival < i)
        {
             (*timeslice).pid = (char) (65 + currentProcessIndex);
		if((*timeslice).pid > 65+25){
			(*timeslice).pid += 6;
		}
		int j;
		for(j = currentProcessIndex+1; j < PROCESS_COUNT; j++){
			if(queue[j].arrival < i){
				queue[j].waitTime +=1.0f;
				queue[j].responseTime += 1.0f;
				if(queue[j].priority < queue[currentProcessIndex].priority){
					printf("current time %d, swap priority %d with priority %d\n", i, queue[currentProcessIndex].priority, queue[j].priority);
					int indexOfNextMin = j;
					currentProcessIndex = indexOfNextMin;
				}			
			}	
		}
		queue[currentProcessIndex].timeRemaining = queue[currentProcessIndex].timeRemaining - 1.0f; 
            if(queue[currentProcessIndex].timeRemaining <= 0)
            {
		queue[currentProcessIndex].turnaroundTime = queue[currentProcessIndex].runtime + queue[currentProcessIndex].waitTime;
		queue[currentProcessIndex].timeFinished += i;
		queue[currentProcessIndex].id = (*timeslice).pid;

                addProcess(&record, queue[currentProcessIndex]);
                if(i >= SIMULATION_LENGTH)
                {
                    okToEnd = true;
                } else {
			timer = timer + queue[currentProcessIndex].turnaroundTime;
		    currentProcessIndex++;
			int x = 0;
			bool swapped = false;
			int indexOfNextMin = currentProcessIndex;
			for(x = currentProcessIndex; x < PROCESS_COUNT - 1; x++)
			{
				if(queue[x].arrival < i)
				if(queue[indexOfNextMin].priority > queue[x].priority)
				{
					printf("current time %d, swap priority %d with priority %d\n", i, queue[currentProcessIndex].priority, queue[x].priority);
					indexOfNextMin = x;
					currentProcessIndex = indexOfNextMin;
				}
			}
                }
            }
        } else {
           (*timeslice).pid = '-';
        }
        addTimeslice(&record, (*timeslice));
        i++;
    }
    printRecord(record);
    return 0;
}
void CCodeCheckpointDebugMgr::UpdateRecords()
{
	//Retrieve the latest snapshot
	ICodeCheckpointMgr* pCodeCheckpointMgr = gEnv->pCodeCheckpointMgr;
	if (pCodeCheckpointMgr)
	{
		size_t nextSnapshotCount = pCodeCheckpointMgr->GetTotalCount();

		size_t currIdx = 0;

		TCheckpointDebugList::iterator unwatchedIt = m_unwatchedPoints.begin(),watchedIt = m_watchedPoints.begin();

		///Update existing points with their snapshot
		size_t currSnapShotcount = m_watchedPoints.size() + m_unwatchedPoints.size();
		while( currIdx < currSnapShotcount && currIdx < nextSnapshotCount)
		{
			string name = pCodeCheckpointMgr->GetCheckPointName(currIdx);
			const CCodeCheckpoint* pCheckpoint = pCodeCheckpointMgr->GetCheckpoint(currIdx);

			///Check if we are a watched point
			if(watchedIt != m_watchedPoints.end() && (name == watchedIt->m_name))
			{
				CheckpointDebugRecord& currentRec = *watchedIt;
				UpdateRecord(pCheckpoint, currentRec);
				++watchedIt;
			}
			//Otherwise checked if we are unwatched point
			else if(unwatchedIt != m_unwatchedPoints.end() && (name == unwatchedIt->m_name))
			{
				CheckpointDebugRecord& currentRec = *unwatchedIt;
				UpdateRecord(pCheckpoint, currentRec);	
				++unwatchedIt;
			}
			///This should never happen, as each existing point should already have been inserted into either the watched or unwatched vector.
			else
			{
				CRY_ASSERT(false);
			}

			++currIdx;
		}

		///Add entities that are new to this snapshot
		while(currIdx < nextSnapshotCount)
		{
			const char* name = pCodeCheckpointMgr->GetCheckPointName(currIdx);
			const CCodeCheckpoint* pCheckpoint = pCodeCheckpointMgr->GetCheckpoint(currIdx);

			CheckpointDebugRecord newRecord(pCheckpoint, name, currIdx);

			//If we have a current request to watch this point, make sure it goes into watched points
			TBookmarkMap::iterator bookmarkedIt = m_bookmarkedNames.find(name);
			if(bookmarkedIt != m_bookmarkedNames.end())
			{
				newRecord.UpdateWatched(bookmarkedIt->second);
				m_watchedPoints.push_back(newRecord);
				//Clean up the bookmark as its already been hit
				m_bookmarkedNames.erase(bookmarkedIt);
			}
			else
				m_unwatchedPoints.push_back(newRecord);


			++currIdx;
		}
	}
}
Пример #23
0
void HumanoidDataLogger::logData() {
	
	dataMutex.Lock();
	newRecord();
	assignItem(TIME, simThread->sim_time);
	assignItem(STATE_CODE, state);
	assignItem(CONTROL_TIME, controlTime);
	
	assignGroup(JOINT_ANGLES, q);
	assignGroup(JOINT_RATES, qd);
	assignGroup(JOINT_TORQUES, tau);
	Vector6F force;
	
	force.head(3) = grfInfo.fCoPs[0];
	force.segment(3,2) = grfInfo.pCoPs[0].head(2);
	force(5)     = grfInfo.nCoPs[0];
	assignGroup(RIGHT_FOOT_WRENCH, force);
	assignItem(RCONT_STATE, contactState[0]);
	assignItem(RSLIDE_STATE, slidingState[0]);
	
	force.head(3) = grfInfo.fCoPs[1];
	force.segment(3,2) = grfInfo.pCoPs[1].head(2);
	force(5)     = grfInfo.nCoPs[1];
	assignGroup(LEFT_FOOT_WRENCH, force);
	assignItem(LCONT_STATE, contactState[1]);
	assignItem(LSLIDE_STATE, slidingState[1]);
	
	force.head(3) = grfInfo.fZMP;
	force.segment(3,2) = grfInfo.pZMP.head(2);
	force(5)     = grfInfo.nZMP;
	assignGroup(ZMP_WRENCH, force);
	
	assignGroup(ZMP_WRENCH_OPT, zmpWrenchOpt);
	assignGroup(ZMP_POS_OPT, zmpPosOpt);
	
	assignGroup(COM_POSITION, pCom);
	assignGroup(COM_POSITION_DES, pComDes);
	assignGroup(COM_VELOCITY, vCom);
	assignGroup(COM_VELOCITY_DES, vComDes);
	
	assignGroup(CENTROIDAL_MOMENTUM, centMom);
	assignGroup(HDES, hDes);
	
	assignGroup(HDOT_DES, hDotDes);
	assignGroup(HDOT_OPT, hDotOpt);
	
	assignGroup(QDD_OPT, qdd);
	assignGroup(QDD_ACT, qddA);
	
	
	assignGroup(RIGHT_FOOT_POS, pFoot[0]);
	assignGroup(RIGHT_FOOT_POS_DES, pDesFoot[0]);
	
	assignGroup(RIGHT_FOOT_VEL, vFoot[0]);
	assignGroup(RIGHT_FOOT_VEL_DES, vDesFoot[0]);
	
	assignGroup(RIGHT_FOOT_ACC, aFoot[0]);
	assignGroup(RIGHT_FOOT_ACC_DES, aDesFoot[0]);
	
	assignGroup(LEFT_FOOT_POS, pFoot[1]);
	assignGroup(LEFT_FOOT_POS_DES, pDesFoot[1]);
	
	assignGroup(LEFT_FOOT_VEL, vFoot[1]);
	assignGroup(LEFT_FOOT_VEL_DES, vDesFoot[1]);
	
	assignGroup(LEFT_FOOT_ACC, aFoot[1]);
	assignGroup(LEFT_FOOT_ACC_DES, aDesFoot[1]);
	
	assignGroup(RWRENCH_OPT, fs.head(6));
	assignGroup(LWRENCH_OPT, fs.tail(6));
	
	assignMatrixGroup(JRF, grfInfo.footJacs[0]);
	assignMatrixGroup(JLF, grfInfo.footJacs[1]);
	
	assignGroup(RIGHT_FOOT_SPATIAL_WRENCH, grfInfo.footWrenches[0]);
	assignGroup(LEFT_FOOT_SPATIAL_WRENCH, grfInfo.footWrenches[1]);
	
	assignGroup(CANDG, artic->CandG);
	assignMatrixGroup(HMAT,artic->H);
	dataMutex.Unlock();
}
Пример #24
0
DbRecord DbFile::newRecord(const char* key, const char* value, RecordType type)
{
	switch (type)
	{
	case Normal:
	{
		size_t size = DbRecord::getSize(key, value, type);
		// Record size too large
		if (size > DbPage::maxFreeSpace)
			return newRecord(key, value, Long);

		return getNewRecord(key, value, type);
	}
	case Long:
	{
		// Check value length
		size_t size = DbRecord::getSize(key, value, type);
		int valueLen = strlen(value);
		int leftValueLen = size - DbPage::maxFreeSpace;
		// Record size too small
		if (leftValueLen <= 0)
			return newRecord(key, value, Normal);

		// Split the first value str
		std::string currentStr(value, valueLen - leftValueLen);

		// Init iterators
		DbRecord firstRecord(getPage(0), 0);
		DbRecord currentRecord(getPage(0), 0);
		DbRecord lastRecord(getPage(0), 0);

		// Create records
		while (leftValueLen > 0)
		{
			lastRecord = currentRecord;
			currentRecord = getNewRecord(key, currentStr.c_str(), type);

			// Update record iterator and next record cursor
			if (type != Long)
			{
				lastRecord.nextExtendedRecord(currentRecord.getPage()->getId(), currentRecord.getCursor());
				leftValueLen -= currentStr.size();
			}
			else
			{
				firstRecord = currentRecord;
				type = LongExtended;
			}

			// Get the size of next value in the new record
			if (leftValueLen > 0)
			{
				size = DbRecord::getSize(key, value + (valueLen - leftValueLen), type);
				if (size > DbPage::maxFreeSpace)
					currentStr = std::string(value + (valueLen - leftValueLen), leftValueLen - (size - DbPage::maxFreeSpace));
				else
					currentStr = std::string(value + (valueLen - leftValueLen), leftValueLen);
			}
		}

		currentRecord.nextExtendedRecord(0, 0);
		return firstRecord;
	}
	default:
		error("Not known record type");
		return DbRecord(getPage(0), 0);		// Avoid warning
	}
}
Пример #25
0
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Constructor
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
dicomDir::dicomDir(ptr<dataSet> pDataSet):
	m_pDataSet(pDataSet)
{
	if(m_pDataSet == 0)
	{
		m_pDataSet =new dataSet;
	}

	// Parse the dataset
	///////////////////////////////////////////////////////////
	lockObject lockDataSet(pDataSet);

	// Get the DICOMDIR sequence
	///////////////////////////////////////////////////////////
	typedef std::map<std::uint32_t, ptr<directoryRecord> > tOffsetsToRecords;
	tOffsetsToRecords offsetsToRecords;
	for(std::uint32_t scanItems(0); ; ++scanItems)
	{
		ptr<dataSet> pDataSet(m_pDataSet->getSequenceItem(0x0004, 0, 0x1220, scanItems));
		if(pDataSet == 0)
		{
			break;
		}
		ptr<directoryRecord> newRecord(new directoryRecord(pDataSet));
		offsetsToRecords[pDataSet->getItemOffset()] = newRecord;
		m_recordsList.push_back(newRecord);
	}

	// Scan all the records and update the pointers
	///////////////////////////////////////////////////////////
	for(tOffsetsToRecords::iterator scanRecords(offsetsToRecords.begin()); scanRecords != offsetsToRecords.end(); ++scanRecords)
	{
		std::uint32_t nextRecordOffset(scanRecords->second->getRecordDataSet()->getUnsignedLong(0x0004, 0, 0x1400, 0));
		std::uint32_t childRecordOffset(scanRecords->second->getRecordDataSet()->getUnsignedLong(0x0004, 0, 0x1420, 0));
		std::uint32_t referencedRecordOffset(scanRecords->second->getRecordDataSet()->getUnsignedLong(0x0004, 0, 0x1504, 0));

		tOffsetsToRecords::iterator findNextRecord(offsetsToRecords.find(nextRecordOffset));
		if(findNextRecord != offsetsToRecords.end())
		{
			scanRecords->second->setNextRecord(findNextRecord->second);
		}

		tOffsetsToRecords::iterator findChildRecord(offsetsToRecords.find(childRecordOffset));
		if(findChildRecord != offsetsToRecords.end())
		{
			scanRecords->second->setFirstChildRecord(findChildRecord->second);
		}

		tOffsetsToRecords::iterator findReferencedRecord(offsetsToRecords.find(referencedRecordOffset));
		if(findReferencedRecord != offsetsToRecords.end())
		{
			scanRecords->second->setReferencedRecord(findReferencedRecord->second);
		}
	}

	// Get the position of the first record
	///////////////////////////////////////////////////////////
	tOffsetsToRecords::iterator findRecord(offsetsToRecords.find(m_pDataSet->getUnsignedLong(0x0004, 0, 0x1200, 0)));
	if(findRecord == offsetsToRecords.end())
	{
		return;
	}
	setFirstRootRecord(findRecord->second);
}