void D3PDSelector::Begin(TTree * /*tree*/) { // The Begin() function is called at the start of the query. // When running with PROOF Begin() is only called on the client. // The tree argument is deprecated (on PROOF 0 is passed). std::cout << "BEGIN" << std::endl; TString option = GetOption(); }
void esdAna::SlaveBegin(TTree *tree) { // The SlaveBegin() function is called after the Begin() function. // When running with PROOF SlaveBegin() is called on each slave server. // The tree argument is deprecated (on PROOF 0 is passed). Init(tree); TString option = GetOption(); }
bool wxOptionValue::GetOption(const wxString& name, int *v1, int *v2, int *v3, const wxString& delims) const { wxArrayInt intArr; if (GetOption(name, intArr, 3, delims) != 3) return false; if (v1) *v1 = intArr[0]; if (v2) *v2 = intArr[1]; if (v3) *v3 = intArr[2]; return true; }
bool wxOptionValue::GetOption(const wxString& name, float *v1, float *v2, float *v3, const wxString& delims) const { double nums[3]; if (GetOption(name, nums, 3, delims)) return false; if (v1) *v1 = (float)nums[0]; if (v2) *v2 = (float)nums[1]; if (v3) *v3 = (float)nums[2]; return true; }
void generate_corrections_TRB3_dataStructureV2::Begin(TTree * /*tree*/) { TString option = GetOption(); binsHist = new TH1F*[channelCount]; correctionsHist = new TH1F*[channelCount]; for(int i = 0; i < channelCount; i++){ binsHist[i] = new TH1F(Form("binsHist%d", i), Form("binsHist%d", i), 500, 0, 5000); correctionsHist[i] = new TH1F(Form("correction%d", i), Form("correction%d", i), 500, 0, 500); } }
Direct::String Config::GetOption( const Direct::String &name ) { D_DEBUG_AT( DirectFB_Graphics, "Graphics::Config::%s( %p, '%s' )\n", __FUNCTION__, this, *name ); long v = 0; GetOption( name, v ); return Direct::String::F( "%ld", v ); }
void MySelector::Begin(TTree * /*tree*/) { // The Begin() function is called at the start of the query. // When running with PROOF Begin() is only called on the client. // The tree argument is deprecated (on PROOF 0 is passed). TString option = GetOption(); // some time measurement tBegin.Set(); printf("*==* ---------- Begin of Job ----------"); tBegin.Print(); }
//_____________________________________________________________________________ void ProofSelectorMyCutFlow::Begin(TTree * /*tree*/) { // The Begin() function is called at the start of the query. // When running with PROOF Begin() is only called on the client. // The tree argument is deprecated (on PROOF 0 is passed). cout << "start Begin " << endl; TString option = GetOption(); cout << "end Begin" << endl; }
// Build the SAM keyboard matrix from the current PC state void SetSamKeyState () { // No SAM keys are pressed initially ReleaseAllSamKeys(); // Set any SIP selection on the SAM keyboard if (nSipKey >= 0 && nSipKey != SK_NONE) PressSamKey(nSipKey); if (nSipMods & SMOD_SHIFT) PressSamKey(SK_SHIFT); if (nSipMods & SMOD_SYMBOL) PressSamKey(SK_SYMBOL); if (nSipMods & SMOD_CONTROL) PressSamKey(SK_CONTROL); // If the control pad or hardware keys are pressed, activate the appropriate SAM key for (int i = 0 ; i < sizeof(anHwKeys)/sizeof(anHwKeys[0]) ; i++) { if (IsPressed(anHwKeys[i])) PressSamKey(anKeyMap[i]); } // Left and right shift keys are equivalent, and also complementary! bool fShiftToggle = IsPressed(VK_LSHIFT) && IsPressed(VK_RSHIFT); // Process the key combinations required for the mode we're in switch (GetOption(keymapping)) { // SAM keys case 1: ProcessKeyTable(asSamSymbols); ProcessKeyTable(asSamMappings); break; // Spectrum mappings case 2: ProcessKeyTable(asSpectrumSymbols); ProcessKeyTable(asSpectrumMappings); break; } // Toggle shift if both shift keys are down to allow shifted versions of keys that are // shifted on the PC but unshifted on the SAM if (fShiftToggle) ReleaseKey(VK_SHIFT); // Process the simple key mappings ProcessKeyTable(asSamKeys); // Update the SIP if it may have changed if (fSipDirty) { InvalidateRect(g_hwndSIP, NULL, FALSE); fSipDirty = false; } }
logical DLInterpreter :: LISTEXPRESSION ( ) { logical term = NO; BEGINSEQ if ( !GetOption('h') ) ShowExpression(); else { // : Output("list current expression: ListExpression|l \n"); if ( !GetOption('d') ) LEAVESEQ // 1 2 3 4 5 6 7 8 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 Output(" The command lists the current expression \n"); Output(" \n"); // - } ENDSEQ return(term); }
logical DLInterpreter :: LISTCURRENTLINE ( ) { logical term = NO; BEGINSEQ if ( !GetOption('h') ) ShowCurrentLine(); else { // : Output("list current line : ListCurrentLine|dlc \n"); if ( !GetOption('d') ) LEAVESEQ // 1 2 3 4 5 6 7 8 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 Output(" The command lists the line with the current statement.\n"); Output(" \n"); // - } ENDSEQ return(term); }
logical DLInterpreter :: RESETBREAK ( ) { logical term = NO; BEGINSEQ if ( !GetOption('h') ) SetBreakPoint(NO); else { // : Output("reset break point : ResetBreak|drb \n"); if ( !GetOption('d') ) LEAVESEQ // 1 2 3 4 5 6 7 8 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 Output(" The command sets a break point at the current position.\n"); Output(" \n"); // - } ENDSEQ return(term); }
void UEAnalysisSelectorRootple::Begin(TTree * /*tree*/) { // The Begin() function is called at the start of the query. // When running with PROOF Begin() is only called on the client. // The tree argument is deprecated (on PROOF 0 is passed). TString option = GetOption(); std::cout << "UEAnalysisSelectorRootple Begin " <<std::endl; ue = new UEAnalysisUE(); jets = new UEAnalysisJets(); mpi = new UEAnalysisMPI(); }
static void ProcStatus( void ) { disp_optn optn; optn = GetOption(); if( optn == OPEN ) { WndCreateStatusWindow( &WndStatusColour ); } else if( optn == CLOSE ) { WndCloseStatusWindow(); } else { Error( ERR_LOC, LIT_ENG( ERR_BAD_OPTION ), GetCmdName( CMD_DISPLAY ) ); } }
int getopt(int argc, char **argv, char *optstring) { int i; i = GetOption(argc, argv, optstring, &optarg); if (i==0 || i==1) return EOF; else if (i==-1) { char c=*(optarg+1); return c; } else return i; }
void TagAndProbe::Begin(TTree * /*tree*/) { // The Begin() function is called at the start of the query. // When running with PROOF Begin() is only called on the client. // The tree argument is deprecated (on PROOF 0 is passed). TString option = GetOption(); tTagAndProbeMuIso_=NULL; tTagAndProbeMuReco_=NULL; tTagAndProbeElecIso_=NULL; tTagAndProbeElecReco_=NULL; }
void Config::DumpValues( std::initializer_list<Direct::String> names, Direct::String &out_str ) { D_DEBUG_AT( DirectFB_Graphics, "Graphics::Config::%s( %p )\n", __FUNCTION__, this ); for (auto &name : names) { long value; if (GetOption( name, value ) == DFB_OK) out_str.PrintF( "%s%s:0x%lx", out_str.empty() ? "" : ",", *name, value ); } }
//_____________________________________________________________________________ void ProofFriends::Begin(TTree * /*tree*/) { // The Begin() function is called at the start of the query. // When running with PROOF Begin() is only called on the client. // The tree argument is deprecated (on PROOF 0 is passed). TString option = GetOption(); TNamed *out = (TNamed *) fInput->FindObject("PROOF_DONT_PLOT"); if (out) fPlot = kFALSE; out = (TNamed *) fInput->FindObject("PROOF_NO_FRIENDS"); if (out) fDoFriends = kFALSE; }
static void ForEachOption( TidyDoc tdoc, OptionFunc OptionPrint ) { TidyIterator pos = tidyGetOptionList( tdoc ); while ( pos ) { TidyOption topt = tidyGetNextOption( tdoc, &pos ); OptionDesc d; GetOption( tdoc, topt, &d ); (*OptionPrint)( tdoc, topt, &d ); } }
bool wxOptionValue::GetOption(const wxString& name, float *value, int count, const wxString& delims) const { double *nums = (double*)malloc(sizeof(double)*count); if (GetOption(name, nums, count, delims)) { for (int i=0; i < count; i++) value[i] = (float)nums[i]; free(nums); return true; } free(nums); return false; }
void analysis::SlaveBegin(TTree * /*tree*/) { // The SlaveBegin() function is called after the Begin() function. // When running with PROOF SlaveBegin() is called on each slave server. // The tree argument is deprecated (on PROOF 0 is passed). TString option = GetOption(); h1_vz = new TH1F("h1_vz","Vertex Z for the proton",100,-5,5); h1_E = new TH1F("h1_E","Energy spectrum for the proton",100,0.,2.); fOutput->Add(h1_vz); fOutput->Add(h1_E); }
void Tape::Play () { if (IsInserted() && !IsPlaying()) { g_fPlaying = true; // Schedule next edge Tape::NextEdge(g_dwCycleCounter); // Trigger turbo mode if fast loading is enabled if (IsPlaying() && GetOption(turbotape)) g_nTurbo |= TURBO_TAPE; } }
//gets the number of parameters that follow the specified option uint32 CCommandLineParser::GetNumParameters(const char* pszOption) const { //get the option const COption* pOpt = GetOption(pszOption); //see if we got one if(pOpt) { return pOpt->m_nNumParameters; } //no option found return 0; }
void abcd::Begin(TTree * /*tree*/) { string option = GetOption(); cout<<"abcd::Begin --> "<<option<<endl; string out_file_name = "../plots/"+option; string cur_out_file_name = out_file_name+".abcd.plots.root"; out_file = (TFile*) TFile::Open(cur_out_file_name.c_str(),"RECREATE"); out_file->cd(); string muon_d0sig_met = "scat_muon_d0sig_met"; scat_muon_d0sig_met = new TH2F(muon_d0sig_met.c_str(),muon_d0sig_met.c_str(),35,0,500,25,0,3); }
extern int main(int argc, char **argv) { struct sigaction sa; // PGID変更 setsid(); memset(&sa, 0, sizeof(struct sigaction)); sa.sa_handler = SIG_IGN; sa.sa_flags |= SA_RESTART; sigemptyset(&sa.sa_mask); if (sigaction(SIGCHLD, &sa, NULL) != 0) { Error("sigaction(2) failure"); } memset(&sa, 0, sizeof(struct sigaction)); sa.sa_handler = (void *)StopProcess; sa.sa_flags |= SA_RESTART; sigemptyset(&sa.sa_mask); if (sigaction(SIGHUP, &sa, NULL) != 0) { Error("sigaction(2) failure"); } prctl(PR_SET_PDEATHSIG, SIGHUP); SetDefault(); (void)GetOption(option, argc, argv, NULL); if (getenv("GLSERVER_DEBUG") != NULL) { fDebug = TRUE; } InitSystem(); #ifdef USE_SSL if (fSsl) { Message("glserver start (ssl)"); if (fVerifyPeer) { Message("verify peer"); } else { Message("no verify peer"); } } else { Message("glserver start"); } #else Message("glserver start"); #endif ExecuteServer(); Message("glserver end"); return (0); }
BOOL CEnCommandLineInfo::GetOption(LPCTSTR szFlag, CString& sParam) const { CStringArray aParams; if (GetOption(szFlag, aParams)) { if (aParams.GetSize()) sParam = aParams[0]; return TRUE; } return FALSE; }
void PrintDefaults(SEXP rho) { R_print.na_string = NA_STRING; R_print.na_string_noquote = mkChar("<NA>"); R_print.na_width = strlen(CHAR(R_print.na_string)); R_print.na_width_noquote = strlen(CHAR(R_print.na_string_noquote)); R_print.quote = 1; R_print.right = 0; R_print.digits = GetOptionDigits(rho); R_print.scipen = asInteger(GetOption(install("scipen"), rho)); if (R_print.scipen == NA_INTEGER) R_print.scipen = 0; R_print.gap = 1; R_print.width = GetOptionWidth(rho); }
logical DLInterpreter :: CONTINUE ( ) { logical term = NO; BEGINSEQ if ( !GetOption('h') ) run_option = YES; else { // : Output("continue application : continue|c \n"); if ( !GetOption('d') ) LEAVESEQ // 1 2 3 4 5 6 7 8 // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 Output(" This is a run command, which causes the debugger to run the application \n"); Output(" until the next break point.\n"); Output(" \n"); // - } ENDSEQ return(term); }
/////////////////////////////////////////////////////////////////////////////// // Descripcion: // - Activa / desactiva las opciones del menu Menu. // Parametros: // - Menu. Referencia al menu sobre el que actuar. // - bActive. Flag de activacion / desactivacion // Devuelve: // Notas: ////////////////////////////////////////////////////////////////////////////// void CGUIWEntityInteract::ActiveMenu(OptionsVector& Menu, const bool bActive) { // SOLO si instancia inicializada ASSERT(Inherited::IsInitOk()); // Se recorre menu activando / desactivando OptionsVectorIt MenuIt(Menu.begin()); for (; MenuIt != Menu.end(); ++MenuIt) { // Se obtiene instancia a opcion y se activa / desactiva GetOption(*MenuIt)->Option.SetActive(bActive); } }
static void ForEachSortedOption( TidyDoc tdoc, OptionFunc OptionPrint ) { AllOption_t tOption; const TidyOption *topt; getSortedOption( tdoc, &tOption ); for( topt = tOption.topt; *topt; ++topt) { OptionDesc d; GetOption( tdoc, *topt, &d ); (*OptionPrint)( tdoc, *topt, &d ); } }