C++ (Cpp) blkInit Examples

Example #1

File: pslBuild.c Project: bowhan/kent

struct psl *pslBuildFromHsp(char *qName, int qSize, int qStart, int qEnd, char qStrand, char *qAln,
                            char *tName, int tSize, int tStart, int tEnd, char tStrand, char *tAln,
                            unsigned flags)
/* construct a new psl from an HSP.  Chaining is left to other programs. */
{
if ((flags & tblastx) && (flags & bldPslx))
    errAbort("can't convert TBLASTX to PSLX");

struct block blk;
blkInit(&blk, qStart, qAln, tStart, tAln, flags);

// construct psl
int pslSpace = 8;
char strand[3];
safef(strand, sizeof(strand), "%c%c", qStrand, tStrand);
struct psl *psl = pslNew(qName, blk.qCoordMult * qSize, blk.qCoordMult * qStart, blk.qCoordMult * qEnd,
                         tName, blk.tCoordMult * tSize, blk.tCoordMult * tStart, blk.tCoordMult * tEnd,
                         strand, pslSpace, ((flags & bldPslx) ? PSL_XA_FORMAT : 0));

// fill in psl
hspToBlocks(psl, &pslSpace, &blk, flags);
finishPsl(psl, flags);
return psl;
}

Example #2

File: block.c Project: arcookie/mob

/*
** Free all memory held by a Block object
*/
void blkFree(Block *p)
{
	sqlite3_free(p->z);
	blkInit(p);
}

Example #3

File: Receiver.cpp Project: arcookie/mob

void CSender::OnRecvData(const InterfaceDescription::Member* /*pMember*/, const char* /*srcPath*/, Message& msg)
{
	uint8_t * data;
	size_t size;
	mTrain::iterator iter;
	const char * pJoiner = msg->GetSender();
	mTrain & train = m_mTrain[pJoiner];
	SessionId sessionId = m_pMob->GetSessionID();

	msg->GetArg(0)->Get("ay", &size, &data);

	if (IS_TRAIN_HEADER(data) && size == sizeof(TRAIN_HEADER)) {
		TRAIN_HEADER * pTH = (TRAIN_HEADER *)data;

		if (pTH->action == ACT_END) OnDataEnd(pTH->footprint, pJoiner);
		else if (pTH->action == ACT_NO_MISSING) m_pMob->SetSignal(pJoiner, false);
		else {
			train[pTH->chain].action = pTH->action;
			train[pTH->chain].footprint = pTH->footprint;
			blkInit(&(train[pTH->chain].body));
			memcpy(train[pTH->chain].extra, pTH->extra, TRAIN_EXTRA_LEN);

			if (pTH->action == ACT_FILE) {
				FILE_SEND_ITEM * pFSI = (FILE_SEND_ITEM *)pTH->extra;

				if (pFSI) {
					qcc::String uri = pFSI->uri;

					train[pTH->chain].path = mem2file(0, 0, uri.substr(uri.find_last_of('.')).data());
				}
			}
		}
	}
	else if ((iter = train.find(((int*)data)[0])) != train.end()){
		if (size == sizeof(int)) {
			switch (iter->second.action) {
			case ACT_SIGNAL:
				MissingCheck(iter->second.body.z);
				blkFree(&(iter->second.body));
				break;
			case ACT_MISSING:
			{
				sqlite3_stmt *pStmt = NULL;
				sqlite3_stmt *pStmt2 = NULL;
				SYNC_DATA sd;

				strcpy_s(sd.joiner, sizeof(sd.joiner), m_pMob->GetJoinName());

				QUERY_SQL_V(m_pMob->GetUndoDB(), pStmt2, ("SELECT num, snum, base_table, redo FROM works WHERE joiner=%Q AND snum IN (%s)", sd.joiner, iter->second.body.z),
					sd.snum = sqlite3_column_int(pStmt2, 1);
					strcpy_s(sd.base_table, sizeof(sd.base_table), (const char *)sqlite3_column_text(pStmt2, 2));
					sd.snum_prev = -1;
					QUERY_SQL_V(m_pMob->GetUndoDB(), pStmt, ("SELECT joiner, snum FROM works WHERE num < %d AND base_table=%Q ORDER BY num DESC LIMIT 1", sqlite3_column_int(pStmt2, 0), sd.base_table),
						strcpy_s(sd.joiner_prev, sizeof(sd.joiner_prev), (const char *)sqlite3_column_text(pStmt, 0));
						sd.snum_prev = sqlite3_column_int(pStmt, 1);
						break;
					);
					alljoyn_send(sessionId, msg->GetSender(), ACT_DATA, (char *)sqlite3_column_text(pStmt2, 3), sqlite3_column_bytes(pStmt2, 3) + 1, (const char *)&sd, sizeof(SYNC_DATA));
				);
				blkFree(&(iter->second.body));
				break;
			}
			case ACT_DATA:
			{
				TRAIN & cargo = m_mStation[pJoiner][iter->second.footprint];
				cargo.action = iter->second.action;
				blkMove(&(cargo.body), &(iter->second.body));
				memcpy(cargo.extra, iter->second.extra, TRAIN_EXTRA_LEN);
				break;
			}
			case ACT_FLIST:
				if (sizeof(FILE_SEND_ITEM) % iter->second.body.nUsed == 0) {
					int n = 0;
					Block data;
					vRecvFiles::iterator _iter;
					FILE_SEND_ITEM * pFSI = (FILE_SEND_ITEM *)iter->second.body.z;

					blkInit(&data);

					while (n < iter->second.body.nUsed) {
						if ((_iter = std::find_if(gRecvFiles.begin(), gRecvFiles.end(), find_uri(sessionId, msg->GetSender(), pFSI->uri))) == gRecvFiles.end() ||
							(*_iter)->mtime != pFSI->mtime || (*_iter)->mtime != pFSI->mtime)
							mem2mem(&data, (char *)pFSI, sizeof(FILE_SEND_ITEM));

						n += sizeof(FILE_SEND_ITEM);
						pFSI++;
					}
					if (data.nUsed > 0) SendData(pJoiner, iter->second.footprint, ACT_FLIST_REQ, sessionId, data.z, data.nUsed); // special target most be assigned.
					else OnDataEnd(iter->second.footprint, pJoiner);

					blkFree(&data);
					blkFree(&(iter->second.body));
				}
				break;
			case ACT_FLIST_REQ:
				if (sizeof(FILE_SEND_ITEM) % iter->second.body.nUsed == 0) {
					int n = 0;
					FILE_SEND_ITEM * pFSI = (FILE_SEND_ITEM *)iter->second.body.z;

					while (n < iter->second.body.nUsed) {
						SendFile(pJoiner, iter->second.footprint, ACT_FILE, sessionId, pFSI);
						n += sizeof(FILE_SEND_ITEM);
						pFSI++;
					}
					SendData(pJoiner, iter->second.footprint, ACT_END, sessionId, 0, 0);// special target most be assigned.
				}
				blkFree(&(iter->second.body));
				break;
			case ACT_FILE:
				SaveFileInfo(sessionId, pJoiner, iter->second.path.data(), (FILE_SEND_ITEM *)iter->second.extra);
				break;
			default:
				blkFree(&(iter->second.body));
				break;
			}
			train.erase(iter);
		}