C++ TStringList::Add方法代码示例

//---------------------------------------------------------------------------
void TRsyncConfigAdapter::SaveConfig(){



    TStringList* lines = new TStringList();



    TModuleHolder* currentModule = GetModuleHolder(GLOBAL_MODULE);


    for(int i = 0; i < currentModule->nvp->Count; i++){
        lines->Add(currentModule->nvp->Strings[i]);
    }

    //Now get remaining modules
    for(int j = 0; j < modules->Count; j++){
        currentModule = (TModuleHolder*)modules->Items[j];
        if(currentModule->moduleName == GLOBAL_MODULE){
            continue;
        }

        lines->Add("[" + currentModule->moduleName + "]");
        for(int i = 0; i < currentModule->nvp->Count; i++){
            lines->Add(currentModule->nvp->Strings[i]);
        }
    }

    lines->SaveToFile(CONFIG_FILE);


    delete lines;
}

//---------------------------------------------------------------------------
TStringList* StringToTok2( AnsiString Words,
  AnsiString Dlmtr1, AnsiString Dlmtr2 )
{
  AnsiString Work = Words.Trim();
  int spos;
  TStringList *Making = new TStringList;

  int spos1 = Work.AnsiPos(Dlmtr1);
  int spos2 = Work.AnsiPos(Dlmtr2);
  while (spos1 || spos2) {
 //   int spos = 0;
    if (!spos1 && spos2) spos = spos2;
    else if (!spos2 && spos1) spos = spos1;
    else spos = (spos1 < spos2) ? spos1 : spos2;
    Making->Add(Work.SubString( 1, spos-1));
    Work = Work.SubString( spos+1, Work.Length() - spos);
    Work = Work.Trim();
    spos1 = Work.AnsiPos(Dlmtr1);
    spos2 = Work.AnsiPos(Dlmtr2);
  } // while
  if (Work != "")
    Making->Add(Work);

  return Making;
}

TStringList GetFileList(wxString folder, const wxString& mask, bool includeFullFolderPath)
{
	TStringList result;
	wxString FName;
	if (wxDir::Exists(folder) == false)
	{
		return result;
	}
	wxDir dir(folder);
	if (dir.GetFirst(&FName,mask,wxDIR_FILES))
	{
		do
		{
			if (includeFullFolderPath)
			{
				wxString FullFileName = IncludeTrailingPathDelimiter(folder) + FName;
				result.Add(FullFileName);
			}
			else
			{
				result.Add(FName);
			}
		} while(dir.GetNext(&FName));
	}
	return result;
}

//---------------------------------------------------------------------------
/// Metoda odpowiada za wyci¹gniêcie oraz sparsowanie poszczególnych danych produktu
/// po czym przypisuje te dane do przekazanego obiektu.
void __fastcall ParsujDane::ZaladujDaneProduktu()
{

	AnsiString znacznikDaneProduktu, znacznikMarka, nazwaMarki, znacznikModel, nazwaModel, znacznikKod, kodProduktu,
				znacznikRodzUrz, rodzajUrzadzenia, znacznikKategoria, kategoria, dodUwagi, str;
	int index;
	TStringList *listaKat = new TStringList;
	try
	{
		listaKat->Add("Komputery");
		listaKat->Add("Fotografia");
		listaKat->Add("Telefony_i_akcesoria");
		listaKat->Sort();
		//----
		znacznikDaneProduktu = "keys : [";
		DaneProduktuText = ZnajdzDane(Text, znacznikDaneProduktu, ']');
		UsunZnacznik(DaneProduktuText, "'");
		//----                                                                    `
		znacznikKategoria = "Cat1:  \'";
		kategoria = ZnajdzDane(Text, znacznikKategoria, '\'');
        bool x = listaKat->Find(kategoria, index);

		if (!listaKat->Find(kategoria, index))
		{
			BladKategorii = true;
			ShowMessage("Proces parsowania tekstu nie powiód³ siê - brak parsera dla wybranej kategorii!");
			return;
		}
		//----
		znacznikMarka = "\"Producent: ";
		nazwaMarki = ZnajdzDane(DaneProduktuText, znacznikMarka, '\"');
		//----
		znacznikModel = "\"" + nazwaMarki;
		znacznikModel = znacznikModel.LowerCase();
		DaneProduktuText = DaneProduktuText.LowerCase();
		nazwaModel = ZnajdzDane(DaneProduktuText, znacznikModel, '\"');
		//----
		while (true)
		{
			DaneProduktuText.Delete(DaneProduktuText.Pos(","), 1);
			if (DaneProduktuText.IsEmpty()) break;
			str = ZnajdzDane(DaneProduktuText, '\"', '\"');
			if (str.Pos(":") == 0) continue;
			dodUwagi += str + ";";
		}
		//----
		znacznikKod = "productID: \'";
		kodProduktu = ZnajdzDane(Text, znacznikKod, '\'');
		//----
		znacznikRodzUrz = "catmin: \'";
		rodzajUrzadzenia = ZnajdzDane(Text, znacznikRodzUrz, '\'');
		// ----
		FProdukt->DodajDaneProduktu(nazwaMarki, nazwaModel, kodProduktu.ToInt(), rodzajUrzadzenia, dodUwagi);
	}
	catch(...) { if (listaKat != NULL) delete listaKat; listaKat = NULL; throw; }
	if (listaKat != NULL) delete listaKat;
	listaKat = NULL;
}

