int main(int argc, char **argv) { int blockSize = 1; int numUIDs = 1; int doThrash = 0; int arg=1; int err=0; while (arg < argc) { if (strcmp(argv[arg], "-p") == 0) { numUIDs = atoi(argv[++arg]); if (numUIDs < blockSize) blockSize = numUIDs; } else if (strcmp(argv[arg], "-n") == 0) { //SYS_UIDset_euid_namespace(argv[++arg]); } else if (strcmp(argv[arg], "-E") == 0) { //SYS_UIDset_euid_server(argv[++arg]); } else if (strcmp(argv[arg], "-thrash") == 0) { doThrash = 1; } else { fprintf(stderr, "%s: unknown option '%s'\n", argv[0], argv[arg]); err++; } arg++; } if ((err) || (numUIDs == 0)) { fprintf(stderr, "%s: [-p n] [-n ns] [-E server] [-d ms]\n", argv[0]); fprintf(stderr, " -p n print n UIDs and exit.\n"); fprintf(stderr, " -n ns use namespace ns.\n"); fprintf(stderr, " -E server contact EUID server 'server'.\n"); fprintf(stderr, " -thrash debug; get UIDs as fast as possible using blocksize 1.\n"); fprintf(stderr, " This is not what you want. Don't use it.\n"); exit(1); } UIDserver *uids = UIDserverInitialize(blockSize, 0); while (doThrash) getUID(uids); // Forever or never. while (numUIDs > 0) { fprintf(stdout, F_U64"\n", getUID(uids)); numUIDs--; } exit(0); }
int PortFE1::setLoop(const int type){ UN_Info e1info = UID::breakUID(getUID()); uint8 ch = e1info.E1.E1; switch( type ) { case dev_and_line_loop: driver.setPortLoopOut(ch, 1); driver.setPortLoopIn(ch, 1); break; case line_loop: driver.setPortLoopOut(ch, 1); driver.setPortLoopIn(ch, 0); break; case dev_loop: driver.setPortLoopOut(ch, 0); driver.setPortLoopIn(ch, 1); break; case no_loop: driver.setPortLoopOut(ch, 0); driver.setPortLoopIn(ch, 0); break; default: return -1; } return 0x5A; }
long EmergenceLog::getLastUID() { string logLine = "-1,READFAIL,READFAIL,READFAIL,READFAIL,\n"; string prevLogLine = "-1,READFAIL,READFAIL,READFAIL,READFAIL,\n"; string fileName = getLogDirPath() + _fileName; std::ifstream mFile; mFile.open(fileName.c_str()); if (mFile.is_open()) { while (mFile.good()) { // last line is garbage prevLogLine = logLine; getline(mFile, logLine); } mFile.close(); } return getUID(prevLogLine); //long len = length(); //if (len < 0) { // return -1; //} //return getUID(len); //string line = getLine(len); //string uid; //istringstream liness(line); //getline(liness, uid, ','); //return atol(uid.c_str()); }
/** * Print a conditional branch instruction. * * @param curBlock the current block * @param trueBlock the destination block if the value on top of the stack is * non-zero * @param falseBlock the destination block if the value on top of the stack is * zero */ void JVMWriter::printBranchInstruction(const BasicBlock *curBlock, const BasicBlock *trueBlock, const BasicBlock *falseBlock) { if(trueBlock == falseBlock) { printSimpleInstruction("pop"); printBranchInstruction(curBlock, trueBlock); } else if(!falseBlock) { printPHICopy(curBlock, trueBlock); printSimpleInstruction("ifne", getLabelName(trueBlock)); } else { std::string labelname = getLabelName(trueBlock); if(isa<PHINode>(trueBlock->begin())) labelname += "$phi" + utostr(getUID()); printSimpleInstruction("ifne", labelname); if(isa<PHINode>(falseBlock->begin())) printPHICopy(curBlock, falseBlock); printSimpleInstruction("goto", getLabelName(falseBlock)); if(isa<PHINode>(trueBlock->begin())) { printLabel(labelname); printPHICopy(curBlock, trueBlock); printSimpleInstruction("goto", getLabelName(trueBlock)); } } }
bool KU_User::operator ==(const KU_User &other) const { if ( getUID() == other.getUID() && getName() == other.getName() ) return true; else return false; }
void ComponentAttachParticleSystem::handleActionDeleteActor( const ActionDeleteActor *message ) { ASSERT(message, "Null parameter: message"); if (message->id == getUID()) { ASSERT(world, "world has not yet been set"); world->particleEngine->remove(handle); active=false; } }
void mob::hit(hitData &data) { RakNet::BitStream dataPacket; //The bitstream dataPacket.Write<RakNet::MessageID>(gamePackets::COMBAT_ENTITY); //Message ID dataPacket.Write<RakNet::MessageID>(gamePackets::COMBAT_ENTITY_HIT); //Message ID dataPacket.Write<int>(getUID()); //Send the combat entities unique ID dataPacket.Write<hitData>(data); this->getParentMap()->broadcastPacket(dataPacket); this->::combatEntity::hit(data); }
void CPlayer::skillDamage(AdvancedAttribute targetAttr) { CMonster *pTargetMonster = dynamic_cast<CMonster *>(getTargetObject()); if(pTargetMonster != NULL) { AdvancedAttribute monsterAdv = pTargetMonster->getAdvAttr(); pTargetMonster->addHate(getUID(), targetAttr.iHP - monsterAdv.iHP); } CUnitObject::skillDamage(targetAttr); }
/* * ֻ�аﶨ��VCG��CHVC���ж�Ӧ��RC6400�� * ����ڰ�ʱ����Ҫ�Ը�CHVC�����������ʵ�� */ bool CHVC::bandToVCG(VCG* v) { BandVCG = v; if( BandVCG ) { LinkChannel->setDownStream(BandVCG->getUID()); } else { LinkChannel->setDownStream(getUID()); } return true; }
bool PortFE1::setPortEnable(uint8 en, bool save) { UN_Info e1info = UID::breakUID(getUID()); uint8 ch = e1info.E1.E1; driver.setPortEnable(ch, en); if( save ) { ConfigData->TXEN = en; return saveConfig(); } return true; }
// used with 'hf search' int HF15Reader(const char *Cmd, bool verbose) { uint8_t uid[8] = {0,0,0,0,0,0,0,0}; if (!getUID(uid)) { if (verbose) PrintAndLogEx(WARNING, "No tag found."); return 0; } PrintAndLogEx(NORMAL, " UID : %s", sprintUID(NULL, uid)); PrintAndLogEx(NORMAL, " TYPE : %s", getTagInfo_15(uid)); return 1; }
void ege::Element::setFireOn(int32_t _groupIdSource, int32_t _type, float _power, const vec3& _center) { float previousLife = m_life; m_life += _power; m_life = std::avg(0.0f, m_life, m_lifeMax); if (m_life <= 0) { EGE_DEBUG("[" << getUID() << "] element is killed ..." << getType()); } if (m_life != previousLife) { onLifeChange(); } }
/** * Print a select instruction. * * @param cond the condition * @param trueVal the return value of the instruction if the condition is * non-zero * @param falseVal the return value of the instruction if the condition is * zero */ void JVMWriter::printSelectInstruction(const Value *cond, const Value *trueVal, const Value *falseVal) { std::string labelname = "select" + utostr(getUID()); printValueLoad(cond); printSimpleInstruction("ifeq", labelname + "a"); printValueLoad(trueVal); printSimpleInstruction("goto", labelname + "b"); printLabel(labelname + "a"); printValueLoad(falseVal); printLabel(labelname + "b"); }
Tile* Board::getTile(int row, int col) { Tile* found_tile; if (row < 1 || row > vert_tiles || col < 1 || col > hori_tiles) { found_tile = &NULL_tile; } else { int index = getUID(row, col)-1; found_tile = &board_tiles[index]; } return found_tile; }
uint32 CHVC::getProtectPartner(void) { UN_Info info = UID::breakUID(getUID()); if( info.chvc.group == 0 ) { info.chvc.group = 1; } else { info.chvc.group = 0; } ST_Chvc_channel partner; partner.slot = info.chvc.slot; partner.group = info.chvc.group; partner.channel = info.chvc.channel; return UID::makeUID(&partner); }
status_t ChromiumHTTPDataSource::connect( const char *uri, const KeyedVector<String8, String8> *headers, off64_t offset) { Mutex::Autolock autoLock(mLock); uid_t uid; if (getUID(&uid)) { mDelegate->setUID(uid); } LOG_PRI(ANDROID_LOG_VERBOSE, LOG_TAG, "connect on behalf of uid %d", uid); return connect_l(uri, headers, offset); }
void fillInPluginDescription (PluginDescription& desc) const { desc.name = getName(); desc.fileOrIdentifier = module->file.getFullPathName(); desc.uid = getUID(); desc.lastFileModTime = module->file.getLastModificationTime(); desc.pluginFormatName = "LADSPA"; desc.category = getCategory(); desc.manufacturerName = plugin != nullptr ? String (plugin->Maker) : String::empty; desc.version = getVersion(); desc.numInputChannels = getNumInputChannels(); desc.numOutputChannels = getNumOutputChannels(); desc.isInstrument = false; }
int main(int argc, char** argv) { int id; char username[128]; const char* baseUrl = "http://172.27.0.1:8000/pam"; printf("Authenticate: %d\n", httpAuthenticate("pepito", "juanito", baseUrl)); int res = getUID(baseUrl,"pepito", username, &id); printf("GetUID:res: %d, username: %s, id: %d\n", res, username, id); *username = '******'; res = getName(baseUrl, 10000, username, &id); printf("GetName:res: %d, username: %s, id: %d\n", res, username, id); }
bool buildUTGMessage(int32 ID, SnapUnitigMesg *utg) { MultiAlignT *ma = ScaffoldGraph->tigStore->loadMultiAlign(ID, TRUE); if (ma == NULL) return(false); utg->eaccession = AS_UID_fromInteger(getUID(uidServer)); utg->iaccession = ID; utg->coverage_stat = ScaffoldGraph->tigStore->getUnitigCoverageStat(ID); utg->microhet_prob = ScaffoldGraph->tigStore->getUnitigMicroHetProb(ID); utg->status = ScaffoldGraph->tigStore->getUnitigStatus(ID); utg->status = (utg->status == AS_UNASSIGNED ? AS_UNIQUE : utg->status); utg->length = GetMultiAlignLength(ma); utg->consensus = Getchar(ma->consensus, 0); utg->quality = Getchar(ma->quality, 0); utg->forced = 0; utg->num_frags = GetNumIntMultiPoss(ma->f_list); utg->num_vars = 0; utg->f_list = (SnapMultiPos*)safe_malloc(utg->num_frags * sizeof(SnapMultiPos)); utg->v_list = NULL; if (utg->consensus == NULL) fprintf(stderr, "buildUTGMessage()-- unitig %d missing consensus sequence\n", utg->iaccession); assert(utg->consensus != NULL); if (utg->length != strlen(utg->consensus)) fprintf(stderr, "buildUTGMessage()-- unitig %d length %d != consensus string length "F_SIZE_T"\n", utg->iaccession, utg->length, strlen(utg->consensus)); assert(utg->length == strlen(utg->consensus)); for (int32 i=0; i<utg->num_frags; i++) { IntMultiPos *imp = GetIntMultiPos(ma->f_list, i); utg->f_list[i].type = imp->type; utg->f_list[i].eident = FRGmap.lookup(imp->ident); utg->f_list[i].position = imp->position; utg->f_list[i].delta_length = imp->delta_length; utg->f_list[i].delta = imp->delta; } return(true); }
void VesselSceneNode::loadState(const VesselSceneNodeState& state) { Log::writeToLog(Log::L_DEBUG, "Loading VesselSceneNode state, UID: ", uid); if (state.uid != uid) throw UID_Mismatch(); setPosition(state.pos); setRotation(state.rot); orbitername = state.orbiterName; for (UINT i = 0; i < state.dockingStatus.size(); ++i) { dockingPorts[i].docked = state.dockingStatus[i].docked; if (state.dockingStatus[i].docked) { Log::writeToLog(Log::L_DEBUG, "Half-docking ourPort (VUID: ", getUID(), " PID: ", i, ") to theirPort (VUID: ", state.dockingStatus[i].dockedTo.vesselUID, " PID: ", state.dockingStatus[i].dockedTo.portID, ")"); dockingPorts[i].dockedTo = state.dockingStatus[i].dockedTo; } } }
bool Process::operator==(const Process &other) const { if(this==&other) return true; if( getPath()!=other.getPath() ) return false; if( getName()!=other.getName() ) return false; if( !Base::ViaPointer::equal( getMD5(), other.getMD5() ) ) return false; if( !Base::ViaPointer::equal( getPID(), other.getPID() ) ) return false; if( !Base::ViaPointer::equal( getUID(), other.getUID() ) ) return false; if( getUsername()!=other.getUsername() ) return false; if( !Base::ViaPointer::equal( getParameters(), other.getParameters() ) ) return false; if( !Base::ViaPointer::equal( getReferenceURL().get(), other.getReferenceURL().get() ) ) return false; // if all fields are identical, Processes are identical too. return true; }
void rice::p2p::past::gc::GCPastImpl::refresh(GCIdSet* ids, ::rice::Continuation* command) { auto const logger = npc(npc(environment)->getLogManager())->getLogger(GCPastImpl::class_(), instance); if(npc(logger)->level <= ::rice::environment::logging::Logger::FINE) npc(logger)->log(::java::lang::StringBuilder().append(u"REFRESH: CALLED WITH "_j)->append(npc(ids)->numElements()) ->append(u" ELEMENTS"_j)->toString()); if(npc(ids)->numElements() == 0) { npc(command)->receiveResult(new ::java::lang::ObjectArray(int32_t(0))); return; } auto const array = npc(ids)->asArray_(); auto start = java_cast< GCId* >((*array)[int32_t(0)]); if(npc(logger)->level <= ::rice::environment::logging::Logger::FINE) npc(logger)->log(::java::lang::StringBuilder().append(u"REFRESH: GETTINGS ALL HANDLES OF "_j)->append(static_cast< ::java::lang::Object* >(start))->toString()); sendRequest(npc(start)->getId(), static_cast< ::rice::p2p::past::messaging::PastMessage* >(new ::rice::p2p::past::gc::messaging::GCLookupHandlesMessage(getUID(), npc(start)->getId(), getLocalNodeHandle(), npc(start)->getId())), static_cast< ::rice::Continuation* >(new GCPastImpl_refresh_3(this, logger, array, ids, ::java::lang::StringBuilder().append(u"GCLookupHandles for "_j)->append(static_cast< ::java::lang::Object* >(npc(start)->getId()))->toString(), command))); }
/** * parses common HF 15 CMD parameters and prepares some data structures * Parameters: * **cmd command line */ int prepareHF15Cmd(char **cmd, UsbCommand *c, uint8_t iso15cmd) { int temp; uint8_t *req = c->d.asBytes; uint8_t uid[8] = {0x00}; uint32_t reqlen = 0; // strip while (**cmd==' ' || **cmd=='\t') (*cmd)++; if (strstr(*cmd, "-2") == *cmd) { c->arg[1] = 0; // use 1of256 (*cmd) += 2; } // strip while (**cmd==' ' || **cmd=='\t') (*cmd)++; if (strstr(*cmd, "-o") == *cmd) { req[reqlen] = ISO15_REQ_OPTION; (*cmd) += 2; } // strip while (**cmd == ' ' || **cmd == '\t') (*cmd)++; switch (**cmd) { case 0: PrintAndLogEx(WARNING, "missing addr"); return 0; break; case 'u': case 'U': // unaddressed mode may not be supported by all vendors req[reqlen++] |= ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH | ISO15_REQ_NONINVENTORY; req[reqlen++] = iso15cmd; break; case '*': // we scan for the UID ourself req[reqlen++] |= ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH | ISO15_REQ_NONINVENTORY | ISO15_REQ_ADDRESS; req[reqlen++] = iso15cmd; if (!getUID(uid)) { PrintAndLogEx(WARNING, "No tag found"); return 0; } memcpy(&req[reqlen], uid, sizeof(uid)); PrintAndLogEx(NORMAL, "Detected UID %s", sprintUID(NULL, uid)); reqlen += sizeof(uid); break; default: req[reqlen++] |= ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH | ISO15_REQ_NONINVENTORY | ISO15_REQ_ADDRESS; req[reqlen++] = iso15cmd; // parse UID for (int i=0; i<8 && (*cmd)[i*2] && (*cmd)[i*2+1]; i++) { sscanf((char[]){(*cmd)[i*2], (*cmd)[i*2+1],0}, "%X", &temp); uid[7-i] = temp & 0xff; } PrintAndLogEx(NORMAL, "Using UID %s", sprintUID(NULL, uid)); memcpy(&req[reqlen], uid, sizeof(uid)); reqlen += sizeof(uid); break; }
int CmdHF15Restore(const char*Cmd) { FILE *file; uint8_t uid[8]={0x00}; char filename[FILE_PATH_SIZE] = {0x00}; char buff[255] = {0x00}; size_t blocksize=4; uint8_t cmdp = 0; char newCmdPrefix[255] = {0x00}, tmpCmd[255] = {0x00}; char param[FILE_PATH_SIZE]=""; char hex[255]=""; uint8_t retries = 3, tried = 0; int retval=0; size_t bytes_read; uint8_t i=0; while(param_getchar(Cmd, cmdp) != 0x00) { switch(tolower(param_getchar(Cmd, cmdp))) { case '-': param_getstr(Cmd, cmdp, param, sizeof(param)); switch(param[1]) { case '2': case 'o': strncpy(newCmdPrefix, " ",sizeof(newCmdPrefix)-1); strncat(newCmdPrefix, param, sizeof(newCmdPrefix)-1); break; default: PrintAndLogEx(WARNING, "Unknown parameter '%s'", param); return usage_15_restore(); } break; case 'f': param_getstr(Cmd, cmdp+1, filename, FILE_PATH_SIZE); cmdp++; break; case 'r': retries=param_get8ex(Cmd, cmdp+1, 3, 10); cmdp++; break; case 'b': blocksize=param_get8ex(Cmd, cmdp+1, 4, 10); cmdp++; break; case 'u': param_getstr(Cmd, cmdp+1, buff, FILE_PATH_SIZE); cmdp++; snprintf(filename,sizeof(filename),"hf-15-dump-%s-bin",buff); break; case 'h': return usage_15_restore(); default: PrintAndLogEx(WARNING, "Unknown parameter '%c'", param_getchar(Cmd, cmdp)); return usage_15_restore(); break; } cmdp++; } PrintAndLogEx(INFO,"Blocksize: %u",blocksize); if(filename[0]=='\0') { PrintAndLogEx(WARNING,"Please provide a filename"); return 1; } if ((file = fopen(filename,"rb")) == NULL) { PrintAndLogEx(WARNING, "Could not find file %s", filename); return 2; } if (!getUID(uid)) { PrintAndLogEx(WARNING, "No tag found"); return 3; } while (1) { tried=0; hex[0]=0x00; tmpCmd[0]=0x00; bytes_read = fread( buff, 1, blocksize, file ); if ( bytes_read == 0) { PrintAndLogEx(SUCCESS, "File reading done (%s).", filename); fclose(file); return 0; } else if ( bytes_read != blocksize) { PrintAndLogEx(WARNING, "File reading error (%s), %u bytes read instead of %u bytes.", filename, bytes_read, blocksize); fclose(file); return 2; } for(int j=0;j<blocksize;j++) snprintf(hex+j*2,3,"%02X", (unsigned char)buff[j]); for(int j=0;j<sizeof(uid)/sizeof(uid[0]);j++) snprintf(buff+j*2,3,"%02X", uid[j]); //TODO: Addressed mode currently not work //snprintf(tmpCmd, sizeof(tmpCmd), "%s %s %d %s", newCmdPrefix, buff, i, hex); snprintf(tmpCmd, sizeof(tmpCmd), "%s u %d %s", newCmdPrefix, i, hex); PrintAndLogEx(DEBUG, "Command to be sent: %s", tmpCmd); for(tried=0;tried<retries;tried++) if(!(retval=CmdHF15Write(tmpCmd))) break; if(tried >= retries) return retval; i++; } fclose(file); }
// Reads all memory pages // need to write to file int CmdHF15Dump(const char*Cmd) { uint8_t fileNameLen = 0; char filename[FILE_PATH_SIZE] = {0}; char * fptr = filename; bool errors = false; uint8_t cmdp = 0; uint8_t uid[8] = {0,0,0,0,0,0,0,0}; while(param_getchar(Cmd, cmdp) != 0x00 && !errors) { switch(param_getchar(Cmd, cmdp)) { case 'h': case 'H': return usage_15_dump(); case 'f': case 'F': fileNameLen = param_getstr(Cmd, cmdp+1, filename, FILE_PATH_SIZE); cmdp += 2; break; default: PrintAndLogEx(WARNING, "Unknown parameter '%c'\n", param_getchar(Cmd, cmdp)); errors = true; break; } } //Validations if (errors) return usage_15_dump(); if (fileNameLen < 1) { PrintAndLogEx(INFO, "Using UID as filename"); if (!getUID(uid)) { PrintAndLogEx(WARNING, "No tag found."); return 1; } fptr += sprintf(fptr, "hf-15-"); FillFileNameByUID(fptr,uid,"-dump",sizeof(uid)); } // detect blocksize from card :) PrintAndLogEx(NORMAL, "Reading memory from tag UID %s", sprintUID(NULL, uid)); int blocknum = 0; uint8_t *recv = NULL; // memory. t15memory mem[256]; uint8_t data[256*4] = {0}; memset(data, 0, sizeof(data)); UsbCommand resp; UsbCommand c = {CMD_ISO_15693_COMMAND, {0, 1, 1}}; // len,speed,recv? uint8_t *req = c.d.asBytes; req[0] = ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH | ISO15_REQ_NONINVENTORY | ISO15_REQ_ADDRESS; req[1] = ISO15_CMD_READ; // copy uid to read command memcpy(req+2, uid, sizeof(uid)); for (int retry = 0; retry < 5; retry++) { req[10] = blocknum; AddCrc(req, 11); c.arg[0] = 13; clearCommandBuffer(); SendCommand(&c); if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) { uint8_t len = resp.arg[0]; if ( len < 2 ) { PrintAndLogEx(FAILED, "iso15693 card select failed"); continue; } recv = resp.d.asBytes; if ( !CheckCrc(recv, len) ) { PrintAndLogEx(FAILED, "crc fail"); continue; } if (recv[0] & ISO15_RES_ERROR) { PrintAndLogEx(FAILED, "Tag returned Error %i: %s", recv[1], TagErrorStr(recv[1]) ); break; } mem[blocknum].lock = resp.d.asBytes[0]; memcpy(mem[blocknum].block, resp.d.asBytes + 1, 4); memcpy(data + (blocknum * 4), resp.d.asBytes + 1, 4); retry = 0; blocknum++; printf("."); fflush(stdout); } } PrintAndLogEx(NORMAL, "\n"); PrintAndLogEx(NORMAL, "block# | data |lck| ascii"); PrintAndLogEx(NORMAL, "---------+--------------+---+----------"); for (int i = 0; i < blocknum; i++) { PrintAndLogEx(NORMAL, "%3d/0x%02X | %s | %d | %s", i, i, sprint_hex(mem[i].block, 4 ), mem[i].lock, sprint_ascii(mem[i].block, 4) ); } PrintAndLogEx(NORMAL, "\n"); size_t datalen = blocknum * 4; saveFileEML(filename, "eml", data, datalen, 4); saveFile(filename, "bin", data, datalen); return 0; }
// -------------------------------------------------------------------------- // // Function // Name: BBInstance ProcessControl::generateBBInstanceFromPID(int) // Purpose: Obtiene todos los parametros y genera una instancia a partir de un PID // Created: 25/6/08 // // ------------------ BBInstance ProcessControl::generateBBInstanceFromPID(int pid) { QString configpath = getConfigPath(pid); unsigned int uid = getUID(pid); return BBInstance(configpath, userNamefromUID(uid),getBinaryPath(pid)); }
bool ProcessControl::checkProcessUser(int pid, int uid) { int processuid=getUID(pid); return processuid == uid; }
int main( int argc, char **argv) { int ckptNum = NULLINDEX; int makeMiniScaffolds = 1; uint64 uidStart = 1230000; UIDserver *uids = NULL; GlobalData = new Globals_CGW(); argc = AS_configure(argc, argv); int err=0; int arg=1; while (arg < argc) { if (strcmp(argv[arg], "-p") == 0) { ckptNum = GlobalData->setPrefix(argv[++arg]); } else if (strcmp(argv[arg], "-c") == 0) { strcpy(GlobalData->outputPrefix, argv[++arg]); } else if (strcmp(argv[arg], "-g") == 0) { strcpy(GlobalData->gkpStoreName, argv[++arg]); } else if (strcmp(argv[arg], "-t") == 0) { strcpy(GlobalData->tigStoreName, argv[++arg]); } else if (strcmp(argv[arg], "-n") == 0) { ckptNum = atoi(argv[++arg]); } else if (strcmp(argv[arg], "-U") == 0) { uidStart = 0; } else if (strcmp(argv[arg], "-S") == 0) { makeMiniScaffolds = 0; } else { fprintf(stderr, "unknown option '%s'\n", argv[arg]); err = 1; } arg++; } if ((GlobalData->outputPrefix[0] == 0) || (GlobalData->gkpStoreName[0] == 0)) { fprintf(stderr, "usage: %s [[-p prefix] | [-c name -g gkpstore -n ckptNum]] [-U] [-S]\n", argv[0]); fprintf(stderr, " -p Attempt to locate the last checkpoint in directory 7-CGW.\n"); fprintf(stderr, " -c Look for checkpoints in 'name'\n"); fprintf(stderr, " -g Path to gkpStore\n"); fprintf(stderr, " -n Checkpoint number to load\n"); fprintf(stderr, " -U Use real UIDs for miniscaffolds, otherwise, UIDs start at 1230000\n"); fprintf(stderr, " -S Do NOT make mini scaffolds.\n"); exit(1); } uids = UIDserverInitialize(256, uidStart); char *toprint = (char *)safe_malloc(sizeof(char) * (AS_READ_MAX_NORMAL_LEN + 51 + AS_READ_MAX_NORMAL_LEN + 2)); LoadScaffoldGraphFromCheckpoint(GlobalData->outputPrefix, ckptNum, FALSE); int ifrag; for (ifrag=0; ifrag < GetNumVA_CIFragT(ScaffoldGraph->CIFrags); ifrag++) { CIFragT *frag = GetCIFragT(ScaffoldGraph->CIFrags, ifrag); CIFragT *mate = NULL; if (frag->flags.bits.isDeleted) continue; assert(frag->cid != NULLINDEX); assert((frag->flags.bits.hasMate == 0) || (frag->mate_iid != 0)); // Fix for missing mates -- OBT used to not delete mate links, leaving // dangling mates. Somebody else seems to be doing this too. // if (frag->flags.bits.hasMate) { mate = GetCIFragT(ScaffoldGraph->CIFrags, frag->mate_iid); if (mate == NULL) frag->flags.bits.hasMate = 0; } // If this fragment is not chaff, we have nothing to do here. // if (GetGraphNode(ScaffoldGraph->CIGraph,frag->cid)->flags.bits.isChaff == 0) continue; // Print a singleton if there is no mate, the mate isn't chaff, // or we were told to not make miniscaffolds. // if ((mate == NULL) || (mate->flags.bits.isChaff == 0) || (makeMiniScaffolds == 0)) { AS_UID fUID = getFragmentClear(frag->read_iid, 0, toprint); AS_UTL_writeFastA(stdout, toprint, strlen(toprint), 0, ">%s /type=singleton\n", AS_UID_toString(fUID)); } else if ((mate != NULL) && (mate->flags.bits.isChaff == 1) && (makeMiniScaffolds == 1) && (frag->read_iid < mate->read_iid)) { // make sure the following chain of Ns is divisible by three; // the exact length is arbitrary but Doug Rusch points out that // by making it divisible by 3, we can get lucky and maintain // the phase of a protein ... which helps in the // auto-annotation of environmental samples AS_UID fUID = getFragmentClear(frag->read_iid, 0, toprint); strcat(toprint, "NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN"); AS_UID mUID = getFragmentClear(mate->read_iid, 1, toprint + strlen(toprint)); AS_UTL_writeFastA(stdout, toprint, strlen(toprint), 0, ">"F_U64" /type=mini_scaffold /frgs=(%s,%s)\n", getUID(uids), AS_UID_toString(fUID), AS_UID_toString(mUID)); } } delete GlobalData; exit(0); }
uint32 CTSChannel::getHID() { uint32 uid = getUID(); return driver->getHID(uid); }
CTSChannel::~CTSChannel() { group.erase(getUID()); }