C++ LString::substr方法代码示例

/** module initialization */
bool TopparManager::load()
{
  SysConfig *pconf = SysConfig::getInstance();
  SysConfig::Section *psec = pconf->getSection("toppar");
  bool bOK = false;
  if (psec!=NULL) {
    SysConfig::const_iterator iter = psec->begin();
    iter=psec->findName(iter, "toppar_file");
    for (; iter!=psec->end(); iter=psec->findName(++iter, "toppar_file")) {
      SysConfig::Section *pchild = *iter;
      LString val = pchild->getStringData();
      if (val.isEmpty()) continue;;

      int cpos = val.indexOf(':');
      if (cpos<0) continue;
      LString type = val.substr(0, cpos);
      LString fnam = val.substr(cpos+1);
      fnam = pconf->convPathName(fnam);

      /*if (!fnam.startsWith(MB_PATH_SEPARATOR)) {
        LString config_dir = pconf->get("config_dir");
        fnam = config_dir + MB_PATH_SEPARATOR + fnam;
      }*/
      
      if (readPrmTop(fnam, type))
        bOK = true;
    }
  }

  if (!bOK) {
    //
    // read from default directory with default type/filename
    //
    LString type("cns");
    LString fnam;

    for ( ;; ) {
      fnam = "queptl.prm";
      if (!readPrmTop(fnam, type))
        break;

      fnam = "queptl.top";
      if (!readPrmTop(fnam, type))
        break;

      fnam = "queptl.lin";
      if (!readPrmTop(fnam, type))
        break;

      return true;
    }
    LOG_DPRINTLN("Toppar> warning: no mol topology/parameter files is loaded.");
  }

  // m_pTopoDB->dump();
  return true;
}

void clConsole::DisplayMessage( const LString& Message, const LConsoleMessageType MSGType ) const
{
	if ( Env )
	{
		Env->SendSync( L_EVENT_CONSOLELOG, LEventArgs( &Message ), false );
	}

	FTimeVisible = MESSAGE_VISIBILITY_TIME;

	LVector4 Color;

	switch ( MSGType )
	{
		case CMSG_ENGINEMESSAGE:
			Color = LC_LinderdaumConsoleEM;
			break;
		case CMSG_ERRORMESSAGE:
			Color = LC_LinderdaumConsoleERR;
			break;
		case CMSG_INFOTIP:
			Color = LC_LinderdaumConsoleIT;
			break;
		default:
			FATAL_MSG( "Unknown message type" );
	}

	LString Msg = Message;

	LMutex Lock( &FMessagesHistoryMutex );

	while ( true )
	{
		size_t Separation = Msg.find( "\n" );

		if ( Separation == LString::npos )
		{
			break;
		}

		LString NewMsg = Msg.substr( 0, Separation );

		FMessagesHistory.push_back( sConsoleMessage( NewMsg, Color ) );

		if ( FMessagesHistory.size() > MAX_HISTORY_SIZE )
		{
			FMessagesHistory.pop_front();
		}

		Msg = Msg.substr( Separation + 1, Message.length() - 1 );
	}

	FMessagesHistory.push_back( sConsoleMessage( Msg, Color ) );
}

void clLocalizer::SetLocale( const LString& LocaleName )
{
	guard( "%s", LocaleName.c_str() );

	ClearLocalization();

	FLocaleName = LocaleName;

	const LString FileName( FLocalePath + "/Localizer-" + LocaleName + ".txt" );

	if ( Env->FileSystem->FileExists( FileName ) )
	{
		Env->Logger->LogP( L_NOTICE, "Reading locale from %s", FileName.c_str() );

		iIStream* Stream = Env->FileSystem->CreateFileReader( FileName );

		while ( !Stream->Eof() )
		{
			LString Line = Stream->ReadLine();

			size_t SepPos = Line.find( "~" );

			FATAL( SepPos == Line.npos, "Invalid locale translation file format: missing ~" );

			LString Text( Line.substr( 0, SepPos ) );
			LString Translation( Line.substr( SepPos + 1, Line.length() - SepPos - 1 ) );

			FTranslations[ Text ] = Translation;
		}

		delete( Stream );
	}
	else
	{
		Env->Logger->LogP( L_NOTICE, "Locale %s not found", FileName.c_str() );
	}

	this->SendAsync( L_EVENT_LOCALE_CHANGED, LEventArgs(), false );

	unguard();
}

    void getRec(int pos, int unit, LString &ret)
    {
      int beg = pos*unit;

      if (beg>=m_line.length() ||
          beg<0) {
        MB_THROW(qlib::FileFormatException, "");
        return;
      }

      ret = m_line.substr(beg, unit);
    }