//---------------------------------------------------------------------------
void __fastcall TMainForm::ConsumeProducts()
{
	TStringList * products = new TStringList();
	if (FInAppPurchase->IsProductPurchased(EuropeID)) {
		products->Add(EuropeID);
	}
	if (FInAppPurchase->IsProductPurchased(NoAdsID)) {
		products->Add(NoAdsID);
	}
	FInAppPurchase->ConsumeProducts(products);
	products->DisposeOf();
}

void TIniFile::ReadSectionNames(const wxString &Section, TStringList &Strings)
{
	wxString N;
	wxString V;
	int I;

	// Assert( !! Strings , SStringsUnassignedError );
	Strings.BeginUpdate();
	try
	{
		Strings.Clear();
		if (FFileBuffer->Count() > 0)
		{
			I = GetSectionIndex(Section);
			if (I != -1)
			{
				++I;
				while ((I < FFileBuffer->Count()) && !IsSection
				  (FFileBuffer->Item(I)))
				{
					N = GetName(FFileBuffer->Item(I));
					if (N != EmptyStr)
					{
						Strings.Add(N);
					}
					++I;
				}
			}
		}
	} /* ? *//* FINALLY */
	catch (...)
	{
		Strings.EndUpdate();
	}
}

void TIniFile::ReadSections(TStringList &Strings)
{
	long I;
	wxString Section;

	// Assert( !! Strings , SStringsUnassignedError );
	Strings.BeginUpdate();
	try
	{
		Strings.Clear();
		if (FFileBuffer->Count() > 0)
		{
			I = 0;
			while ((I < FFileBuffer->Count()))
			{
				if (IsSection(FFileBuffer->Item(I)))
				{
					Section = Trim(FFileBuffer->Item(I));
					Delete(Section, 0, 1);
					Delete(Section, Length(Section) - 1, 1);
					Strings.Add(Trim(Section));
				}
				++I;
			}
		}
	} /* ? *//* FINALLY */
	catch (...)
	{
		Strings.EndUpdate();
	}
}

//---------------------------------------------------------------------------
TStringList* StringToTokiens( AnsiString Words, AnsiString Dlmtr )
{
  AnsiString Work = Words.Trim();
  int spos;
  TStringList *Making = new TStringList;

  while ((spos = Work.AnsiPos(Dlmtr)) != 0) {
    Making->Add(Work.SubString( 1, spos-1));
    Work = Work.SubString( spos+1, Work.Length() - spos);
    Work = Work.Trim();
  } // while
  if (Work != "")
    Making->Add(Work);

  return Making;
}

TStringList * Defines::GetList(String key)
{
        int indexS = -1, indexF = -1;
        for (int i=0; i<l->Count; i++)
        {
                switch(indexS)
                {
                case -1:
                        if (l->Strings[i]==String("@")+key)
                                indexS = i;
                        break;
                default:
                        if (l->Strings[i]==String("/")+key)
                        {
                                indexF = i;
                                i = l->Count;
                        }
                        break;
                }
        }
        if (indexS !=-1 && indexF!=-1)
        {
                TStringList * out = new TStringList();
                for (int i=0; i<(indexF-indexS-1); i++)
                        out->Add(l->Strings[indexS+1+i]);
                return out;
        }
        else
                return 0;
}

//---------------------------------------------------------------------------
void TfrmMain::apply(::Move& move)
{
	TStringsEnumerator *e = move.getEffects()->GetEnumerator();
	while(e->MoveNext())
	{
		if(e->Current[1] == '!')
		{
			Memo5->Lines->Delete(Memo5->Lines->IndexOf(e->Current.SubString(2,e->Current.Length())) );
		}
		else //add something
		{
			Memo5->Lines->Add(e->Current);        	
		}
	}
	TStringList *tmpState = new TStringList(); 
	TStringsEnumerator *eM = Memo5->Lines->GetEnumerator();
	while(eM->MoveNext())
	{
     	tmpState->Add(eM->Current);
	}
	Memo5->Clear();
	tmpState->Sort();
	Memo5->Lines->AddStrings(tmpState);
	tmpState->Free();
	eM->Free();
}

