Пример #1
0
/// <summary>
/// Test the data structure
/// </summary>
void testDataPoints()
{
	struct dataPoint *head = getNewDataPoint(10, 1);

	printf("Start of tests\n");
	printf("First: Value: %lu\t timestamp: %lu\n\n", head->value, head->timestamp);

	head = insertData(head, 20, 2);

	// Insert new element
	printf("Second inserted\n");
	printf("Head: \t\tValue %lu\t timestamp %lu\n", head->value, head->timestamp);
	printf("Head->next: \tValue %lu\t timestamp %lu\n\n", head->next->value, head->next->timestamp);

	// Deletion tests
	printf("Before deletion:\tHead->next: %p\n", head->next);
	deleteLastDataPoint(head);
	printf("After deletion: \tHead->next: %p\n\n", head->next);

	// Insert a new element again.
	printf("Head: Value %lu\n", head->value);
	head = insertData(head, 30, 3);
	printf("Insert 30:  Value %lu\n", head->value);
	printf("Head->next: Value %lu\n", head->next->value);

	printf("\nEnd of tests");
}
Пример #2
0
int main(){
    LinkedList* list = creatList();
    insertData(list,12);
    insertData(list,13);
    insertData(list,14);
    insertData(list,16);
    insertData(list,17);
    printList(list);
    reverseList(list);
    printList(list);
}
Пример #3
0
int writeApplePartitionMap(int pNum, AbstractFile* file, Partition* partitions, unsigned int BlockSize, ChecksumFunc dataForkChecksum, void* dataForkToken, ResourceKey **resources, NSizResource** nsizIn) {
  AbstractFile* bufferFile;
  BLKXTable* blkx;
  ChecksumToken uncompressedToken;
  Partition* buffer;
  NSizResource* nsiz;
  CSumResource csum;
 
  size_t realPartitionSize = (PARTITION_SIZE * SECTOR_SIZE) / BlockSize * BlockSize; 
  buffer = (Partition*) malloc(realPartitionSize);
  memcpy(buffer, partitions, realPartitionSize);
  memset(&uncompressedToken, 0, sizeof(uncompressedToken));
   
  flipPartition(buffer, TRUE, BlockSize);

  bufferFile = createAbstractFileFromMemory((void**)&buffer, realPartitionSize);
   
  blkx = insertBLKX(file, bufferFile, PARTITION_OFFSET * BlockSize / SECTOR_SIZE, realPartitionSize / SECTOR_SIZE, pNum, CHECKSUM_CRC32,
              &BlockCRC, &uncompressedToken, dataForkChecksum, dataForkToken, NULL, 0);
  
  bufferFile->close(bufferFile);

  *((uint32_t*)blkx->checksum.data) = uncompressedToken.crc;
  
  csum.version = 1;
  csum.type = CHECKSUM_MKBLOCK;
  csum.checksum = uncompressedToken.block;

  char pName[100];
  sprintf(pName, "Apple (Apple_partition_map : %d)", pNum + 1);	
  *resources = insertData(*resources, "blkx", pNum, pName, (const char*) blkx, sizeof(BLKXTable) + (blkx->blocksRunCount * sizeof(BLKXRun)), ATTRIBUTE_HDIUTIL);
  *resources = insertData(*resources, "cSum", 0, "", (const char*) (&csum), sizeof(csum), 0);
  
  nsiz = (NSizResource*) malloc(sizeof(NSizResource));
  memset(nsiz, 0, sizeof(NSizResource));
  nsiz->isVolume = FALSE;
  nsiz->blockChecksum2 = uncompressedToken.block;
  nsiz->partitionNumber = 0;
  nsiz->version = 6;
  nsiz->next = NULL;
  
  if((*nsizIn) == NULL) {
    *nsizIn = nsiz;
  } else {
    nsiz->next = (*nsizIn)->next;
    (*nsizIn)->next = nsiz;
  }
  
  free(buffer);
  free(blkx);

  return pNum + 1;
}
Пример #4
0
void test_insert_string_data_in_queue1() {
    Queue* queue = createQueue();
    string data1 = "shital" , data2 = "shweta" , data3 = "shabarin";

    insertData(queue , &data1 , 1);
    insertData(queue , &data2 , 5);
    insertData(queue , &data3 , 2);
    insertData(queue , &data3 , 3);

    checkPriority(queue);
    ASSERT(queue->length == 4);
}
Пример #5
0
void test_insert_float_data_in_queue1() {
    Queue* queue = createQueue();
    Node* node;
    float data1 = 10.5 , data2 = 20.5 , data3 = 30.5;

    insertData(queue , &data1 , 1);
    insertData(queue , &data2 , 5);
    insertData(queue , &data3 , 2);
    insertData(queue , &data3 , 3);

    checkPriority(queue);
    ASSERT(queue->length == 4);
}
Пример #6
0
void test_insert_integer_data_in_queue1() {
    Queue* queue = createQueue();
    Node* node;
    int data1 = 10 , data2 = 20 , data3 = 30;

    insertData(queue , &data1 , 1);
    insertData(queue , &data2 , 3);
    insertData(queue , &data3 , 2);
    insertData(queue , &data3 , 1);

    checkPriority(queue);
    ASSERT(queue->length == 4);
}
Пример #7
0
void test_delete_integer_data_in_queue1() {
    Queue* queue = createQueue();
    int removedData;
    int data1 = 10 , data2 = 20 , data3 = 30;

    insertData(queue , &data1 , 1);
    insertData(queue , &data2 , 3);
    insertData(queue , &data3 , 2);

    ASSERT(queue->length == 3);
    removedData =*(int*)deleteData(queue);
    ASSERT(queue->length == 2);
    ASSERT(removedData == 10);
}
Пример #8
0
void AddClientDialog::loadQuery()
{
    ThreadControl *tc = qobject_cast<ThreadControl *>( sender() );
    if( !tc )
        return;

    int i = tc->getIndexOfLastQuery( qList );
    if( i < 0 )
        return;

    QStringList list = tc->getDataList();
    switch(i)
    {
        case 0:
        {
            checkData( list );
            break;
        }
        case 1:
        {
            if( list.count() > 0 )
                insertData( list.first() );
            break;
        }
    }
}
Пример #9
0
int writeDriverDescriptorMap(int pNum, AbstractFile* file, DriverDescriptorRecord* DDM, unsigned int BlockSize, ChecksumFunc dataForkChecksum, void* dataForkToken,
				ResourceKey **resources) {
  AbstractFile* bufferFile;
  BLKXTable* blkx;
  ChecksumToken uncompressedToken;
  DriverDescriptorRecord* buffer;
  
  buffer = (DriverDescriptorRecord*) malloc(DDM_SIZE * BlockSize);
  memcpy(buffer, DDM, DDM_SIZE * BlockSize);
  memset(&uncompressedToken, 0, sizeof(uncompressedToken));
  
  flipDriverDescriptorRecord(buffer, TRUE);

  bufferFile = createAbstractFileFromMemory((void**)&buffer, DDM_SIZE * BlockSize);
  
  blkx = insertBLKX(file, bufferFile, DDM_OFFSET, DDM_SIZE, DDM_DESCRIPTOR, CHECKSUM_CRC32, &CRCProxy, &uncompressedToken,
			dataForkChecksum, dataForkToken, NULL, 0);
              
  blkx->checksum.data[0] = uncompressedToken.crc;
  
  char pName[100];
  sprintf(pName, "Driver Descriptor Map (DDM : %d)", pNum + 1);	
  *resources = insertData(*resources, "blkx", pNum, pName, (const char*) blkx, sizeof(BLKXTable) + (blkx->blocksRunCount * sizeof(BLKXRun)), ATTRIBUTE_HDIUTIL);
  
  free(buffer);
  bufferFile->close(bufferFile);
  free(blkx);

  pNum++;

  if((DDM_SIZE * BlockSize / SECTOR_SIZE) - DDM_SIZE > 0)
    pNum = writeFreePartition(pNum, file, DDM_SIZE, (DDM_SIZE * BlockSize / SECTOR_SIZE) - DDM_SIZE, resources);

  return pNum;
}
Пример #10
0
void test_delete_string_data_in_queue() {
    Queue* queue = createQueue();
    string deletedData;
    string data1 = "shital" , data2 = "shweta" , data3 = "shabarin";

    insertData(queue , &data1 , 1);
    insertData(queue , &data2 , 5);
    insertData(queue , &data3 , 2);
    insertData(queue , &data3 , 3);

    ASSERT(queue->length == 4);
    checkPriority(queue);
    strcpy(deletedData  , *(string*)deleteData(queue));
    ASSERT(!strcmp(deletedData , "shital"));
    ASSERT(queue->length == 3);
}
Пример #11
0
void test_delete_float_data_in_queue1() {
    Queue* queue = createQueue();
    float deletedData;
    float data1 = 10.5 , data2 = 20.5 , data3 = 30.5;

    insertData(queue , &data1 , 1);
    insertData(queue , &data2 , 5);
    insertData(queue , &data3 , 2);
    insertData(queue , &data3 , 3);

    ASSERT(queue->length == 4);
    checkPriority(queue);
    deletedData  = *(float*)deleteData(queue);
    ASSERT(queue->length == 3);
    ASSERT(deletedData == 10.5);
}
Пример #12
0
void TestSqliteController::onInsertTable(yhge::Event* event)
{
    CCLOG("####insert table#####");
    insertData("test1","testa",1,1.1);
//    insertData("test2","testb",2,2.2);
//    insertData("test3","testc",3,3.3);
}
Пример #13
0
// Create a Recurring
bool
QuasarDB::create(Recurring& recurring)
{
    if (!validate(recurring)) return false;

    QString cmd = insertCmd("recurring", "recurring_id", "gltx_id,"
			    "description,frequency,day1,day2,max_post,"
			    "last_posted,post_count,group_id");
    Stmt stmt(_connection, cmd);

    insertData(recurring, stmt);
    stmtSetId(stmt, recurring.gltxId());
    stmtSetString(stmt, recurring.description());
    stmtSetInt(stmt, recurring.frequency());
    stmtSetInt(stmt, recurring.day1());
    stmtSetInt(stmt, recurring.day2());
    stmtSetInt(stmt, recurring.maxPostings());
    stmtSetDate(stmt, recurring.lastPosted());
    stmtSetInt(stmt, recurring.postingCount());
    stmtSetId(stmt, recurring.cardGroup());

    if (!execute(stmt)) return false;

    commit();
    dataSignal(DataEvent::Insert, recurring);
    return true;
}
Пример #14
0
// Create a Slip
bool
QuasarDB::create(Slip& slip)
{
    if (!validate(slip)) return false;

    // Auto allocate slip number
    if (slip.number().stripWhiteSpace() == "#") {
	fixed number = uniqueNumber("slip", "number");
	slip.setNumber(number.toString());
    }

    QString cmd = insertCmd("slip", "slip_id", "vendor_id,number,"
			    "waybill,carrier,ship_date,store_id,"
			    "inv_num,num_pieces,status,post_date");
    Stmt stmt(_connection, cmd);

    insertData(slip, stmt);
    stmtSetId(stmt, slip.vendorId());
    stmtSetString(stmt, slip.number());
    stmtSetString(stmt, slip.waybill());
    stmtSetString(stmt, slip.carrier());
    stmtSetDate(stmt, slip.shipDate());
    stmtSetId(stmt, slip.storeId());
    stmtSetString(stmt, slip.invoiceNumber());
    stmtSetInt(stmt, slip.numPieces());
    stmtSetString(stmt, slip.status());
    stmtSetDate(stmt, slip.postDate());

    if (!execute(stmt)) return false;
    if (!sqlCreateLines(slip)) return false;

    commit();
    dataSignal(DataEvent::Insert, slip);
    return true;
}
// TODO: optimize and check if pattern is just one byte, so memset can be used
// TODO: see if copying larger chunks with memcpy is faster, so 
QMimeData* ByteArraySequenceGenerator::generateData()
{
    const Okteta::Byte firstByte = 0;
    const Okteta::Byte lastByte = 255;

    const int insertDataSize = lastByte-firstByte+1;
    QByteArray insertData( insertDataSize, '\0' );

    Okteta::Byte byte = firstByte;
    for( int i=0; i < insertDataSize; ++i, ++byte )
        insertData[i] = byte;

    QMimeData* mimeData = new QMimeData;
    mimeData->setData( mimeType(), insertData );

// TODO: a method to get the description of the change, e.g. 
#if 0
    Okteta::ChangesDescribable *changesDescribable =
        qobject_cast<Okteta::ChangesDescribable*>( mByteArrayModel );

    if( changesDescribable )
        changesDescribable->openGroupedChange( i18n("Sequence inserted.") );
    mByteArrayView->insert( insertData );
//     mByteArrayModel->replace( filteredSection, filterResult );
    if( changesDescribable )
        changesDescribable->closeGroupedChange();
#endif

    return mimeData;
}
Пример #16
0
// TODO: use different RNG, with multiple characteristics and offer them in the config
QMimeData* ByteArrayRandomDataGenerator::generateData()
{
    qsrand( (unsigned int)time(0) );

    const int insertDataSize = mSettings.size;
    QByteArray insertData( insertDataSize, '\0' );

    for( int i=0; i < insertDataSize; ++i )
        insertData[i] = qrand() % 256; // TODO: modulo is expensive, even if easy to use

    QMimeData* mimeData = new QMimeData;
    mimeData->setData( mimeType(), insertData );

// TODO: a method to get the description of the change, e.g. 
#if 0
    Okteta::ChangesDescribable *changesDescribable =
        qobject_cast<Okteta::ChangesDescribable*>( mByteArrayModel );

    if( changesDescribable )
        changesDescribable->openGroupedChange( i18n("RandomData inserted.") );
    mByteArrayView->insert( insertData );
//     mByteArrayModel->replace( filteredSection, filterResult );
    if( changesDescribable )
        changesDescribable->closeGroupedChange();
#endif

    return mimeData;
}
Пример #17
0
// TODO: optimize and check if pattern is just one byte, so memset can be used
// TODO: see if copying larger chunks with memcpy is faster, so 
QMimeData* ByteArrayPatternGenerator::generateData()
{
    const int patternSize = mSettings.pattern.size();

    const int insertDataSize = mSettings.count * patternSize;

    QByteArray insertData( insertDataSize, '\0' );

    char* rawInsertData = insertData.data();
    const char* rawPatternData = mSettings.pattern.constData();

    for( int i=0; i < insertDataSize; i+= patternSize )
        memcpy( &rawInsertData[i], rawPatternData, patternSize );

    QMimeData* mimeData = new QMimeData;
    mimeData->setData( mimeType(), insertData );

// TODO: a method to get the description of the change, e.g. 
#if 0
    Okteta::ChangesDescribable *changesDescribable =
        qobject_cast<Okteta::ChangesDescribable*>( mByteArrayModel );

    if( changesDescribable )
        changesDescribable->openGroupedChange( i18n("Pattern inserted.") );
    mByteArrayView->insert( insertData );
//     mByteArrayModel->replace( filteredSection, filterResult );
    if( changesDescribable )
        changesDescribable->closeGroupedChange();
#endif

    return mimeData;
}
Пример #18
0
ex_expr::exp_return_type ExpLOBload::eval(char *op_data[],
					  CollHeap*h,
					  ComDiagsArea** diagsArea)
{
  ex_expr::exp_return_type err = ex_expr::EXPR_OK;

  char * handle =
    getExeGlobals()->lobGlobals()->lobLoadInfo()->lobHandle(lobNum());
  Lng32 handleLen =
    getExeGlobals()->lobGlobals()->lobLoadInfo()->lobHandleLen(lobNum());

  if (handle == NULL)
    return ex_expr::EXPR_ERROR;
  
  if (fromLoad())
    {
      char * clientFile = op_data[1];
      // call ExLoadApi
      Lng32 rc = LOBsql2loaderInterface
	(clientFile, strlen(clientFile),
	 (char*)"loaderPort", strlen("loaderPort"),
	 handle, handleLen,
	 lobStorageLocation(), strlen(lobStorageLocation()));
    }
  else
    {
      err = insertData(handleLen, handle, op_data, h, diagsArea);
    }

  return err;
}
Пример #19
0
void writeDriverDescriptorMap(AbstractFile* file, DriverDescriptorRecord* DDM, ChecksumFunc dataForkChecksum, void* dataForkToken,
				ResourceKey **resources) {
  AbstractFile* bufferFile;
  BLKXTable* blkx;
  ChecksumToken uncompressedToken;
  DriverDescriptorRecord* buffer;
  
  buffer = (DriverDescriptorRecord*) malloc(DDM_SIZE * SECTOR_SIZE);
  memcpy(buffer, DDM, DDM_SIZE * SECTOR_SIZE);
  memset(&uncompressedToken, 0, sizeof(uncompressedToken));
  
  flipDriverDescriptorRecord(buffer, TRUE);

  bufferFile = createAbstractFileFromMemory((void**)&buffer, DDM_SIZE * SECTOR_SIZE);
  
  blkx = insertBLKX(file, bufferFile, DDM_OFFSET, DDM_SIZE, DDM_DESCRIPTOR, CHECKSUM_CRC32, &CRCProxy, &uncompressedToken,
			dataForkChecksum, dataForkToken, NULL);
              
  blkx->checksum.data[0] = uncompressedToken.crc;
  
  *resources = insertData(*resources, "blkx", -1, "Driver Descriptor Map (DDM : 0)", (const char*) blkx, sizeof(BLKXTable) + (blkx->blocksRunCount * sizeof(BLKXRun)), ATTRIBUTE_HDIUTIL);
  
  free(buffer);
  bufferFile->close(bufferFile);
  free(blkx);
}
int insertDataPage(string fname,string data)
{
	ifstream fd;
	fd.open(fname.c_str(),ios::binary);
	if(!fd)
	{
		cerr<<"\n File does not exist.....";
		return -2;
	}

	fd.seekg(0,ios::end);
	int fileSize = fd.tellg();
	cout<<"\n File size: "<<fileSize;
	int no_Pages = fileSize/PAGESIZE;
	int result;

	for(int i=1;i<=fileSize;i++)
	{
		result = insertData(fname,i,data);
		if(result == 1)
			break;
	}

	return 1;
}
Пример #21
0
void writeATAPI(AbstractFile* file, ChecksumFunc dataForkChecksum, void* dataForkToken, ResourceKey **resources, NSizResource** nsizIn) {
  AbstractFile* bufferFile;
  BLKXTable* blkx;
  ChecksumToken uncompressedToken;
  NSizResource* nsiz;
  CSumResource csum;
  char* atapi;
  
  memset(&uncompressedToken, 0, sizeof(uncompressedToken));
  
  atapi = (char*) malloc(ATAPI_SIZE * SECTOR_SIZE);
  printf("malloc: %p %d\n", atapi, ATAPI_SIZE * SECTOR_SIZE); fflush(stdout);
  memcpy(atapi, atapi_data, ATAPI_SIZE * SECTOR_SIZE);
  bufferFile = createAbstractFileFromMemory((void**)&atapi, ATAPI_SIZE * SECTOR_SIZE);

  blkx = insertBLKX(file, bufferFile, ATAPI_OFFSET, ATAPI_SIZE, 1, CHECKSUM_CRC32,
              &BlockCRC, &uncompressedToken, dataForkChecksum, dataForkToken, NULL);

  bufferFile->close(bufferFile);
  free(atapi);

  blkx->checksum.data[0] = uncompressedToken.crc;
  
  csum.version = 1;
  csum.type = CHECKSUM_MKBLOCK;
  csum.checksum = uncompressedToken.block;

  *resources = insertData(*resources, "blkx", 1, "Macintosh (Apple_Driver_ATAPI : 2)", (const char*) blkx, sizeof(BLKXTable) + (blkx->blocksRunCount * sizeof(BLKXRun)), ATTRIBUTE_HDIUTIL);
  *resources = insertData(*resources, "cSum", 1, "", (const char*) (&csum), sizeof(csum), 0);
  
  nsiz = (NSizResource*) malloc(sizeof(NSizResource));
  memset(nsiz, 0, sizeof(NSizResource));
  nsiz->isVolume = FALSE;
  nsiz->blockChecksum2 = uncompressedToken.block;
  nsiz->partitionNumber = 1;
  nsiz->version = 6;
  nsiz->next = NULL;
  
  if((*nsizIn) == NULL) {
    *nsizIn = nsiz;
  } else {
    nsiz->next = (*nsizIn)->next;
    (*nsizIn)->next = nsiz;
  }
  
  free(blkx);
}
Пример #22
0
int
main ()
{
    queue_t* queuePtr;
    random_t* randomPtr;
    long data[] = {3, 1, 4, 1, 5};
    long numData = sizeof(data) / sizeof(data[0]);
    long i;

    randomPtr = random_alloc();
    assert(randomPtr);
    random_seed(randomPtr, 0);

    puts("Starting tests...");

    queuePtr = queue_alloc(-1);

    assert(queue_isEmpty(queuePtr));
    for (i = 0; i < numData; i++) {
        insertData(queuePtr, &data[i]);
    }
    assert(!queue_isEmpty(queuePtr));

    for (i = 0; i < numData; i++) {
        long* dataPtr = (long*)queue_pop(queuePtr);
        printf("Removing %li: ", *dataPtr);
        printQueue(queuePtr);
    }
    assert(!queue_pop(queuePtr));
    assert(queue_isEmpty(queuePtr));

    puts("All tests passed.");

    for (i = 0; i < numData; i++) {
        insertData(queuePtr, &data[i]);
    }
    for (i = 0; i < numData; i++) {
        printf("Shuffle %li: ", i);
        queue_shuffle(queuePtr, randomPtr);
        printQueue(queuePtr);
    }
    assert(!queue_isEmpty(queuePtr));

    queue_free(queuePtr);

    return 0;
}
Пример #23
0
void MemoryTablePrivate::updateValue(const value_type &value, quint32 valueSize, quint32 offset, TableMetadata *table)
{
    Allocation *allocation = allocationAt(offset, table);
    Q_ASSERT(allocation->size >= requiredSpace(valueSize));

    allocation->dataSize = valueSize;
    insertData(allocation->data, allocation->dataSize, value);
}
void CharacterDataImpl::replaceData(unsigned int offset, unsigned int count,
                                    const DOMString &dat)
{
    if (isReadOnly())
        throw DOM_DOMException(
        DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
    deleteData(offset, count);
    insertData(offset, dat);
};
Пример #25
0
void MySQLLayer::dropTable(std::string schemaName, std::string tableName)
{
	std::string sqlQuery = "DROP TABLE ";
	sqlQuery += schemaName;
	sqlQuery += ".";
	sqlQuery += tableName;
	sqlQuery += ";";
	insertData(sqlQuery);
}
Пример #26
0
int Krls::estimate(Data<double> data){
  sample_type m;
  m(0) = getTime(data);
  cout << "Krls -> " << data.type << " esperada: " << krlsTest(m) << endl;
  cout << "Krls -> " << data.type << " real: " << data.value << endl;
  int status = abs(krlsTest(m) - (double) data.value) > LIMIT? 4 : 0;
  insertData(data);
  return status;
}
Пример #27
0
void test_insert_integer_data_in_Start_of_queue() {
    Queue* queue = createQueue();
    int data = 10;
    int priority = 1;
    insertData(queue , &data , priority);
    ASSERT(queue->head->priority == 1);
    ASSERT(*(int*)queue->head->data == 10);
    ASSERT(queue->length == 1);
}
Пример #28
0
void DOMCharacterDataImpl::replaceData(const DOMNode *node, XMLSize_t offset, XMLSize_t count,
                                    const XMLCh *dat)
{
    if (castToNodeImpl(node)->isReadOnly())
        throw DOMException(
        DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMCharacterDataImplMemoryManager);

    deleteData(node, offset, count);
    insertData(node, offset, dat);
}
Пример #29
0
bool TutFile::insertData(int tutID, const QString &path)
{
	QFile f(path);
	if(f.open(QIODevice::ReadOnly)) {
		insertData(tutID, f.readAll());
		f.close();
		return true;
	}

	return false;
}
Пример #30
0
void Wykres::zdarzenie(Obserwowany *o)
{
    //QMessageBox::information(0, "info", "obserwator(WYKRES) powiadomiony");
    if(insertData(Wydatnik::getInstance()->getData()))
    {
        rysuj = true;
    }
    else
    {
        rysuj = false;
    }
}