LString PDBFileWriter::formatAtomName(MolAtomPtr pAtom)
{
  LString atomnam = pAtom->getName();
  char cConfID = pAtom->getConfID();
  int elem = pAtom->getElement();
  
  if (cConfID=='\0')
    cConfID = ' ';

  // invalid name case
  if (atomnam.length()>=4||
      elem==ElemSym::XX) {
    return LString::format("%4s%c", atomnam.c_str(), cConfID);
  }

  LString elenam = ElemSym::symID2Str(elem);
  elenam = elenam.toUpperCase();
  int elepos = atomnam.indexOf(elenam);
  if (elepos<0) {
    return LString::format("%4s%c", atomnam.c_str(), cConfID);
  }
  
  LString atommod;
  // if (atomnam.equals(elenam)) {
  // // atom name==elem name
  // shead += LString::format(" %2s  ", elenam.c_str());
  // break;
  // }
  
  elepos += elenam.length();
  atommod = atomnam.substr(elepos);
  elenam = atomnam.substr(0, elepos);
  
  if (atommod.length()<=2) {
    return LString::format("%2s%-2s%c",
                           elenam.c_str(), atommod.c_str(), cConfID);
  }
  
  return LString::format("%4s%c", atomnam.c_str(), cConfID);
}

//------------------------------------------------------------------------------
int LArguments::parse(int argc, char* argv[]) {
    LString opt;
    int find;
    int ret;
    for(int num = 1; num < argc; num++) {
        opt = LString(argv[num]);

        if(opt.find("--") == 0) {
            if((find = opt.find("=")) != (int)string::npos) {
                if((ret = parseInternalOptionWithParamater(opt.substr(0, find), opt.substr(find + 1))) != L_OK) {
                    return ret;
                    }
                }
            else {
                if((ret = parseInternalOption(opt)) != L_OK) {
                    return ret;
                    }
                }
            }
        else if(opt.find("-") == 0) {
            if((find = opt.find("=")) != (int)string::npos) {
                if((ret = parseInternalOptionWithParamater(opt.substr(0, find), opt.substr(find + 1))) != L_OK) {
                    return ret;
                    }
                }
            else {
                if((ret = parseInternalOption(opt)) != L_OK) {
                    return ret;
                    }
                }
            }
        else {
            if((ret = parseInternalArgument(opt)) != L_OK) {
                return ret;
                }
            }

        }
    return L_OK;
    }

  LString readStr(int start, int end) {
    if (m_recbuf.isEmpty()) return LString();

    start --; end --;
    if (end >= m_recbuf.length())
      end = m_recbuf.length()-1;
    if (start<0)
      start = 0;
    if (start>end)
      start = end;

    return m_recbuf.substr(start, end-start+1);
  }

    int getInt(int pos, int unit)
    {
      int ret;
      int beg = pos*unit;

      if (beg>=m_line.length() ||
          beg<0) {
        MB_THROW(qlib::FileFormatException, "");
        return -1;
      }

      LString s = m_line.substr(beg, unit);
      if (!s.toInt(&ret)) {
        MB_THROW(qlib::FileFormatException, "");
        return -1;
      }
      return ret;
    }