//---------------------------------------------------------------------------
void TRsyncConfigAdapter::SetParamValue(AnsiString moduleName, AnsiString paramName, AnsiString paramValue){
    TModuleHolder* aHolder = GetModuleHolder(moduleName);

    if(aHolder == NULL){
        return; //"Invalid module name";
    }


    TStringList* params = aHolder->nvp;

	bool newModule = true;
    for(int i = 0; i < params->Count; i++){
        AnsiString oneLine = params->Strings[i];
        AnsiString sName, sValue;

        if(ParseNameValue(oneLine, sName, sValue)){
            if(sName == paramName){
				params->Strings[i] = "    " + paramName + " = " + paramValue;
				newModule = false;
                break;
            }
        }

	}

	if(newModule){
		params->Add("    " + paramName + " = " + paramValue);
	}

}

void __fastcall TfrmMain::WMDropFiles(TWMDropFiles& Message)
{
  int Count = DragQueryFile(reinterpret_cast<void*>(Message.Drop), 0xFFFFFFFF, NULL, 0);
  try
  {
    char FileBuf[MAX_PATH+1];
    if (Count > 0)
    {
      TStringList* FileList = new TStringList();
      try
      {
        for (int i = 0; i < Count; i++)
        {
          DragQueryFile(reinterpret_cast<void*>(Message.Drop), i, FileBuf, sizeof(FileBuf));
          FileList->Add(FileBuf);
        }
        FileList->Sort();
        reSource->Lines->BeginUpdate();
        try
        {
          reSource->Lines->Clear();
          for (int i = 0; i < FileList->Count; i++)
            reSource->Lines->Add(StringFromFile(FileList->Strings[i]));
        }
        __finally
        {
          reSource->Lines->EndUpdate();
        }
      }
      __finally
      {
        delete FileList;
      }
    }
  } __finally {

TStringList* __fastcall TYoutubeGrabFormBase::PrepareLinks()
{
	TStringList* result = NULL;
	try {
		//Check categories
		try {
			this->UploadProperties->CheckCategories();
		} catch (UnicodeString msg) {
        	this->UploadProperties->GetCategoryControl()->SetFocus();
			throw msg;
		}

		//Remove empty lines and trim
		UnicodeString link;
		int pos = 0;
		for (int i = 0; i < this->memLinks->Lines->Count; i++) {
			link = this->memLinks->Lines->Strings[i].Trim();
			if (link.IsEmpty()) {
				this->memLinks->Lines->Delete(i);
				i--; continue;
			}
			this->memLinks->Lines->Strings[i] = link;
		}
		//Check if no links
		if (this->memLinks->Lines->Count == 0) {
			this->memLinks->SetFocus();
			throw UnicodeString(L"Please provide YouTube links.");
		}

		//Extract IDs
		UnicodeString id;
		result = new TStringList;
		for (int i = 0; i < this->memLinks->Lines->Count; i++) {
			link = this->memLinks->Lines->Strings[i];

			id = YT_ExpractID(link);
			if (id.IsEmpty()) {
				UnicodeString msg = L"Invalid YouTube link \"" \
				+ link + L"\".\r\n" \
				+ L"No YouTube video ID found.";

				this->memLinks->SetFocus();
				this->memLinks->SelStart = pos;
				this->memLinks->SelLength = memLinks->Lines->Strings[i].Length();
				throw msg;
			}
			result->Add(id);

			pos += link.Length()+2;
		}
	}
	catch (UnicodeString msg) {
		Framework->ShowErrorMessage(msg, this->Caption, true);
		delete result;
		return NULL;
	}

	return result;
}

void __fastcall TfMain::FormClose(TObject *Sender, TCloseAction &Action)
{
	TFile f;
	TStringList* sl = new(TStringList);

	for(int i = 0; i < lvLib->Items->Count; i++)
		sl->Add(lvLib->Items->Item[i]->SubItems->Strings[0] + '=' +
			lvLib->Items->Item[i]->SubItems->Strings[1] + '/' +
			lvLib->Items->Item[i]->SubItems->Strings[2]);

	sl->SaveToFile(ExtractFileDir(Application->ExeName) + "\\Library.lb");
	sl->Clear();

	sl->Add("Login=" + leLogin->Text);
	if(cbRememberPass->Checked)
		sl->Add("Pass=" + lePass->Text);
	else
		sl->Add("Pass=");
	if(cbRememberPass->Checked)
		sl->Add("RememberPass=1");
	else
		sl->Add("RememberPass=0");
	sl->Add("Server=" + leServer->Text);

	sl->SaveToFile(ExtractFileDir(Application->ExeName) + "\\Settings.ini");

	sl->~TStringList();
}

Debug::~Debug()
{
   if(ntimes==0) return;
   if(!debug_on_exit) return;

   TStringList *L = new TStringList;

   double elapsed = 1000.0*((double)accumulated_counter.LowPart)/((double)FrequencyCounter.LowPart);
   double average_elapsed = elapsed / (double) ntimes;

   L->Add("Number of times called:"+AnsiString(ntimes));
   L->Add("Elapsed time msec:"+AnsiString(elapsed));
   L->Add("Average elapsed time msec:"+AnsiString(average_elapsed));

   L->SaveToFile("c:\\debug.txt");

   delete L;
}