// write PDB file to stream
bool PDBFileWriter::write(qlib::OutStream &outs)
{
  m_pMol = getTarget<MolCoord>();

  if (m_pMol==NULL) {
    LOG_DPRINTLN("PDBWriter> MolCoord is not attached !!");
    return false;
  }

  // check extension record handlers
  PDBFileReader::HndlrTab &htab = PDBFileReader::m_htab;
  bool bUseHndlr = htab.size()>0;

  MolCoord *pMol = m_pMol;
  qlib::PrintStream prs(outs);

  //
  //  write header
  //
  //LString sbuf = pqsys->getVersion();
  //prs.formatln("REMARK   PDB File Generated by CueMol (ver %s)", sbuf.c_str());
  prs.formatln("REMARK   PDB File Generated by CueMol2");

  //
  //  write SSBOND record
  //
  writeSSBonds(prs);

  //
  //  write LINK record
  //
  writeLinks(prs);

  writeSecstr(prs);

  //
  //  write extension records (CRYST1)
  //
  if (bUseHndlr) {
    LString sbuf;
    PDBFileReader::HndlrTab::const_iterator iter = htab.begin();
    for (; iter!=htab.end(); ++iter) {
      PDBFileReader::RecordHandler *ph = iter->second;
      if (ph!=NULL && ph->write(sbuf, pMol)) {
        prs.println(sbuf);
      }
    }
  }
  
  //
  //  write body (ATOM/ANISOU records)
  //

  int nserial = 1;

  // Sort chain names by ASCII order
  // take care of '_' (empty) chain
  std::list<LString> chnames;
  {
    MolCoord::ChainIter iter = pMol->begin();
    bool bHasEmptyChain = false;
    for (; iter!=pMol->end(); ++iter) {
      MolChainPtr pChn = iter->second;
      LString chnam = (pChn->getName().c_str()); 
      if (chnam.equals("_")) {
        bHasEmptyChain = true;
        continue;
      }
      chnames.push_back(chnam);
    }
    chnames.sort();
    if (bHasEmptyChain)
      chnames.push_back("_");
  }
  
  std::list<LString>::const_iterator cniter = chnames.begin();
  for (; cniter!=chnames.end(); ++cniter) {
    LString chnam = *cniter;
    MolChainPtr pChn = pMol->getChain(chnam);

    // format chain name
    char cch = convChainName(chnam);

    LString resnam;
    MolChain::ResidCursor2 riter = pChn->begin2();
    // int nlastres = 0;
    for (; riter!=pChn->end2(); ++riter) {
      //MolResiduePtr pRes = *riter;
      MolResiduePtr pRes = riter->second;
      if (pRes.isnull()) continue;
      ResidIndex rindex = pRes->getIndex();
      resnam = pRes->getName();
      
      // format residue name
      // resnam = resnam.toUpperCase();
      resnam = resnam.substr(0,3);

      // sort atom by AID
      std::list<int> atmlist;
//.........这里部分代码省略.........

void PDBFileWriter::writeSecstr(qlib::PrintStream &prs)
{
  MolResiduePtr pRes1;

  int nhx = 1;
  MolCoordPtr pMol(m_pMol);
  ResidIterator riter(pMol); //(MolCoordPtr(m_pMol));

  // Write HELIX records
  for (riter.first(); riter.hasMore(); riter.next()) {
    LString sec;
    LString pfx;
    MolResiduePtr pRes = riter.get();
    pRes->getPropStr("secondary2", sec);

    // MB_DPRINTLN("%s%d => %s", pRes->getChainName().c_str(), pRes->getIndex().first, sec.c_str());

    if (sec.length()>=2)
      pfx= sec.substr(1,1);
    
    if (!(sec.startsWith("H")||sec.startsWith("G")||sec.startsWith("I")))
      continue;

    if (pfx.equals("s"))
      pRes1 = pRes;
    else if (pfx.equals("e")) {
      LString resn1 = pRes1->getName().substr(0,3);
      LString chn1 = pRes1->getChainName().substr(0,1);
      ResidIndex resix1 = pRes1->getIndex();
      char ins1 = resix1.second;
        if (ins1=='\0') ins1 = ' ';
      
      LString resn2 = pRes->getName().substr(0,3);
      LString chn2 = pRes->getChainName().substr(0,1);
      ResidIndex resix2 = pRes->getIndex();
      char ins2 = resix2.second;
      if (ins2=='\0') ins2 = ' ';
      
      prs.print("HELIX ");
      // helix seqno
      prs.format(" %3d", nhx);
        // helix ID
      prs.format(" %3d", nhx);
      
      // start resname
      prs.format(" %3s", resn1.c_str());
      prs.format(" %1s", chn1.c_str());
      prs.format(" %4d", resix1.first);
      prs.format("%c", ins1);
      
      // end resname
      prs.format(" %3s", resn2.c_str());
      prs.format(" %1s", chn2.c_str());
      prs.format(" %4d", resix2.first);
      prs.format("%c", ins2);
      
      // typeof helix
      int ntype = 1;
      if (sec.startsWith("G"))
        ntype = 5;
      else if (sec.startsWith("I"))
        ntype = 3;
      prs.format("%2d", ntype);
      
      prs.println("");
      ++nhx;
    }
  }

  // Write SHEET records
  int nsh = 1;
  for (riter.first(); riter.hasMore(); riter.next()) {
    LString sec;
    LString pfx;
    MolResiduePtr pRes = riter.get();
    pRes->getPropStr("secondary2", sec);

    // MB_DPRINTLN("%s%d => %s", pRes->getChainName().c_str(), pRes->getIndex().first, sec.c_str());

    if (sec.length()>=2)
      pfx= sec.substr(1,1);
    
    if (!(sec.startsWith("E")))
      continue;

    if (pfx.equals("s"))
      pRes1 = pRes;
    else if (pfx.equals("e")) {
      
      LString resn1 = pRes1->getName().substr(0,3);
      LString chn1 = pRes1->getChainName().substr(0,1);
      ResidIndex resix1 = pRes1->getIndex();
      char ins1 = resix1.second;
      if (ins1=='\0') ins1 = ' ';
      
      LString resn2 = pRes->getName().substr(0,3);
      LString chn2 = pRes->getChainName().substr(0,1);
      ResidIndex resix2 = pRes->getIndex();
      char ins2 = resix2.second;
      if (ins2=='\0') ins2 = ' ';
//.........这里部分代码省略.........

void clConsole::SendCommand( const LString& CMDName )
{
	guard( "%s", CMDName.c_str() );

	FSendCommandResult.assign( "" );

	if ( CMDName.size() == 0 )
	{
		return;
	}

	bool IsScript = ( LStr::GetUpper( LStr::GetToken( CMDName, 1 ) ) == "RS" );

	// split command
	size_t CommandsSeparator = FindCommandsSeparator( CMDName );

	LString ThisCMDString = CMDName;
	LString RestCMDString( "" );

	if ( !IsScript )
	{
		if ( CommandsSeparator )
		{
			ThisCMDString = CMDName.substr( 0, CommandsSeparator );
			RestCMDString = CMDName.substr( CommandsSeparator,
			                                CMDName.length() - CommandsSeparator );

			if ( RestCMDString.length() > 0 )
			{
				LStr::pop_front( &RestCMDString );
			}
		}
	}

	// extract command name and parameters
	LString ThisCMDName  = LStr::GetToken( ThisCMDString, 1 );
	LString ThisCMDParam = ThisCMDString.substr( ThisCMDName.length(),
	                                             ThisCMDString.length() - ThisCMDName.length() );

	if ( ThisCMDParam.length() > 0 )
	{
		LStr::pop_front( &ThisCMDParam );
	}

	LStr::ToUpper( &ThisCMDName );

	if ( IsScript )
	{
		// execute script and return
		ExecuteStatement( ThisCMDParam );

		return;
	}

	if ( ThisCMDName.find( "WAIT" ) == 0 )
	{
		// Leave the rest of the command until the next frame
		if ( CommandsSeparator )
		{
			QueryCommand( RestCMDString );
		}

		return;
	}
	else
	{
		clCommandsList::const_iterator i = FCommandsList.find( ThisCMDName );

		if ( i != FCommandsList.end() )
		{
			( i->second ).Exec( clFileSystem::ReplaceEnvVars( ThisCMDParam ) );
		}
		else
		{
			clAliasesList::const_iterator j = FAliasesList.find( ThisCMDName );

			if ( j != FAliasesList.end() )
			{
				QueryCommand( j->second );
			}
			else
			{
				DisplayError( "Unknown command: " + ThisCMDName );
			}
		}
	}

	if ( CommandsSeparator )
	{
		SendCommand( RestCMDString );
	}

	unguard();
}