/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86

Bug Summary

File:	alld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h
Warning:	line 398, column 7 Null pointer passed to 2nd parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -main-file-name DTrackTimeBased_factory.cc -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0 -D HAVE_CCDB -D HAVE_RCDB -D HAVE_EVIO -D HAVE_TMVA=1 -D RCDB_MYSQL=1 -D RCDB_SQLITE=1 -D SQLITE_USE_LEGACY_STRUCT=ON -I .Linux_CentOS7.7-x86_64-gcc4.8.5/libraries/TRACKING -I libraries/TRACKING -I . -I libraries -I libraries/include -I /w/halld-scifs17exp/home/sdobbs/clang/halld_recon/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I external/xstream/include -I /usr/include/tirpc -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/root/root-6.08.06/include -I /w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/ccdb/ccdb_1.06.06/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/rcdb/rcdb_0.06.00/cpp/include -I /usr/include/mysql -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlitecpp/SQLiteCpp-2.2.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/sqlite/sqlite-3.13.0^bs130/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/hdds/hdds-4.9.0/Linux_CentOS7.7-x86_64-gcc4.8.5/src -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/xerces-c/xerces-c-3.1.4/include -I /group/halld/Software/builds/Linux_CentOS7.7-x86_64-gcc4.8.5/evio/evio-4.4.6/Linux-x86_64/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/backward -internal-isystem /usr/local/include -internal-isystem /w/halld-scifs17exp/home/sdobbs/clang/llvm-project/install/lib/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /home/sdobbs/work/clang/halld_recon/src -ferror-limit 19 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /tmp/scan-build-2021-01-21-110224-160369-1 -x c++ libraries/TRACKING/DTrackTimeBased_factory.cc

libraries/TRACKING/DTrackTimeBased_factory.cc

→

1// $Id$
2//
3//    File: DTrackTimeBased_factory.cc
4// Created: Thu Sep  4 14:02:44 EDT 2008
5// Creator: davidl (on Darwin harriet.jlab.org 8.11.1 i386)
6//


9#include <iostream>
10#include <iomanip>
11#include <set>
12#include <mutex>
13#include <TMath.h>
14using namespace std;

16#define TOF_SIGMA0.080 0.080   // TOF resolution in ns

18#include <TROOT.h>

20#include "DTrackTimeBased_factory.h"
21#include <TRACKING/DTrackWireBased.h>
22#include <TRACKING/DReferenceTrajectory.h>
23#include <TRACKING/DTrackFitter.h>
24#include <TRACKING/DTrackHitSelector.h>
25#include <TRACKING/DMCTrackHit.h>
26#include <SplitString.h>
27#include "HDGEOMETRY/DMagneticFieldMapNoField.h"
28#include <deque>

30using namespace jana;

32// Routine for sorting start times
33bool DTrackTimeBased_T0_cmp(DTrackTimeBased::DStartTime_t a,
	    DTrackTimeBased::DStartTime_t b){
return (a.system>b.system);
36}

38bool DTrackTimeBased_cmp(DTrackTimeBased *a,DTrackTimeBased *b){
if (a->candidateid==b->candidateid) return a->mass()<b->mass();
return a->candidateid<b->candidateid;
41}


44// count_common_members
45//------------------
46template<typename T>
47static unsigned int count_common_members(vector<T> &a, vector<T> &b)
48{
unsigned int n=0;
for(unsigned int i=0; i<a.size(); i++){
for(unsigned int j=0; j<b.size(); j++){
	if(a[i]==b[j])n++;
}
}

return n;
57}



61//------------------
62// init
63//------------------
64jerror_t DTrackTimeBased_factory::init(void)
65{
fitter = NULL__null;

DEBUG_HISTS = false;
//DEBUG_HISTS = true;
DEBUG_LEVEL = 0;

USE_HITS_FROM_WIREBASED_FIT=false;
gPARMS->SetDefaultParameter("TRKFIT:USE_HITS_FROM_WIREBASED_FIT",
	      USE_HITS_FROM_WIREBASED_FIT);
INSERT_MISSING_HYPOTHESES=true;
gPARMS->SetDefaultParameter("TRKFIT:INSERT_MISSING_HYPOTHESES",
		    INSERT_MISSING_HYPOTHESES);

gPARMS->SetDefaultParameter("TRKFIT:DEBUG_HISTS",DEBUG_HISTS);
gPARMS->SetDefaultParameter("TRKFIT:DEBUG_LEVEL",DEBUG_LEVEL);

vector<int> hypotheses;
hypotheses.push_back(Positron);
hypotheses.push_back(PiPlus);
hypotheses.push_back(KPlus);
hypotheses.push_back(Proton);
hypotheses.push_back(Electron);
hypotheses.push_back(PiMinus);
hypotheses.push_back(KMinus);
hypotheses.push_back(AntiProton);

ostringstream locMassStream;
for(size_t loc_i = 0; loc_i < hypotheses.size(); ++loc_i)
{
locMassStream << hypotheses[loc_i];
if(loc_i != (hypotheses.size() - 1))
	locMassStream << ",";
}

string HYPOTHESES = locMassStream.str();
gPARMS->SetDefaultParameter("TRKFIT:HYPOTHESES", HYPOTHESES);

// Parse MASS_HYPOTHESES strings to make list of masses to try
hypotheses.clear();
SplitString(HYPOTHESES, hypotheses, ",");
for(size_t loc_i = 0; loc_i < hypotheses.size(); ++loc_i)
{
 if(ParticleCharge(Particle_t(hypotheses[loc_i])) > 0){
   mass_hypotheses_positive.push_back(hypotheses[loc_i]);
 }
 else if(ParticleCharge(Particle_t(hypotheses[loc_i])) < 0){
	mass_hypotheses_negative.push_back(hypotheses[loc_i]);
 }
}

if(mass_hypotheses_positive.empty()){
static once_flag pwarn_flag;
call_once(pwarn_flag, [](){
	jout << endl;
	jout << "############# WARNING !! ################ " <<endl;
	jout << "There are no mass hypotheses for positive tracks!" << endl;
	jout << "Be SURE this is what you really want!" << endl;
	jout << "######################################### " <<endl;
	jout << endl;
});
}
if(mass_hypotheses_negative.empty()){
static once_flag nwarn_flag;
call_once(nwarn_flag, [](){
	jout << endl;
	jout << "############# WARNING !! ################ " <<endl;
	jout << "There are no mass hypotheses for negative tracks!" << endl;
	jout << "Be SURE this is what you really want!" << endl;
	jout << "######################################### " <<endl;
	jout << endl;
});
}

mNumHypPlus=mass_hypotheses_positive.size();
mNumHypMinus=mass_hypotheses_negative.size();

// Forces correct particle id (when available)
PID_FORCE_TRUTH = false;
gPARMS->SetDefaultParameter("TRKFIT:PID_FORCE_TRUTH", PID_FORCE_TRUTH);

USE_SC_TIME=true;
gPARMS->SetDefaultParameter("TRKFIT:USE_SC_TIME",USE_SC_TIME);

USE_TOF_TIME=true;
gPARMS->SetDefaultParameter("TRKFIT:USE_TOF_TIME",USE_TOF_TIME);

USE_FCAL_TIME=true;
gPARMS->SetDefaultParameter("TRKFIT:USE_FCAL_TIME",USE_FCAL_TIME);

USE_BCAL_TIME=true;
gPARMS->SetDefaultParameter("TRKFIT:USE_BCAL_TIME",USE_BCAL_TIME);
     
return NOERROR;
159}

161//------------------
162// brun
163//------------------
164jerror_t DTrackTimeBased_factory::brun(jana::JEventLoop *loop, int32_t runnumber)
165{
// Get the geometry
DApplication* dapp=dynamic_cast<DApplication*>(loop->GetJApplication());
geom = dapp->GetDGeometry(runnumber);
 // Check for magnetic field
dIsNoFieldFlag = (dynamic_cast<const DMagneticFieldMapNoField*>(dapp->GetBfield(runnumber)) != NULL__null);
1
Assuming the condition is false→

if(dIsNoFieldFlag1.1
Field 'dIsNoFieldFlag' is false
1
Field 'dIsNoFieldFlag' is false
1
Field 'dIsNoFieldFlag' is false
){
2
←
Taking false branch→
  //Setting this flag makes it so that JANA does not delete the objects in 
  //_data.  This factory will manage this memory.
  //This is all of these pointers are just copied from the "StraightLine" 
  //factory, and should not be re-deleted.
  SetFactoryFlag(NOT_OBJECT_OWNER);
}
else{
  ClearFactoryFlag(NOT_OBJECT_OWNER); //This factory will create it's own obje
}

// Get pointer to TrackFitter object that actually fits a track
vector<const DTrackFitter *> fitters;
loop->Get(fitters);
3
←
Calling 'JEventLoop::Get'→
if(fitters.size()<1){
  _DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<187<<" "<<"Unable to get a DTrackFitter object! NO Charged track fitting will be done!"<<endl;
  return RESOURCE_UNAVAILABLE;
}

// Drop the const qualifier from the DTrackFitter pointer (I'm surely going to hell for this!)
fitter = const_cast<DTrackFitter*>(fitters[0]);

// Warn user if something happened that caused us NOT to get a fitter object pointer
if(!fitter){
  _DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<196<<" "<<"Unable to get a DTrackFitter object! NO Charged track fitting will be done!"<<endl;
  return RESOURCE_UNAVAILABLE;
}

// Get the particle ID algorithms
vector<const DParticleID *> pid_algorithms;
loop->Get(pid_algorithms);
if(pid_algorithms.size()<1){
  _DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<204<<" "<<"Unable to get a DParticleID object! NO PID will be done!"<<endl;
  return RESOURCE_UNAVAILABLE;
}

pid_algorithm = pid_algorithms[0];

// Warn user if something happened that caused us NOT to get a pid_algorithm object pointer
if(!pid_algorithm){
  _DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<212<<" "<<"Unable to get a DParticleID object! NO PID will be done!"<<endl;
  return RESOURCE_UNAVAILABLE;
}


if(DEBUG_HISTS){
dapp->Lock();

// Histograms may already exist. (Another thread may have created them)
// Try and get pointers to the existing ones.
fom_chi2_trk = (TH1F*)gROOT(ROOT::GetROOT())->FindObject("fom_chi2_trk");
fom = (TH1F*)gROOT(ROOT::GetROOT())->FindObject("fom");
hitMatchFOM = (TH1F*)gROOT(ROOT::GetROOT())->FindObject("hitMatchFOM");
chi2_trk_mom = (TH2F*)gROOT(ROOT::GetROOT())->FindObject("chi2_trk_mom");

if(!fom_chi2_trk)fom_chi2_trk = new TH1F("fom_chi2_trk","PID FOM: #chi^{2}/Ndf from tracking", 1000, 0.0, 100.0);
if(!fom)fom = new TH1F("fom","Combined PID FOM", 1000, 0.0, 1.01);
if(!hitMatchFOM)hitMatchFOM = new TH1F("hitMatchFOM","Total Fraction of Hit Matches", 101, 0.0, 1.01);
if(!chi2_trk_mom)chi2_trk_mom = new TH2F("chi2_trk_mom","Track #chi^{2}/Ndf versus Kinematic #chi^{2}/Ndf", 1000, 0.0, 100.0, 1000, 0.,100.);


Hstart_time=(TH2F*)gROOT(ROOT::GetROOT())->FindObject("Hstart_time");
if (!Hstart_time) Hstart_time=new TH2F("Hstart_time",
				       "vertex time source vs. time",
				 300,-50,50,9,-0.5,8.5);

dapp->Unlock();

}

return NOERROR;
243}

245//------------------
246// evnt
247//------------------
248jerror_t DTrackTimeBased_factory::evnt(JEventLoop *loop, uint64_t eventnumber)
249{
// Save event number to help with debugging
myevt=eventnumber;
if(!fitter)return NOERROR;

if(dIsNoFieldFlag){
  //Clear previous objects: 
  //JANA doesn't do it because NOT_OBJECT_OWNER was set
  //It DID delete them though, in the "StraightLine" factory
  _data.clear();
   
  vector<const DTrackTimeBased*> locTimeBasedTracks;
  loop->Get(locTimeBasedTracks, "StraightLine");
  for(size_t loc_i = 0; loc_i < locTimeBasedTracks.size(); ++loc_i)
    _data.push_back(const_cast<DTrackTimeBased*>(locTimeBasedTracks[loc_i]));
  return NOERROR;
}

// Get candidates and hits
vector<const DTrackWireBased*> tracks;
loop->Get(tracks);
if (tracks.size()==0) return NOERROR;

// get start counter hits
vector<const DSCHit*>sc_hits;
if (USE_SC_TIME){
  loop->Get(sc_hits);
}

// Get TOF points
vector<const DTOFPoint*> tof_points;
if (USE_TOF_TIME){
  loop->Get(tof_points);
}

// Get BCAL and FCAL showers
vector<const DBCALShower*>bcal_showers;
if (USE_BCAL_TIME){
  loop->Get(bcal_showers);
}
vector<const DFCALShower*>fcal_showers;
if (USE_FCAL_TIME){
  loop->Get(fcal_showers);
}

vector<const DMCThrown*> mcthrowns;
loop->Get(mcthrowns, "FinalState");
 
// Loop over candidates
for(unsigned int i=0; i<tracks.size(); i++){
  const DTrackWireBased *track = tracks[i];

  unsigned int num=_data.size();

  // Create vector of start times from various sources
  vector<DTrackTimeBased::DStartTime_t>start_times;
  CreateStartTimeList(track,sc_hits,tof_points,bcal_showers,fcal_showers,start_times);

  // Fit the track
  DoFit(track,start_times,loop,track->mass());

  //_DBG_<< "eventnumber:   " << eventnumber << endl;
  if (PID_FORCE_TRUTH && _data.size()>num) {
    // Add figure-of-merit based on difference between thrown and reconstructed momentum 
    // if more than half of the track's hits match MC truth hits and also (charge,mass)
    // match; add FOM=0 otherwise	  
    _data[_data.size()-1]->FOM=GetTruthMatchingFOM(i,_data[_data.size()-1],
				     mcthrowns);
  }
} // loop over track candidates

// Filter out duplicate tracks
FilterDuplicates();

// Fill in track data for missing hypotheses 
if (INSERT_MISSING_HYPOTHESES){
  InsertMissingHypotheses(loop);
}

// Set MC Hit-matching information
for(size_t loc_i = 0; loc_i < _data.size(); ++loc_i)
{
  if(!mcthrowns.empty())
  {
    double hitFraction;
    int thrownIndex = GetThrownIndex(mcthrowns, (DKinematicData*)_data[loc_i], hitFraction);
    _data[loc_i]->dMCThrownMatchMyID = thrownIndex;
    _data[loc_i]->dNumHitsMatchedToThrown = int(hitFraction * float(Get_NumTrackHits(_data[loc_i])) + 0.01); // + 0.01 so that it rounds down properly
  }
  else
  {
    _data[loc_i]->dMCThrownMatchMyID = -1;
    _data[loc_i]->dNumHitsMatchedToThrown = 0;
  }
}

return NOERROR;
346}

348//------------------
349// erun
350//------------------
351jerror_t DTrackTimeBased_factory::erun(void)
352{
return NOERROR;
354}

356//------------------
357// fini
358//------------------
359jerror_t DTrackTimeBased_factory::fini(void)
360{
return NOERROR;
362}

364//------------------
365// FilterDuplicates
366//------------------
367void DTrackTimeBased_factory::FilterDuplicates(void)
368{
/// Look through all current DTrackTimeBased objects and remove any
/// that have most of their hits in common with another track

if(_data.size()==0)return;

if(DEBUG_LEVEL>2)_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<374<<" "<<"Looking for clones of time-based tracks ..."<<endl;
// We want to remove duplicate tracks corresponding to actual particles,
// not just duplicate fitted tracks for certain mass hypotheses -- this
// is partly because at a later stage the holes in the list of mass 
// hypotheses are filled in, thereby spoiling the whole point of this
// part of the code!
// Keep track of pairs of candididate id's, one for which we want to 
// keep all the results of fitting with different mass hypotheses,
// the other for which we want to delete all the results of fitting.
// We need both vectors to take into account potential ambiguities: 
// for one mass hypothesis starting with one candidate may be "better"
// than starting with a second clone candidate, whereas for a second
// mass hypothesis, the opposite may be true.
vector<unsigned int> candidates_to_keep;
vector<unsigned int> candidates_to_delete;
for(unsigned int i=0; i<_data.size()-1; i++){
DTrackTimeBased *dtrack1 = _data[i];

vector<const DCDCTrackHit*> cdchits1;
vector<const DFDCPseudo*> fdchits1;
dtrack1->Get(cdchits1);
dtrack1->Get(fdchits1);
// Total number of hits in this candidate
unsigned int num_cdc1=cdchits1.size();
unsigned int num_fdc1=fdchits1.size();
unsigned int total1 = num_cdc1+num_fdc1;

JObject::oid_t cand1=dtrack1->candidateid;
for(unsigned int j=i+1; j<_data.size(); j++){
	DTrackTimeBased *dtrack2 = _data[j];
	if (dtrack2->candidateid==cand1) continue;

	vector<const DCDCTrackHit*> cdchits2;
	vector<const DFDCPseudo*> fdchits2;
	dtrack2->Get(cdchits2);
	dtrack2->Get(fdchits2);
	
	// Total number of hits in this candidate
	unsigned int num_cdc2=cdchits2.size();
	unsigned int num_fdc2=fdchits2.size();
	unsigned int total2 = num_cdc2+num_fdc2;
	
	// Count number of cdc and fdc hits in common
	unsigned int Ncdc = count_common_members(cdchits1, cdchits2);
	unsigned int Nfdc = count_common_members(fdchits1, fdchits2);
	
	if(DEBUG_LEVEL>3){
		_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<421<<" "<<"cand1:"<<cand1<<" cand2:"<<dtrack2->candidateid<<endl;
		_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<422<<" "<<"   Ncdc="<<Ncdc<<" num_cdc1="<<num_cdc1<<" num_cdc2="<<num_cdc2<<endl;
		_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<423<<" "<<"   Nfdc="<<Nfdc<<" num_fdc1="<<num_fdc1<<" num_fdc2="<<num_fdc2<<endl;
	}
	unsigned int total = Ncdc + Nfdc;	
	// If the tracks share at most one hit, consider them
	// to be separate tracks
	if (total<=1) continue;

	// Deal with the case where there are cdc hits in 
	// common between the tracks but there were no fdc 
	// hits used in one of the tracks.
	if (Ncdc>0 && (num_fdc1>0 || num_fdc2>0) 
	    && (num_fdc1*num_fdc2)==0) continue;

	// Deal with the case where there are fdc hits in
	// common between the tracks but no cdc hits used in 
	// one of the tracks.			
	if (Nfdc>0 && (num_cdc1>0 || num_cdc2>0)
	    && (num_cdc1*num_cdc2)==0) continue;

	// Look for tracks with many common hits in the CDC
	if (num_cdc1>0 && num_cdc2>0){
	  if (double(Ncdc)/double(num_cdc1)<0.9) continue;
	  if (double(Ncdc)/double(num_cdc2)<0.9) continue;
	}
	// Look for tracks with many common hits in the FDC
	if (num_fdc1>0 && num_fdc2>0){
	  if (double(Nfdc)/double(num_fdc1)<0.9) continue;
	  if (double(Nfdc)/double(num_fdc2)<0.9) continue;
	}
	
	if(total1<total2){
	  candidates_to_delete.push_back(cand1);
	  candidates_to_keep.push_back(dtrack2->candidateid);
	}else if(total2<total1){
	  candidates_to_delete.push_back(dtrack2->candidateid);
	  candidates_to_keep.push_back(cand1);
	}else if(dtrack1->FOM > dtrack2->FOM){
	  candidates_to_delete.push_back(dtrack2->candidateid);
	  candidates_to_keep.push_back(cand1);
	}else{
	  candidates_to_delete.push_back(cand1);
	  candidates_to_keep.push_back(dtrack2->candidateid);
	}
}
}

if(DEBUG_LEVEL>2)_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<469<<" "<<"Found "<<candidates_to_delete.size()<<" time-based clones"<<endl;


// Return now if we're keeping everyone
if(candidates_to_delete.size()==0)return;

// Deal with the ambiguity problem mentioned above
for (unsigned int i=0;i<candidates_to_keep.size();i++){
 for (unsigned int j=0;j<candidates_to_delete.size();j++){
   if (candidates_to_keep[i]==candidates_to_delete[j]){
     candidates_to_delete.erase(candidates_to_delete.begin()+j);
     break;
   }
 }
 
}

// Copy pointers that we want to keep to a new container and delete
// the clone objects
vector<DTrackTimeBased*> new_data;
sort(_data.begin(),_data.end(),DTrackTimeBased_cmp);
for (unsigned int i=0;i<_data.size();i++){
 bool keep_track=true;
 for (unsigned int j=0;j<candidates_to_delete.size();j++){
   if (_data[i]->candidateid==candidates_to_delete[j]){
     keep_track=false;
     if(DEBUG_LEVEL>1){
_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<496<<" "<<"Deleting clone time-based fitted result "<<i
     << " in event " << myevt << endl;
     }
     break;
   }
 }
 if (keep_track){
   new_data.push_back(_data[i]);
 }
 else delete _data[i];
}
_data = new_data;
508}

510// Returns a FOM based on difference between thrown and reconstructed momentum if track matches MC truth information, 
511// returns a FOM=0 otherwise;
512// a match requires identical masses and charges, and that more than half of the track's hits match the truth hits 
513double DTrackTimeBased_factory::GetTruthMatchingFOM(int trackIndex,DTrackTimeBased *track,vector<const DMCThrown*>mcthrowns)  {
bool match=false;

DLorentzVector fourMom = track->lorentzMomentum(); 
//DLorentzVector gen_fourMom[mcthrowns.size()];
 vector<DLorentzVector> gen_fourMom(mcthrowns.size());
for(unsigned int i=0; i<mcthrowns.size(); i++){
  gen_fourMom[i] = mcthrowns[i]->lorentzMomentum();
}

// Get info for thrown track
double f = 0.;
int thrownIndex = GetThrownIndex(mcthrowns, track, f);
if(thrownIndex<=0 || f<=0.5) return 0.;

double delta_pt_over_pt = (fourMom.Pt()-gen_fourMom[thrownIndex-1].Pt())/gen_fourMom[thrownIndex-1].Pt();
double delta_theta = (fourMom.Theta()-gen_fourMom[thrownIndex-1].Theta())*1000.0; // in milliradians
double delta_phi = (fourMom.Phi()-gen_fourMom[thrownIndex-1].Phi())*1000.0; // in milliradians
double chisq = pow(delta_pt_over_pt/0.04, 2.0) + pow(delta_theta/20.0, 2.0) + pow(delta_phi/20.0, 2.0);

if (fabs(track->mass()-mcthrowns[thrownIndex-1]->mass())<0.01 && track->charge()==mcthrowns[thrownIndex-1]->charge()) 
  match = true;

double trk_chi2=track->chisq;
unsigned int ndof=track->Ndof;

if(DEBUG_HISTS&&match){
  fom_chi2_trk->Fill(track->chisq);
  chi2_trk_mom->Fill(chisq/3.,trk_chi2/ndof);
  fom->Fill(TMath::Prob(chisq,3));
}

/*_DBG_ << "f: " << f << endl;
_DBG_ << "trk_chi2: " << trk_chi2 << endl;
_DBG_ << "ndof: " << ndof << endl;
_DBG_ << "throwncharge: " << mcthrowns[thrownIndex-1]->charge() << endl;
_DBG_ << "trackcharge: " << track->charge() << endl;
_DBG_ << "chargediff: " << fabs(track->charge()-mcthrowns[thrownIndex-1]->charge()) << endl;
_DBG_ << "thrownmass: " << mcthrowns[thrownIndex-1]->mass() << endl;
_DBG_ << "trackmass: " << track->mass() << endl;
_DBG_ << "massdiff: " << fabs(track->mass()-mcthrowns[thrownIndex-1]->mass()) << endl;
_DBG_ << "chisq: " << chisq << endl;
_DBG_ << "match?: " << match << endl;
_DBG_ << "thrownIndex: " << thrownIndex << "   trackIndex: " << trackIndex << endl;
_DBG_<< "track   " << setprecision(4) << "Px: " << fourMom.Px() << "    Py: " << fourMom.Py() << "   Pz: " << fourMom.Pz() << "   E: " << fourMom.E() << "    M: " << fourMom.M() << "   pt: " << fourMom.Pt() << "   theta: " << fourMom.Theta() << "   phi: " << fourMom.Phi() << endl; 
_DBG_<< "thrown  " << setprecision(4) << "Px: " << gen_fourMom[thrownIndex-1].Px() << "    Py: " << gen_fourMom[thrownIndex-1].Py() << "   Pz: " << gen_fourMom[thrownIndex-1].Pz() << "   E: " << gen_fourMom[thrownIndex-1].E() << "    M: " << gen_fourMom[thrownIndex-1].M() << "   pt: " << gen_fourMom[thrownIndex-1].Pt() << "   theta: " << gen_fourMom[thrownIndex-1].Theta() << "   phi: " << gen_fourMom[thrownIndex-1].Phi() << endl;*/

return (match) ?  TMath::Prob(chisq,3) : 0.0; 
561}

563//------------------
564// GetThrownIndex
565//------------------
566int DTrackTimeBased_factory::GetThrownIndex(vector<const DMCThrown*>& locMCThrowns, const DKinematicData *kd, double &f)
567{
// The DKinematicData object should be a DTrackCandidate, DTrackWireBased, or DParticle which
// has associated objects for the hits
vector<const DCDCTrackHit*> cdctrackhits;
kd->Get(cdctrackhits);
vector<const DFDCPseudo*> fdcpseudos;
kd->Get(fdcpseudos);

int locTotalNumHits = cdctrackhits.size() + fdcpseudos.size();
if(locTotalNumHits == 0)
{
f = 0;
return -1;
}

// The track number is buried in the truth hit objects of type DMCTrackHit. These should be 
// associated objects for the individual hit objects. We need to loop through them and
// keep track of how many hits for each track number we find

map<int, int> locHitMatches; //first int is MC my id, second is num hits
for(size_t loc_i = 0; loc_i < locMCThrowns.size(); ++loc_i)
{
if(fabs(locMCThrowns[loc_i]->charge()) > 0.9)
	locHitMatches[locMCThrowns[loc_i]->myid] = 0;
}

// CDC hits
for(size_t loc_i = 0; loc_i < cdctrackhits.size(); ++loc_i)
{
const DCDCHit* locCDCHit = NULL__null;
cdctrackhits[loc_i]->GetSingle(locCDCHit);
vector<const DCDCHit*> locTruthCDCHits;
    locCDCHit->Get(locTruthCDCHits);
if(locTruthCDCHits.empty()) continue;

int itrack = locTruthCDCHits[0]->itrack;
if(locHitMatches.find(itrack) == locHitMatches.end())
	continue;
++locHitMatches[itrack];
}

// FDC hits
for(size_t loc_i = 0; loc_i < fdcpseudos.size(); ++loc_i)
{
vector<const DMCTrackHit*> mctrackhits;
fdcpseudos[loc_i]->Get(mctrackhits);
if(mctrackhits.empty())
	continue;
if(!mctrackhits[0]->primary)
	continue;

int itrack = mctrackhits[0]->itrack;
if(locHitMatches.find(itrack) == locHitMatches.end())
	continue;
++locHitMatches[itrack];
}

// Find DMCThrown::myid with most wires hit
map<int, int>::iterator locIterator = locHitMatches.begin();
int locBestMyID = -1;
int locBestNumHits = 0;
for(; locIterator != locHitMatches.end(); ++locIterator)
{
if(locIterator->second <= locBestNumHits)
	continue;
locBestNumHits = locIterator->second;
locBestMyID = locIterator->first;
}

// total fraction of reconstructed hits that match truth hits
f = 1.0*locBestNumHits/locTotalNumHits;
if(DEBUG_HISTS)hitMatchFOM->Fill(f);

return locBestMyID;
641}


644// Create a list of start (vertex) times from various sources, ordered by 
645// uncertainty.
646void DTrackTimeBased_factory
::CreateStartTimeList(const DTrackWireBased *track,
	vector<const DSCHit*>&sc_hits,
	vector<const DTOFPoint*>&tof_points,
	vector<const DBCALShower*>&bcal_showers,	
	vector<const DFCALShower*>&fcal_showers,
	vector<DTrackTimeBased::DStartTime_t>&start_times){
DTrackTimeBased::DStartTime_t start_time;
 
// Match to the start counter and the outer detectors
double locStartTimeVariance = 0.0;
double track_t0=track->t0();
double locStartTime = track_t0;  // initial guess from tracking

// Get start time estimate from Start Counter
if (pid_algorithm->Get_StartTime(track->extrapolations.at(SYS_START),sc_hits,locStartTime)){
  start_time.t0=locStartTime;
  //    start_time.t0_sigma=sqrt(locTimeVariance); //uncomment when ready
  start_time.t0_sigma=sqrt(locStartTimeVariance);
  start_time.system=SYS_START;
  start_times.push_back(start_time);
}
// Get start time estimate from TOF
locStartTime = track_t0;  // initial guess from tracking
if (pid_algorithm->Get_StartTime(track->extrapolations.at(SYS_TOF),tof_points,locStartTime)){
  // Fill in the start time vector
  start_time.t0=locStartTime;
  start_time.t0_sigma=sqrt(locStartTimeVariance);
  //    start_time.t0_sigma=sqrt(locTimeVariance); //uncomment when ready
  start_time.system=SYS_TOF;
  start_times.push_back(start_time); 
}
// Get start time estimate from FCAL
locStartTime = track_t0;  // initial guess from tracking
if (pid_algorithm->Get_StartTime(track->extrapolations.at(SYS_FCAL),fcal_showers,locStartTime)){
  // Fill in the start time vector
  start_time.t0=locStartTime;
  start_time.t0_sigma=sqrt(locStartTimeVariance);
  //    start_time.t0_sigma=sqrt(locTimeVariance); //uncomment when ready
  start_time.system=SYS_FCAL;
  start_times.push_back(start_time); 
}
// Get start time estimate from BCAL
locStartTime=track_t0;
if (pid_algorithm->Get_StartTime(track->extrapolations.at(SYS_BCAL),bcal_showers,locStartTime)){
  // Fill in the start time vector
  start_time.t0=locStartTime;
  start_time.t0_sigma=0.5;
  //    start_time.t0_sigma=sqrt(locTimeVariance); //uncomment when ready
  start_time.system=SYS_BCAL;
  start_times.push_back(start_time);    
}
// Add the t0 estimate from the tracking 
start_time.t0=track_t0;
start_time.t0_sigma=5.;
start_time.system=track->t0_detector();
start_times.push_back(start_time);

// Set t0 for the fit to the first entry in the list. Usually this will be
// from the start counter.
mStartTime=start_times[0].t0;
mStartDetector=start_times[0].system;

//  _DBG_ << mStartDetector << " " << mStartTime << endl;

711}

713// Create a list of start times and do the fit for a particular mass hypothesis
714bool DTrackTimeBased_factory::DoFit(const DTrackWireBased *track,
		    vector<DTrackTimeBased::DStartTime_t>&start_times,
		    JEventLoop *loop,
		    double mass){  
if(DEBUG_LEVEL>1){_DBG__std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<718<<std::endl;_DBG_std::cerr<<"libraries/TRACKING/DTrackTimeBased_factory.cc"
<<":"<<718<<" "<<"---- Starting time based fit with mass: "<<mass<<endl;}
// Get the hits from the wire-based track
vector<const DFDCPseudo*>myfdchits;
track->GetT(myfdchits);
vector<const DCDCTrackHit *>mycdchits;
track->GetT(mycdchits);

// Do the fit
DTrackFitter::fit_status_t status = DTrackFitter::kFitNotDone;
if (USE_HITS_FROM_WIREBASED_FIT) {
  fitter->Reset();
  fitter->SetFitType(DTrackFitter::kTimeBased);	
  
  fitter->AddHits(myfdchits);
  fitter->AddHits(mycdchits);

  status=fitter->FitTrack(track->position(),track->momentum(),
	    track->charge(),mass,mStartTime,mStartDetector);
}   
else{   
  fitter->Reset();
  fitter->SetFitType(DTrackFitter::kTimeBased);    
  status = fitter->FindHitsAndFitTrack(*track, track->extrapolations,loop, 
			 mass,
			 mycdchits.size()+2*myfdchits.size(),
			 mStartTime,mStartDetector);
  
  // If the status is kFitNotDone, then not enough hits were attached to this
  // track using the hit-gathering algorithm.  In this case get the hits 
  // from the wire-based track
  if (status==DTrackFitter::kFitNotDone){
    //_DBG_ << " Using wire-based hits " << endl;
    fitter->Reset();
    fitter->SetFitType(DTrackFitter::kTimeBased);   
    fitter->AddHits(myfdchits);
    fitter->AddHits(mycdchits);
    
    status=fitter->FitTrack(track->position(),track->momentum(),
	      track->charge(),mass,mStartTime,mStartDetector);
  }

}

// if the fit returns chisq=-1, something went terribly wrong.  We may still 
// have a usable track from the wire-based pass.  In this case set 
// kFitNoImprovement so we can save the wire-based results.
if (fitter->GetChisq()<0){
  status=DTrackFitter::kFitNoImprovement;
}

// In the transition region between the CDC and the FDC where the track 
// contains both CDC and FDC hits, sometimes too many hits are discarded in 
// the time-based phase and the time-based fit result does not improve on the 
// wire-based fit result.  In this case set the status word to 
// kFitNoImprovement and copy the wire-based parameters into the time-based
// class.
if (myfdchits.size()>3 && mycdchits.size()>3){
  unsigned int ndof=fitter->GetNdof();
  if (TMath::Prob(track->chisq,track->Ndof)>
TMath::Prob(fitter->GetChisq(),ndof)&&ndof<5)
    status=DTrackFitter::kFitNoImprovement;
}
    
// Check the status value from the fit
switch(status){
case DTrackFitter::kFitNotDone:
  //_DBG_<<"Fitter returned kFitNotDone. This should never happen!!"<<endl;
case DTrackFitter::kFitFailed:
  break;
case DTrackFitter::kFitNoImprovement:
  {
    // Create a new time-based track object
    DTrackTimeBased *timebased_track = new DTrackTimeBased();
    *static_cast<DTrackingData*>(timebased_track) = *static_cast<const DTrackingData*>(track);

    timebased_track->chisq = track->chisq;
    timebased_track->Ndof = track->Ndof;
    timebased_track->pulls = track->pulls; 
    timebased_track->extrapolations = track->extrapolations;
    timebased_track->trackid = track->id;
    timebased_track->candidateid=track->candidateid;
    timebased_track->FOM=track->FOM;
    timebased_track->flags=DTrackTimeBased::FLAG__USED_WIREBASED_FIT;
 
    // add the list of start times
    timebased_track->start_times.assign(start_times.begin(),
			  start_times.end());

    for(unsigned int m=0; m<myfdchits.size(); m++)
timebased_track->AddAssociatedObject(myfdchits[m]); 
    for(unsigned int m=0; m<mycdchits.size(); m++)
timebased_track->AddAssociatedObject(mycdchits[m]);

  timebased_track->measured_cdc_hits_on_track = mycdchits.size();
  timebased_track->measured_fdc_hits_on_track = myfdchits.size();

    // dEdx
    double locdEdx_FDC, locdx_FDC, locdEdx_CDC, locdEdx_CDC_amp;
    double locdx_CDC_amp,locdx_CDC;
    unsigned int locNumHitsUsedFordEdx_FDC, locNumHitsUsedFordEdx_CDC;
    pid_algorithm->CalcDCdEdx(timebased_track, locdEdx_FDC, locdx_FDC, locdEdx_CDC, locdEdx_CDC_amp, locdx_CDC, locdx_CDC_amp,locNumHitsUsedFordEdx_FDC, locNumHitsUsedFordEdx_CDC);

    timebased_track->ddEdx_FDC = locdEdx_FDC;
    timebased_track->ddx_FDC = locdx_FDC;
    timebased_track->dNumHitsUsedFordEdx_FDC = locNumHitsUsedFordEdx_FDC;
    timebased_track->ddEdx_CDC = locdEdx_CDC; 
    timebased_track->ddEdx_CDC_amp = locdEdx_CDC_amp;
    timebased_track->ddx_CDC = locdx_CDC; 
    timebased_track->ddx_CDC_amp = locdx_CDC_amp;
    timebased_track->dNumHitsUsedFordEdx_CDC = locNumHitsUsedFordEdx_CDC;
    
    timebased_track->potential_cdc_hits_on_track = fitter->GetNumPotentialCDCHits();
  timebased_track->potential_fdc_hits_on_track = fitter->GetNumPotentialFDCHits();

    timebased_track->AddAssociatedObject(track);
    _data.push_back(timebased_track);
    
    return true;
    break;
  }
case DTrackFitter::kFitSuccess:
  {
    // Create a new time-based track object
    DTrackTimeBased *timebased_track = new DTrackTimeBased();
    *static_cast<DTrackingData*>(timebased_track) = fitter->GetFitParameters();

    timebased_track->setTime(mStartTime);
    timebased_track->chisq = fitter->GetChisq();
    timebased_track->Ndof = fitter->GetNdof();
    timebased_track->pulls = std::move(fitter->GetPulls());  
    timebased_track->extrapolations=std::move(fitter->GetExtrapolations());
    timebased_track->IsSmoothed = fitter->GetIsSmoothed();
    timebased_track->trackid = track->id;
    timebased_track->candidateid=track->candidateid;
    timebased_track->flags=DTrackTimeBased::FLAG__GOODFIT;
    
    // Set the start time and add the list of start times
    timebased_track->setT0(mStartTime,start_times[0].t0_sigma, mStartDetector);
    timebased_track->start_times.assign(start_times.begin(), start_times.end());
 
    if (DEBUG_HISTS){
int id=0;
if (mStartDetector==SYS_CDC) id=1;
else if (mStartDetector==SYS_FDC) id=2;
else if (mStartDetector==SYS_BCAL) id=3;
else if (mStartDetector==SYS_FCAL) id=4;
else if (mStartDetector==SYS_TOF) id=5;

Hstart_time->Fill(start_times[0].t0,id);
    }
    
    
    // Add hits used as associated objects
    const vector<const DCDCTrackHit*> &cdchits = fitter->GetCDCFitHits();
    const vector<const DFDCPseudo*> &fdchits = fitter->GetFDCFitHits();
    
    unsigned int num_fdc_potential=fitter->GetNumPotentialFDCHits();
    unsigned int num_cdc_potential=fitter->GetNumPotentialCDCHits();

    DTrackTimeBased::hit_usage_t temp;
    temp.inner_layer=0;
    temp.outer_layer=0;
    temp.total_hits=num_cdc_potential;
    if (cdchits.size()>0){
temp.inner_layer=cdchits[0]->wire->ring;
temp.outer_layer=cdchits[cdchits.size()-1]->wire->ring;
    }
    timebased_track->cdc_hit_usage=temp;

    // Reset the structure
    temp.inner_layer=0;
    temp.outer_layer=0;
    temp.total_hits=num_fdc_potential; 
    if (fdchits.size()>0){
temp.inner_layer=fdchits[0]->wire->layer;
temp.outer_layer=fdchits[fdchits.size()-1]->wire->layer;
    }
    timebased_track->fdc_hit_usage=temp;
    
    for(unsigned int m=0; m<cdchits.size(); m++)
timebased_track->AddAssociatedObject(cdchits[m]);
    for(unsigned int m=0; m<fdchits.size(); m++)
timebased_track->AddAssociatedObject(fdchits[m]);
    
    timebased_track->measured_cdc_hits_on_track = cdchits.size();
    timebased_track->measured_fdc_hits_on_track = fdchits.size();

    // dEdx
    double locdEdx_FDC, locdx_FDC, locdEdx_CDC, locdEdx_CDC_amp;
    double locdx_CDC,locdx_CDC_amp;
    unsigned int locNumHitsUsedFordEdx_FDC, locNumHitsUsedFordEdx_CDC;
    pid_algorithm->CalcDCdEdx(timebased_track, locdEdx_FDC, locdx_FDC, locdEdx_CDC, locdEdx_CDC_amp,locdx_CDC,locdx_CDC_amp, locNumHitsUsedFordEdx_FDC, locNumHitsUsedFordEdx_CDC);
    
    timebased_track->ddEdx_FDC = locdEdx_FDC;
    timebased_track->ddx_FDC = locdx_FDC;
    timebased_track->dNumHitsUsedFordEdx_FDC = locNumHitsUsedFordEdx_FDC;
    timebased_track->ddEdx_CDC = locdEdx_CDC;
    timebased_track->ddEdx_CDC_amp= locdEdx_CDC_amp;
    timebased_track->ddx_CDC = locdx_CDC;
    timebased_track->ddx_CDC_amp= locdx_CDC_amp;
    timebased_track->dNumHitsUsedFordEdx_CDC = locNumHitsUsedFordEdx_CDC;

    // Set CDC ring & FDC plane hit patterns before candidate and wirebased tracks are associated
    vector<const DCDCTrackHit*> tempCDCTrackHits;
    vector<const DFDCPseudo*> tempFDCPseudos;
    timebased_track->Get(tempCDCTrackHits);
    timebased_track->Get(tempFDCPseudos);
    timebased_track->dCDCRings = pid_algorithm->Get_CDCRingBitPattern(tempCDCTrackHits);
    timebased_track->dFDCPlanes = pid_algorithm->Get_FDCPlaneBitPattern(tempFDCPseudos);
    
    timebased_track->potential_cdc_hits_on_track = fitter->GetNumPotentialCDCHits();
    timebased_track->potential_fdc_hits_on_track = fitter->GetNumPotentialFDCHits();

    // Add DTrack object as associate object
    timebased_track->AddAssociatedObject(track);
  
    // Compute the figure-of-merit based on tracking
    timebased_track->FOM = TMath::Prob(timebased_track->chisq, timebased_track->Ndof);
    //_DBG_<< "FOM:   " << timebased_track->FOM << endl;

    _data.push_back(timebased_track);
   
    return true;
    break;
 
  }
default:
  break;
}
return false;
948}


951// Create a track with a mass hypothesis that was not present in the list of 
952// fitted tracks from an existing fitted track.
953void DTrackTimeBased_factory::AddMissingTrackHypothesis(vector<DTrackTimeBased*>&tracks_to_add,
		      const DTrackTimeBased *src_track,
					double my_mass,
					double q,
					JEventLoop *loop){

// Create a new time-based track object
DTrackTimeBased *timebased_track = new DTrackTimeBased();
*static_cast<DTrackingData*>(timebased_track) = *static_cast<const DTrackingData*>(src_track);

// Get the hits used in the fit  
vector<const DCDCTrackHit *>src_cdchits;
src_track->GetT(src_cdchits);
vector<const DFDCPseudo *>src_fdchits;
src_track->GetT(src_fdchits);

// Copy over DKinematicData part from the result of a successful fit
timebased_track->setPID(IDTrack(q, my_mass));
timebased_track->chisq = src_track->chisq;
timebased_track->Ndof = src_track->Ndof;
timebased_track->pulls = src_track->pulls;
timebased_track->extrapolations = src_track->extrapolations;
timebased_track->trackid = src_track->id;
timebased_track->candidateid=src_track->candidateid;
timebased_track->FOM=src_track->FOM;
timebased_track->cdc_hit_usage=src_track->cdc_hit_usage;
timebased_track->fdc_hit_usage=src_track->fdc_hit_usage;
timebased_track->flags=DTrackTimeBased::FLAG__USED_OTHER_HYPOTHESIS;

// Add list of start times
timebased_track->start_times.assign(src_track->start_times.begin(),  
		      src_track->start_times.end());
// Set the start time we used
timebased_track->setT0(timebased_track->start_times[0].t0,
	 timebased_track->start_times[0].t0_sigma, 
	 timebased_track->start_times[0].system);

// Add DTrack object as associate object
vector<const DTrackWireBased*>wire_based_track;
src_track->GetT(wire_based_track);
timebased_track->AddAssociatedObject(wire_based_track[0]);

// (Partially) compensate for the difference in energy loss between the 
// source track and a particle of mass my_mass 
DVector3 position,momentum;
if (timebased_track->extrapolations.at(SYS_CDC).size()>0){
  unsigned int index=timebased_track->extrapolations.at(SYS_CDC).size()-1;
  position=timebased_track->extrapolations[SYS_CDC][index].position;
  momentum=timebased_track->extrapolations[SYS_CDC][index].momentum;
}
else if (timebased_track->extrapolations.at(SYS_FDC).size()>0){
  unsigned int index=timebased_track->extrapolations.at(SYS_FDC).size()-1;
  position=timebased_track->extrapolations[SYS_FDC][index].position;
  momentum=timebased_track->extrapolations[SYS_FDC][index].momentum;
}

DTrackFitter::fit_status_t status=DTrackFitter::kFitNotDone;
if (momentum.Mag()>0.){
  CorrectForELoss(position,momentum,q,my_mass);  
  timebased_track->setMomentum(momentum);
  timebased_track->setPosition(position);
  // Redo the fit with the new position and momentum as initial guesses
  fitter->Reset();
  fitter->SetFitType(DTrackFitter::kTimeBased);    
  status = fitter->FindHitsAndFitTrack(*timebased_track,
			 timebased_track->extrapolations,loop, 
			 my_mass,
			 src_cdchits.size()+2*src_fdchits.size(),
			 timebased_track->t0(),
			 timebased_track->t0_detector());
  // if the fit returns chisq=-1, something went terribly wrong.  Do not 
  // update the parameters for the track...
  if (fitter->GetChisq()<0) status=DTrackFitter::kFitFailed;

  // if the fit flips the charge of the track, then this is bad as well
  if(q != fitter->GetFitParameters().charge())
      status=DTrackFitter::kFitFailed; 

  // if we can't refit the track, it is likely of poor quality, so stop here and do not add the hypothesis
  if(status == DTrackFitter::kFitFailed) {
      delete timebased_track;
      return;
  }

  if (status==DTrackFitter::kFitSuccess){
    timebased_track->chisq = fitter->GetChisq();
    timebased_track->Ndof = fitter->GetNdof();
    timebased_track->pulls = std::move(fitter->GetPulls());  
    timebased_track->extrapolations=std::move(fitter->GetExtrapolations());
    timebased_track->IsSmoothed = fitter->GetIsSmoothed();  
    *static_cast<DTrackingData*>(timebased_track) = fitter->GetFitParameters();
    timebased_track->flags=DTrackTimeBased::FLAG__GOODFIT;
    
    timebased_track->setTime(timebased_track->start_times[0].t0);

    // Add hits used as associated objects
    const vector<const DCDCTrackHit*> &cdchits = fitter->GetCDCFitHits();
    const vector<const DFDCPseudo*> &fdchits = fitter->GetFDCFitHits();
    
    unsigned int num_fdc_potential=fitter->GetNumPotentialFDCHits();
    unsigned int num_cdc_potential=fitter->GetNumPotentialCDCHits();

    DTrackTimeBased::hit_usage_t temp;
    temp.inner_layer=0;
    temp.outer_layer=0;
    temp.total_hits=num_cdc_potential;
    if (cdchits.size()>0){
temp.inner_layer=cdchits[0]->wire->ring;
temp.outer_layer=cdchits[cdchits.size()-1]->wire->ring;
    }
    timebased_track->cdc_hit_usage=temp;

    // Reset the structure
    temp.inner_layer=0;
    temp.outer_layer=0;
    temp.total_hits=num_fdc_potential; 
    if (fdchits.size()>0){
temp.inner_layer=fdchits[0]->wire->layer;
temp.outer_layer=fdchits[fdchits.size()-1]->wire->layer;
    }
    timebased_track->fdc_hit_usage=temp;
    
    for(unsigned int m=0; m<cdchits.size(); m++)
timebased_track->AddAssociatedObject(cdchits[m]);
    for(unsigned int m=0; m<fdchits.size(); m++)
timebased_track->AddAssociatedObject(fdchits[m]); 
    
    timebased_track->measured_cdc_hits_on_track = cdchits.size();
    timebased_track->measured_fdc_hits_on_track = fdchits.size();
    
    // Compute the figure-of-merit based on tracking
    timebased_track->FOM = TMath::Prob(timebased_track->chisq, timebased_track->Ndof);
    
  }
}

if (status!=DTrackFitter::kFitSuccess){ 
  for(unsigned int m=0; m<src_fdchits.size(); m++)
    timebased_track->AddAssociatedObject(src_fdchits[m]); 
  for(unsigned int m=0; m<src_cdchits.size(); m++)
    timebased_track->AddAssociatedObject(src_cdchits[m]);
  
  timebased_track->measured_cdc_hits_on_track = src_cdchits.size();
  timebased_track->measured_fdc_hits_on_track = src_fdchits.size();
}

// dEdx
double locdEdx_FDC, locdx_FDC, locdEdx_CDC, locdEdx_CDC_amp;
double locdx_CDC,locdx_CDC_amp;
unsigned int locNumHitsUsedFordEdx_FDC, locNumHitsUsedFordEdx_CDC;
pid_algorithm->CalcDCdEdx(timebased_track, locdEdx_FDC, locdx_FDC, locdEdx_CDC, locdEdx_CDC_amp,locdx_CDC,locdx_CDC_amp, locNumHitsUsedFordEdx_FDC, locNumHitsUsedFordEdx_CDC);

timebased_track->ddEdx_FDC = locdEdx_FDC;
timebased_track->ddx_FDC = locdx_FDC;
timebased_track->dNumHitsUsedFordEdx_FDC = locNumHitsUsedFordEdx_FDC;
timebased_track->ddEdx_CDC = locdEdx_CDC;
timebased_track->ddEdx_CDC_amp = locdEdx_CDC_amp;
timebased_track->ddx_CDC = locdx_CDC;
timebased_track->ddx_CDC_amp = locdx_CDC_amp;
timebased_track->dNumHitsUsedFordEdx_CDC = locNumHitsUsedFordEdx_CDC;

// Set CDC ring & FDC plane hit patterns before candidate and wirebased tracks are associated
vector<const DCDCTrackHit*> tempCDCTrackHits;
vector<const DFDCPseudo*> tempFDCPseudos;
timebased_track->Get(tempCDCTrackHits);
timebased_track->Get(tempFDCPseudos);
timebased_track->dCDCRings = pid_algorithm->Get_CDCRingBitPattern(tempCDCTrackHits);
timebased_track->dFDCPlanes = pid_algorithm->Get_FDCPlaneBitPattern(tempFDCPseudos);

timebased_track->potential_cdc_hits_on_track = fitter->GetNumPotentialCDCHits();
timebased_track->potential_fdc_hits_on_track = fitter->GetNumPotentialFDCHits();

tracks_to_add.push_back(timebased_track);
1126}


1129// If the fit failed for certain hypotheses, fill in the gaps using data from
1130// successful fits for each candidate.
1131bool DTrackTimeBased_factory::InsertMissingHypotheses(JEventLoop *loop){
if (_data.size()==0) return false;

// Make sure the tracks are ordered by candidate id
sort(_data.begin(),_data.end(),DTrackTimeBased_cmp);

JObject::oid_t old_id=_data[0]->candidateid;
unsigned int mass_bits=0;
double q=_data[0]->charge();
bool flipped_charge=false;
vector<DTrackTimeBased*>myhypotheses;
vector<DTrackTimeBased*>tracks_to_add;
for (size_t i=0;i<_data.size();i++){
  if (_data[i]->candidateid!=old_id){
    AddMissingTrackHypotheses(mass_bits,tracks_to_add,myhypotheses,q,
		flipped_charge,loop);

    // Clear the myhypotheses vector for the next track
    myhypotheses.clear();
    // Reset flags and charge 
    q=_data[i]->charge();	
    flipped_charge=false;
    // Set the bit for this mass hypothesis
    mass_bits = 1<<_data[i]->PID();
    
    // Add the data to the myhypotheses vector
    myhypotheses.push_back(_data[i]);
  }
  else{
    myhypotheses.push_back(_data[i]);

    // Set the bit for this mass hypothesis
    mass_bits |= 1<< _data[i]->PID();
    
    // Check if the sign of the charge has flipped
    if (_data[i]->charge()!=q) flipped_charge=true;
  }
  
  old_id=_data[i]->candidateid;
}
// Deal with last track candidate	
AddMissingTrackHypotheses(mass_bits,tracks_to_add,myhypotheses,q,
	    flipped_charge,loop);
  
// Add the new list of tracks to the output list
if (tracks_to_add.size()>0){
  for (size_t i=0;i<tracks_to_add.size();i++){
    _data.push_back(tracks_to_add[i]);
  }
  // Make sure the tracks are ordered by candidate id
  sort(_data.begin(),_data.end(),DTrackTimeBased_cmp);
}

return true;
1185}

1187// Use the FastSwim method in DReferenceTrajectory to propagate back to the 
1188// POCA to the beam line, adding a bit of energy at each step that would have 
1189// been lost had the particle emerged from the target.
1190void DTrackTimeBased_factory::CorrectForELoss(DVector3 &position,DVector3 &momentum,double q,double my_mass){  
DReferenceTrajectory::swim_step_t dummy_step;
DReferenceTrajectory rt(fitter->GetDMagneticFieldMap(),q,&dummy_step);
rt.SetDGeometry(geom);
rt.SetMass(my_mass);
rt.SetPLossDirection(DReferenceTrajectory::kBackward);
DVector3 last_pos,last_mom;
DVector3 origin(0.,0.,65.);
DVector3 dir(0.,0.,1.);
rt.FastSwim(position,momentum,last_pos,last_mom,q,origin,dir,300.);   
position=last_pos;
momentum=last_mom;   
1202}

1204// Fill in all missing hypotheses for a given track candidate
1205void DTrackTimeBased_factory::AddMissingTrackHypotheses(unsigned int mass_bits,
					vector<DTrackTimeBased*>&tracks_to_add,
					vector<DTrackTimeBased *>&myhypotheses,
					double q,
					bool flipped_charge,
					JEventLoop *loop){ 

unsigned int last_index=myhypotheses.size()-1;
unsigned int index=0;
if (q>0){
  if (flipped_charge){
    /*if ((mass_bits & (1<<AntiProton))==0){
AddMissingTrackHypothesis(tracks_to_add,myhypotheses[last_index],
		  ParticleMass(Proton),-1.,loop);  
    } 
    */
    for (unsigned int i=0;i<mass_hypotheses_negative.size();i++){
if ((mass_bits & (1<<mass_hypotheses_negative[i]))==0){
 if (mass_hypotheses_negative[i]>13) index=last_index;
 else index=0;
 AddMissingTrackHypothesis(tracks_to_add,myhypotheses[index],
		    ParticleMass(Particle_t(mass_hypotheses_negative[i])),
		    -1.,loop);  
} 
    }
  }
  /*   if ((mass_bits & (1<<Proton))==0){
    AddMissingTrackHypothesis(tracks_to_add,myhypotheses[last_index],
		ParticleMass(Proton),+1.,loop);  
		} */
  for (unsigned int i=0;i<mass_hypotheses_positive.size();i++){
    if ((mass_bits & (1<<mass_hypotheses_positive[i]))==0){
if (mass_hypotheses_positive[i]>13) index=last_index;
else index=0;
AddMissingTrackHypothesis(tracks_to_add,myhypotheses[index],
		  ParticleMass(Particle_t(mass_hypotheses_positive[i])),
		  +1.,loop);  
    } 
  }    
}
else{
  /*
  if ((mass_bits & (1<<AntiProton))==0){
    AddMissingTrackHypothesis(tracks_to_add,myhypotheses[last_index],
		ParticleMass(Proton),-1.,loop);  
		} */	
  for (unsigned int i=0;i<mass_hypotheses_negative.size();i++){
    if ((mass_bits & (1<<mass_hypotheses_negative[i]))==0){
if (mass_hypotheses_negative[i]>13) index=last_index;
else index=0;
AddMissingTrackHypothesis(tracks_to_add,myhypotheses[index],
		  ParticleMass(Particle_t(mass_hypotheses_negative[i])),
		  -1.,loop);  
    } 
  }
  if (flipped_charge){
    /*if ((mass_bits & (1<<Proton))==0){
AddMissingTrackHypothesis(tracks_to_add,myhypotheses[last_index],
		  ParticleMass(Proton),+1.,loop);  
		  } */
    for (unsigned int i=0;i<mass_hypotheses_positive.size();i++){
if ((mass_bits & (1<<mass_hypotheses_positive[i]))==0){
 if (mass_hypotheses_positive[i]>13) index=last_index;
 else index=0;
 AddMissingTrackHypothesis(tracks_to_add,myhypotheses[index],
		    ParticleMass(Particle_t(mass_hypotheses_positive[i])),
		    +1.,loop);  
} 
    }	
  }
}
1276} 

←

/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h

→

1// $Id: JEventLoop.h 1763 2006-05-10 14:29:25Z davidl $
2//
3//    File: JEventLoop.h
4// Created: Wed Jun  8 12:30:51 EDT 2005
5// Creator: davidl (on Darwin wire129.jlab.org 7.8.0 powerpc)
6//

8#ifndef _JEventLoop_
9#define _JEventLoop_

11#include <sys/time.h>

13#include <vector>
14#include <list>
15#include <string>
16#include <utility>
17#include <typeinfo>
18#include <string.h>
19#include <map>
20#include <utility>
21using std::vector;
22using std::list;
23using std::string;
24using std::type_info;

26#include <JANA/jerror.h>
27#include <JANA/JObject.h>
28#include <JANA/JException.h>
29#include <JANA/JEvent.h>
30#include <JANA/JThread.h>
31#include <JANA/JFactory_base.h>
32#include <JANA/JCalibration.h>
33#include <JANA/JGeometry.h>
34#include <JANA/JResourceManager.h>
35#include <JANA/JStreamLog.h>

37// The following is here just so we can use ROOT's THtml class to generate documentation.
38#include "cint.h"


41// Place everything in JANA namespace
42namespace jana{


45template<class T> class JFactory;
46class JApplication;
47class JEventProcessor;


50class JEventLoop{
public:

friend class JApplication;

enum data_source_t{
	DATA_NOT_AVAILABLE = 1,
	DATA_FROM_CACHE,
	DATA_FROM_SOURCE,
	DATA_FROM_FACTORY
};

typedef struct{
	string caller_name;
	string caller_tag;
	string callee_name;
	string callee_tag;
	double start_time;
	double end_time;
	data_source_t data_source;
}call_stack_t;

typedef struct{
	const char* factory_name;
	string tag;
	const char* filename;
	int line;
}error_call_stack_t;

                                  JEventLoop(JApplication *app); ///< Constructor
					   virtual ~JEventLoop(); ////< Destructor
		   virtual const char* className(void){return static_className();}
			static const char* static_className(void){return "JEventLoop";}

				 JApplication* GetJApplication(void) const {return app;} ///< Get pointer to the JApplication object
                                void RefreshProcessorListFromJApplication(void); ///< Re-copy the list of JEventProcessors from JApplication
                    virtual jerror_t AddFactory(JFactory_base* factory); ///< Add a factory
					  jerror_t RemoveFactory(JFactory_base* factory); ///< Remove a factory
                      JFactory_base* GetFactory(const string data_name, const char *tag="", bool allow_deftag=true); ///< Get a specific factory pointer
              vector<JFactory_base*> GetFactories(void) const {return factories;} ///< Get all factory pointers
                                void GetFactoryNames(vector<string> &factorynames); ///< Get names of all factories in name:tag format
                                void GetFactoryNames(map<string,string> &factorynames); ///< Get names of all factories in map with key=name, value=tag
                  map<string,string> GetDefaultTags(void) const {return default_tags;}
                            jerror_t ClearFactories(void); ///< Reset all factories in preparation for next event.
					  jerror_t PrintFactories(int sparsify=0); ///< Print a list of all factories.
                            jerror_t Print(const string data_name, const char *tag=""); ///< Print the data of the given type

				 JCalibration* GetJCalibration();
              template<class T> bool GetCalib(string namepath, map<string,T> &vals);
              template<class T> bool GetCalib(string namepath, vector<T> &vals);
              template<class T> bool GetCalib(string namepath, T &val);

                          JGeometry* GetJGeometry();
              template<class T> bool GetGeom(string namepath, map<string,T> &vals);
	    template<class T> bool GetGeom(string namepath, T &val);

                   JResourceManager* GetJResourceManager(void);
                              string GetResource(string namepath);
              template<class T> bool GetResource(string namepath, T vals, int event_number=0);

                                void Initialize(void); ///< Do initializations just before event processing starts
                            jerror_t Loop(void); ///< Loop over events
                            jerror_t OneEvent(uint64_t event_number); ///< Process a specific single event (if source supports it)
                            jerror_t OneEvent(void); ///< Process a single event
                         inline void Pause(void){pause = 1;} ///< Pause event processing
                         inline void Resume(void){pause = 0;} ///< Resume event processing
                         inline void Quit(void){quit = 1;} ///< Clean up and exit the event loop
                         inline bool GetQuit(void) const {return quit;}
                                void QuitProgram(void);

                               // Support for random access of events
                          bool HasRandomAccess(void);
                          void AddToEventQueue(uint64_t event_number){ next_events_to_process.push_back(event_number); }
                          void AddToEventQueue(list<uint64_t> &event_numbers) { next_events_to_process.insert(next_events_to_process.end(), event_numbers.begin(), event_numbers.end()); }
                list<uint64_t> GetEventQueue(void){ return next_events_to_process; }
                          void ClearEventQueue(void){ next_events_to_process.clear(); }

      template<class T> JFactory<T>* GetSingle(const T* &t, const char *tag="", bool exception_if_not_one=true); ///< Get pointer to first data object from (source or factory).
      template<class T> JFactory<T>* Get(vector<const T*> &t, const char *tag="", bool allow_deftag=true); ///< Get data object pointers from (source or factory)
      template<class T> JFactory<T>* GetFromFactory(vector<const T*> &t, const char *tag="", data_source_t &data_source=null_data_source, bool allow_deftag=true); ///< Get data object pointers from factory
          template<class T> jerror_t GetFromSource(vector<const T*> &t, JFactory_base *factory=NULL__null); ///< Get data object pointers from source.
                      inline JEvent& GetJEvent(void){return event;} ///< Get pointer to the current JEvent object.
                         inline void SetJEvent(JEvent *event){this->event = *event;} ///< Set the JEvent pointer.
                         inline void SetAutoFree(int auto_free){this->auto_free = auto_free;} ///< Set the Auto-Free flag on/off
                    inline pthread_t GetPThreadID(void) const {return pthread_id;} ///< Get the pthread of the thread to which this JEventLoop belongs
                              double GetInstantaneousRate(void) const {return rate_instantaneous;} ///< Get the current event processing rate
                              double GetIntegratedRate(void) const {return rate_integrated;} ///< Get the current event processing rate
                              double GetLastEventProcessingTime(void) const {return delta_time_single;}
                        unsigned int GetNevents(void) const {return Nevents;}

                         inline bool CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB);

                         inline bool GetCallStackRecordingStatus(void){ return record_call_stack; }
                         inline void DisableCallStackRecording(void){ record_call_stack = false; }
                         inline void EnableCallStackRecording(void){ record_call_stack = true; }
                     inline void CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag);
                     inline void CallStackEnd(JEventLoop::call_stack_t &cs);
         inline vector<call_stack_t> GetCallStack(void){return call_stack;} ///< Get the current factory call stack
                         inline void AddToCallStack(call_stack_t &cs){if(record_call_stack) call_stack.push_back(cs);} ///< Add specified item to call stack record but only if record_call_stack is true
                         inline void AddToErrorCallStack(error_call_stack_t &cs){error_call_stack.push_back(cs);} ///< Add layer to the factory call stack
   inline vector<error_call_stack_t> GetErrorCallStack(void){return error_call_stack;} ///< Get the current factory error call stack
                                void PrintErrorCallStack(void); ///< Print the current factory call stack

                      const JObject* FindByID(JObject::oid_t id); ///< Find a data object by its identifier.
          template<class T> const T* FindByID(JObject::oid_t id); ///< Find a data object by its type and identifier
                      JFactory_base* FindOwner(const JObject *t); ///< Find the factory that owns a data object by pointer
                      JFactory_base* FindOwner(JObject::oid_t id); ///< Find a factory that owns a data object by identifier

                                     // User defined references
              template<class T> void SetRef(T *t);    ///< Add a user reference to this JEventLoop (must be a pointer)
                template<class T> T* GetRef(void);   ///< Get a user-defined reference of a specific type
        template<class T> vector<T*> GetRefsT(void); ///< Get all user-defined refrences of a specicif type
   vector<pair<const char*, void*> > GetRefs(void){ return user_refs; }  ///< Get copy of full list of user-defined references
              template<class T> void RemoveRef(T *t); ///< Remove user reference from list

							   // Convenience methods wrapping JEvent methods of same name
                      uint64_t GetStatus(void){return event.GetStatus();}
                          bool GetStatusBit(uint32_t bit){return event.GetStatusBit(bit);}
                          bool SetStatusBit(uint32_t bit, bool val=true){return event.SetStatusBit(bit, val);}
                          bool ClearStatusBit(uint32_t bit){return event.ClearStatusBit(bit);}
                          void ClearStatus(void){event.ClearStatus();}
                          void SetStatusBitDescription(uint32_t bit, string description){event.SetStatusBitDescription(bit, description);}
                        string GetStatusBitDescription(uint32_t bit){return event.GetStatusBitDescription(bit);}
                          void GetStatusBitDescriptions(map<uint32_t, string> &status_bit_descriptions){return event.GetStatusBitDescriptions(status_bit_descriptions);}
                              string StatusWordToString(void);

private:
JEvent event;
vector<JFactory_base*> factories;
vector<JEventProcessor*> processors;
vector<error_call_stack_t> error_call_stack;
vector<call_stack_t> call_stack;
JApplication *app;
JThread *jthread;
bool initialized;
bool print_parameters_called;
int pause;
int quit;
int auto_free;
pthread_t pthread_id;
map<string, string> default_tags;
vector<pair<string,string> > auto_activated_factories;
bool record_call_stack;
string caller_name;
string caller_tag;
vector<uint64_t> event_boundaries;
int32_t event_boundaries_run; ///< Run number boundaries were retrieved from (possbily 0)
list<uint64_t> next_events_to_process;

uint64_t Nevents;			      ///< Total events processed (this thread)
uint64_t Nevents_rate;		   ///< Num. events accumulated for "instantaneous" rate
double delta_time_single;		///< Time spent processing last event
double delta_time_rate;			///< Integrated time accumulated "instantaneous" rate (partial number of events)
double delta_time;				///< Total time spent processing events (this thread)
double rate_instantaneous;		///< Latest instantaneous rate
double rate_integrated;			///< Rate integrated over all events
 
static data_source_t null_data_source;

vector<pair<const char*, void*> > user_refs;
210};


213// The following is here just so we can use ROOT's THtml class to generate documentation.
214#ifdef G__DICTIONARY
215typedef JEventLoop::call_stack_t call_stack_t;
216typedef JEventLoop::error_call_stack_t error_call_stack_t;
217#endif

219#if !defined(__CINT__) && !defined(__CLING__)

221//-------------
222// GetSingle
223//-------------
224template<class T>
225JFactory<T>* JEventLoop::GetSingle(const T* &t, const char *tag, bool exception_if_not_one)
226{
/// This is a convenience method that can be used to get a pointer to the single
/// object of type T from the specified factory. It simply calls the Get(vector<...>) method
/// and copies the first pointer into "t" (or NULL if something other than 1 object is returned).
/// 
/// This is intended to address the common situation in which there is an interest
/// in the event if and only if there is exactly 1 object of type T. If the event
/// has no objects of that type or more than 1 object of that type (for the specified
/// factory) then an exception of type "unsigned long" is thrown with the value
/// being the number of objects of type T. You can supress the exception by setting
/// exception_if_not_one to false. In that case, you will have to check if t==NULL to
/// know if the call succeeded.
vector<const T*> v;
JFactory<T> *fac = Get(v, tag);

if(v.size()!=1){
t = NULL__null;
if(exception_if_not_one) throw v.size();
}

t = v[0];

return fac;
249}

251//-------------
252// Get
253//-------------
254template<class T> 
255JFactory<T>* JEventLoop::Get(vector<const T*> &t, const char *tag, bool allow_deftag)
256{
/// Retrieve or generate the array of objects of
/// type T for the curent event being processed
/// by this thread.
///
/// By default, preference is given to reading the
/// objects from the data source(e.g. file) before generating
/// them in the factory. A flag exists in the factory
/// however to change this so that the factory is
/// given preference.
///
/// Note that regardless of the setting of this flag,
/// the data are only either read in or generated once.
/// Ownership of the objects will always be with the
/// factory so subsequent calls will always return pointers to
/// the same data.
///
/// If the factory is called on to generate the data,
/// it is done by calling the factory's Get() method
/// which, in turn, calls the evnt() method. 
/// 
/// First, we just call the GetFromFactory() method.
/// It will make the initial decision as to whether
/// it should look in the source first or not. If
/// it returns NULL, then the factory couldn't be
/// found so we automatically try the file.
///
/// Note that if no factory exists to hold the objects
/// from the file, one can be created automatically
/// providing the <i>JANA:AUTOFACTORYCREATE</i>
/// configuration parameter is set.

// Check if a tag was specified for this data type to use for the
// default.
const char *mytag = tag3.1
'tag' is not equal to NULL
1
'tag' is not equal to NULL
1
'tag' is not equal to NULL
==NULL__null ? "":tag; // protection against NULL tags
4
←
'?' condition is false→
if(strlen(mytag)==0 && allow_deftag4.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
5
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(T::static_className());
if(iter!=default_tags.end())tag = iter->second.c_str();
6
←
Assuming the condition is true→
7
←
Taking true branch→
8
←
Value assigned to 'tag'→
}


// If we are trying to keep track of the call stack then we
// need to add a new call_stack_t object to the the list
// and initialize it with the start time and caller/callee
// info.
call_stack_t cs;

// Optionally record starting info of call stack entry
if(record_call_stack) CallStackStart(cs, caller_name, caller_tag, T::static_className(), tag);
9
←
Assuming field 'record_call_stack' is false→
10
←
Taking false branch→

// Get the data (or at least try to)
JFactory<T>* factory=NULL__null;
try{
factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
11
←
Passing value via 2nd parameter 'tag'→
12
←
Calling 'JEventLoop::GetFromFactory'→
if(!factory){
	// No factory exists for this type and tag. It's possible
	// that the source may be able to provide the objects
	// but it will need a place to put them. We can create a
	// dumb JFactory just to hold the data in case the source
	// can provide the objects. Before we do though, make sure
	// the user condones this via the presence of the
	// "JANA:AUTOFACTORYCREATE" config parameter.
	string p;
	try{
		gPARMS->GetParameter("JANA:AUTOFACTORYCREATE", p);
	}catch(...){}
	if(p.size()==0){
		jout<<std::endl;
		_DBG__std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<324<<std::endl;
		jout<<"No factory of type \""<<T::static_className()<<"\" with tag \""<<tag<<"\" exists."<<std::endl;
		jout<<"If you are reading objects from a file, I can auto-create a factory"<<std::endl;
		jout<<"of the appropriate type to hold the objects, but this feature is turned"<<std::endl;
		jout<<"off by default. To turn it on, set the \"JANA:AUTOFACTORYCREATE\""<<std::endl;
		jout<<"configuration parameter. This can usually be done by passing the"<<std::endl;
		jout<<"following argument to the program from the command line:"<<std::endl;
		jout<<std::endl;
		jout<<"   -PJANA:AUTOFACTORYCREATE=1"<<std::endl;
		jout<<std::endl;
		jout<<"Note that since the most commonly expected occurance of this situation."<<std::endl;
		jout<<"is an error, the program will now throw an exception so that the factory."<<std::endl;
		jout<<"call stack can be printed."<<std::endl;
		jout<<std::endl;
		throw exception();
	}else{
		AddFactory(new JFactory<T>(tag));
		jout<<__FILE__"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"<<":"<<__LINE__341<<" Auto-created "<<T::static_className()<<":"<<tag<<" factory"<<std::endl;
	
		// Now try once more. The GetFromFactory method will call
		// GetFromSource since it's empty.
		factory = GetFromFactory(t, tag, cs.data_source, allow_deftag);
	}
}
}catch(exception &e){
// Uh-oh, an exception was thrown. Add us to the call stack
// and re-throw the exception
error_call_stack_t ecs;
ecs.factory_name = T::static_className();
ecs.tag = tag;
ecs.filename = NULL__null;
error_call_stack.push_back(ecs);
throw e;
}

// If recording the call stack, update the end_time field and add to stack
if(record_call_stack) CallStackEnd(cs);

return factory;
363}

365//-------------
366// GetFromFactory
367//-------------
368template<class T> 
369JFactory<T>* JEventLoop::GetFromFactory(vector<const T*> &t, const char *tag, data_source_t &data_source, bool allow_deftag)
370{
// We need to find the factory providing data type T with
// tag given by "tag". 
vector<JFactory_base*>::iterator iter=factories.begin();
JFactory<T> *factory = NULL__null;
string className(T::static_className());

// Check if a tag was specified for this data type to use for the
// default.
const char *mytag = tag==NULL__null ? "":tag; // protection against NULL tags
13
←
Assuming 'tag' is equal to NULL→
14
←
'?' condition is true→
if(strlen(mytag)==0 && allow_deftag14.1
'allow_deftag' is true
1
'allow_deftag' is true
1
'allow_deftag' is true
){
15
←
Taking true branch→
map<string, string>::const_iterator iter = default_tags.find(className);
if(iter!=default_tags.end())tag = iter->second.c_str();
16
←
Assuming the condition is false→
17
←
Taking false branch→
}

for(; iter!=factories.end(); iter++){
18
←
Calling 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
21
←
Returning from 'operator!=<jana::JFactory_base **, std::vector<jana::JFactory_base *>>'→
22
←
Loop condition is true.  Entering loop body→
// It turns out a long standing bug in g++ makes dynamic_cast return
// zero improperly when used on objects created on one side of
// a dynamically shared object (DSO) and the cast occurs on the 
// other side. I saw bug reports ranging from 2001 to 2004. I saw
// saw it first-hand on LinuxEL4 using g++ 3.4.5. This is too bad
// since it is much more elegant (and safe) to use dynamic_cast.
// To avoid this problem which can occur with plugins, we check
// the name of the data classes are the same. (sigh)
//factory = dynamic_cast<JFactory<T> *>(*iter);
if(className == (*iter)->GetDataClassName())factory = (JFactory<T>*)(*iter);
23
←
Taking true branch→
if(factory == NULL__null)continue;
24
←
Assuming 'factory' is not equal to NULL→
25
←
Taking false branch→
const char *factag = factory->Tag()==NULL__null ? "":factory->Tag();
26
←
Assuming the condition is true→
27
←
'?' condition is true→
if(!strcmp(factag, tag)){
28
←
Null pointer passed to 2nd parameter expecting 'nonnull'
	break;
}else{
	factory=NULL__null;
}
}

// If factory not found, just return now
if(!factory){
data_source = DATA_NOT_AVAILABLE;
return NULL__null;
}

// OK, we found the factory. If the evnt() routine has already
// been called, then just call the factory's Get() routine
// to return a copy of the existing data
if(factory->evnt_was_called()){
factory->CopyFrom(t);
data_source = DATA_FROM_CACHE;
return factory;
}

// Next option is to get the objects from the data source
if(factory->GetCheckSourceFirst()){
// If the object type/tag is found in the source, it
// will return NOERROR, even if there are zero instances
// of it. If it is not available in the source then it
// will return OBJECT_NOT_AVAILABLE.

jerror_t err = GetFromSource(t, factory);
if(err == NOERROR){
	// A return value of NOERROR means the source had the objects
	// even if there were zero of them.(If the source had no
	// information about the objects OBJECT_NOT_AVAILABLE would 
	// have been returned.)
	// The GetFromSource() call will eventually lead to a call to
	// the GetObjects() method of the concrete class derived
	// from JEventSource. That routine should copy the object
	// pointers into the factory using the factory's CopyTo()
	// method which also sets the evnt_called flag for the factory.
	// Note also that the "t" vector is then filled with a call
	// to the factory's CopyFrom() method in JEvent::GetObjects().
	// All we need to do now is just set the factory pointers in
	// the newly generated JObjects and return the factory pointer.

	factory->SetFactoryPointers();
	data_source = DATA_FROM_SOURCE;

	return factory;
}
}

// OK. It looks like we have to have the factory make this.
// Get pointers to data from the factory.
factory->Get(t);
factory->SetFactoryPointers();
data_source = DATA_FROM_FACTORY;

return factory;
457}

459//-------------
460// GetFromSource
461//-------------
462template<class T> 
463jerror_t JEventLoop::GetFromSource(vector<const T*> &t, JFactory_base *factory)
464{
/// This tries to get objects from the event source.
/// "factory" must be a valid pointer to a JFactory
/// object since that will take ownership of the objects
/// created by the source.
/// This should usually be called from JEventLoop::GetFromFactory
/// which is called from JEventLoop::Get. The latter will
/// create a dummy JFactory of the proper flavor and tag if
/// one does not already exist so if objects exist in the
/// file without a corresponding factory to create them, they
/// can still be used.
if(!factory)throw OBJECT_NOT_AVAILABLE;

return event.GetObjects(t, factory);
478}

480//-------------
481// CallStackStart
482//-------------
483inline void JEventLoop::CallStackStart(JEventLoop::call_stack_t &cs, const string &caller_name, const string &caller_tag, const string callee_name, const string callee_tag)
484{
/// This is used to fill initial info into a call_stack_t stucture
/// for recording the call stack. It should be matched with a call
/// to CallStackEnd. It is normally called from the Get() method
/// above, but may also be used by external actors to manipulate
/// the call stack (presumably for good and not evil).

struct itimerval tmr;
getitimer(ITIMER_PROFITIMER_PROF, &tmr);

cs.caller_name    = this->caller_name;
cs.caller_tag     = this->caller_tag;
this->caller_name = cs.callee_name = callee_name;
this->caller_tag  = cs.callee_tag  = callee_tag;
cs.start_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
499}

501//-------------
502// CallStackEnd
503//-------------
504inline void JEventLoop::CallStackEnd(JEventLoop::call_stack_t &cs)
505{
/// Complete a call stack entry. This should be matched
/// with a previous call to CallStackStart which was
/// used to fill the cs structure.

struct itimerval tmr;
getitimer(ITIMER_PROFITIMER_PROF, &tmr);
cs.end_time = tmr.it_value.tv_sec + tmr.it_value.tv_usec/1.0E6;
caller_name = cs.caller_name;
caller_tag  = cs.caller_tag;
call_stack.push_back(cs);
516}

518//-------------
519// CheckEventBoundary
520//-------------
521inline bool JEventLoop::CheckEventBoundary(uint64_t event_numberA, uint64_t event_numberB)
522{
/// Check whether the two event numbers span one or more boundaries
/// in the calibration/conditions database for the current run number.
/// Return true if they do and false if they don't. The first parameter
/// "event_numberA" is also checked if it lands on a boundary in which
/// case true is also returned. If event_numberB lands on a boundary,
/// but event_numberA does not, then false is returned.
///
/// This method is not expected to be called by a user. It is, however called,
/// everytime a JFactory's Get() method is called.

// Make sure our copy of the boundaries is up to date
if(event.GetRunNumber()!=event_boundaries_run){
event_boundaries.clear(); // in case we can't get the JCalibration pointer
JCalibration *jcalib = GetJCalibration();
if(jcalib)jcalib->GetEventBoundaries(event_boundaries);
event_boundaries_run = event.GetRunNumber();
}

// Loop over boundaries
for(unsigned int i=0; i<event_boundaries.size(); i++){
uint64_t eb = event_boundaries[i];
if((eb - event_numberA)*(eb - event_numberB) < 0.0 || eb==event_numberA){ // think about it ....
	// events span a boundary or is on a boundary. Return true
	return true;
}
}

return false;
551}

553//-------------
554// FindByID
555//-------------
556template<class T> 
557const T* JEventLoop::FindByID(JObject::oid_t id)
558{
/// This is a templated method that can be used in place
/// of the non-templated FindByID(oid_t) method if one knows
/// the class of the object with the specified id.
/// This method is faster than calling the non-templated
/// FindByID and dynamic_cast-ing the JObject since
/// this will only search the objects of factories that
/// produce the desired data type.
/// This method will cast the JObject pointer to one
/// of the specified type. To use this method,
/// a type is specified in the call as follows:
///
/// const DMyType *t = loop->FindByID<DMyType>(id);

// Loop over factories looking for ones that provide
// specified data type.
for(unsigned int i=0; i<factories.size(); i++){
if(factories[i]->GetDataClassName() != T::static_className())continue;

// This factory provides data of type T. Search it for
// the object with the specified id.
const JObject *my_obj = factories[i]->GetByID(id);
if(my_obj)return dynamic_cast<const T*>(my_obj);
}

return NULL__null;
584}

586//-------------
587// GetCalib (map)
588//-------------
589template<class T>
590bool JEventLoop::GetCalib(string namepath, map<string,T> &vals)
591{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

// Note that we could do this by making "vals" a generic type T thus, combining
// this with the vector version below. However, doing this explicitly will make
// it easier for the user to understand how to call us.

vals.clear();

JCalibration *calib = GetJCalibration();
if(!calib){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<603<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return calib->Get(namepath, vals, event.GetEventNumber());
608}

610//-------------
611// GetCalib (vector)
612//-------------
613template<class T> bool JEventLoop::GetCalib(string namepath, vector<T> &vals)
614{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

vals.clear();

JCalibration *calib = GetJCalibration();
if(!calib){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<622<<" "<<"Unable to get JCalibration object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return calib->Get(namepath, vals, event.GetEventNumber());
627}

629//-------------
630// GetCalib (single)
631//-------------
632template<class T> bool JEventLoop::GetCalib(string namepath, T &val)
633{
/// This is a convenience method for getting a single entry. It
/// simply calls the vector version and returns the first entry.
/// It returns true if the vector version returns true AND there
/// is at least one entry in the vector. No check is made for there
/// there being more than one entry in the vector.

vector<T> vals;
bool ret = GetCalib(namepath, vals);
if(vals.empty()) return true;
val = vals[0];

return ret;
646}

648//-------------
649// GetGeom (map)
650//-------------
651template<class T>
652bool JEventLoop::GetGeom(string namepath, map<string,T> &vals)
653{
/// Get the JGeometry object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

// Note that we could do this by making "vals" a generic type T thus, combining
// this with the vector version below. However, doing this explicitly will make
// it easier for the user to understand how to call us.

vals.clear();

JGeometry *geom = GetJGeometry();
if(!geom){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<665<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return geom->Get(namepath, vals);
670}

672//-------------
673// GetGeom (atomic)
674//-------------
675template<class T> bool JEventLoop::GetGeom(string namepath, T &val)
676{
/// Get the JCalibration object from JApplication for the run number of
/// the current event and call its Get() method to get the constants.

JGeometry *geom = GetJGeometry();
if(!geom){
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<682<<" "<<"Unable to get JGeometry object for run "<<event.GetRunNumber()<<std::endl;
return true;
}

return geom->Get(namepath, val);
687}

689//-------------
690// SetRef
691//-------------
692template<class T>
693void JEventLoop::SetRef(T *t)
694{
pair<const char*, void*> p(typeid(T).name(), (void*)t);
user_refs.push_back(p);
697}

699//-------------
700// GetResource
701//-------------
702template<class T> bool JEventLoop::GetResource(string namepath, T vals, int event_number)
703{
JResourceManager *resource_manager = GetJResourceManager();
if(!resource_manager){
string mess = string("Unable to get the JResourceManager object (namepath=\"")+namepath+"\")";
throw JException(mess);
}

return resource_manager->Get(namepath, vals, event_number);
711}

713//-------------
714// GetRef
715//-------------
716template<class T>
717T* JEventLoop::GetRef(void)
718{
/// Get a user-defined reference (a pointer)
for(unsigned int i=0; i<user_refs.size(); i++){
if(user_refs[i].first == typeid(T).name()) return (T*)user_refs[i].second;
}

return NULL__null;
725}

727//-------------
728// GetRefsT
729//-------------
730template<class T>
731vector<T*> JEventLoop::GetRefsT(void)
732{
vector<T*> refs;
for(unsigned int i=0; i<user_refs.size(); i++){
if(user_refs[i].first == typeid(T).name()){
	refs.push_back((T*)user_refs[i].second);
}
}

return refs;
741}

743//-------------
744// RemoveRef
745//-------------
746template<class T>
747void JEventLoop::RemoveRef(T *t)
748{
vector<pair<const char*, void*> >::iterator iter;
for(iter=user_refs.begin(); iter!= user_refs.end(); iter++){
if(iter->second == (void*)t){
	user_refs.erase(iter);
	return;
}
}
_DBG_std::cerr<<"/w/halld-scifs17exp/halld2/home/sdobbs/Software/jana/jana_0.8.2/Linux_CentOS7.7-x86_64-gcc4.8.5/include/JANA/JEventLoop.h"
<<":"<<756<<" "<<" Attempt to remove user reference not in event loop!" << std::endl;
757}


760#endif //__CINT__  __CLING__

762} // Close JANA namespace



766#endif // _JEventLoop_


←

/usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../include/c++/4.8.5/bits/stl_iterator.h

1// Iterators -*- C++ -*-

3// Copyright (C) 2001-2013 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996-1998
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation.  Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose.  It is provided "as is" without express or implied warranty.
*/

51/** @file bits/stl_iterator.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{iterator}
*
*  This file implements reverse_iterator, back_insert_iterator,
*  front_insert_iterator, insert_iterator, __normal_iterator, and their
*  supporting functions and overloaded operators.
*/

60#ifndef _STL_ITERATOR_H1
61#define _STL_ITERATOR_H1 1

63#include <bits/cpp_type_traits.h>
64#include <ext/type_traits.h>
65#include <bits/move.h>

67namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
68{
69_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.1 Reverse iterators
/**
 *  Bidirectional and random access iterators have corresponding reverse
 *  %iterator adaptors that iterate through the data structure in the
 *  opposite direction.  They have the same signatures as the corresponding
 *  iterators.  The fundamental relation between a reverse %iterator and its
 *  corresponding %iterator @c i is established by the identity:
 *  @code
 *      &*(reverse_iterator(i)) == &*(i - 1)
 *  @endcode
 *
 *  <em>This mapping is dictated by the fact that while there is always a
 *  pointer past the end of an array, there might not be a valid pointer
 *  before the beginning of an array.</em> [24.4.1]/1,2
 *
 *  Reverse iterators can be tricky and surprising at first.  Their
 *  semantics make sense, however, and the trickiness is a side effect of
 *  the requirement that the iterators must be safe.
*/
template<typename _Iterator>
  class reverse_iterator
  : public iterator<typename iterator_traits<_Iterator>::iterator_category,
      typename iterator_traits<_Iterator>::value_type,
      typename iterator_traits<_Iterator>::difference_type,
      typename iterator_traits<_Iterator>::pointer,
                    typename iterator_traits<_Iterator>::reference>
  {
  protected:
    _Iterator current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::difference_type	difference_type;
    typedef typename __traits_type::pointer		pointer;
    typedef typename __traits_type::reference		reference;

    /**
     *  The default constructor value-initializes member @p current.
     *  If it is a pointer, that means it is zero-initialized.
    */
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 235 No specification of default ctor for reverse_iterator
    reverse_iterator() : current() { }

    /**
     *  This %iterator will move in the opposite direction that @p x does.
    */
    explicit
    reverse_iterator(iterator_type __x) : current(__x) { }

    /**
     *  The copy constructor is normal.
    */
    reverse_iterator(const reverse_iterator& __x)
    : current(__x.current) { }

    /**
     *  A %reverse_iterator across other types can be copied if the
     *  underlying %iterator can be converted to the type of @c current.
    */
    template<typename _Iter>
      reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) { }

    /**
     *  @return  @c current, the %iterator used for underlying work.
    */
    iterator_type
    base() const
    { return current; }

    /**
     *  @return  A reference to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
     *
     *  @warning This implementation requires that for an iterator of the
     *           underlying iterator type, @c x, a reference obtained by
     *           @c *x remains valid after @c x has been modified or
     *           destroyed. This is a bug: http://gcc.gnu.org/PR51823
    */
    reference
    operator*() const
    {
_Iterator __tmp = current;
return *--__tmp;
    }

    /**
     *  @return  A pointer to the value at @c --current
     *
     *  This requires that @c --current is dereferenceable.
    */
    pointer
    operator->() const
    { return &(operator*()); }

    /**
     *  @return  @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator&
    operator++()
    {
--current;
return *this;
    }

    /**
     *  @return  The original value of @c *this
     *
     *  Decrements the underlying iterator.
    */
    reverse_iterator
    operator++(int)
    {
reverse_iterator __tmp = *this;
--current;
return __tmp;
    }

    /**
     *  @return  @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator&
    operator--()
    {
++current;
return *this;
    }

    /**
     *  @return  A reverse_iterator with the previous value of @c *this
     *
     *  Increments the underlying iterator.
    */
    reverse_iterator
    operator--(int)
    {
reverse_iterator __tmp = *this;
++current;
return __tmp;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator+(difference_type __n) const
    { return reverse_iterator(current - __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator backwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator+=(difference_type __n)
    {
current -= __n;
return *this;
    }

    /**
     *  @return  A reverse_iterator that refers to @c current - @a __n
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator
    operator-(difference_type __n) const
    { return reverse_iterator(current + __n); }

    /**
     *  @return  *this
     *
     *  Moves the underlying iterator forwards @a __n steps.
     *  The underlying iterator must be a Random Access Iterator.
    */
    reverse_iterator&
    operator-=(difference_type __n)
    {
current += __n;
return *this;
    }

    /**
     *  @return  The value at @c current - @a __n - 1
     *
     *  The underlying iterator must be a Random Access Iterator.
    */
    reference
    operator[](difference_type __n) const
    { return *(*this + __n); }
  };

//@{
/**
 *  @param  __x  A %reverse_iterator.
 *  @param  __y  A %reverse_iterator.
 *  @return  A simple bool.
 *
 *  Reverse iterators forward many operations to their underlying base()
 *  iterators.  Others are implemented in terms of one another.
 *
*/
template<typename _Iterator>
  inline bool
  operator==(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() < __x.base(); }

template<typename _Iterator>
  inline bool
  operator!=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator>(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator<=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator>=(const reverse_iterator<_Iterator>& __x,
      const reverse_iterator<_Iterator>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline typename reverse_iterator<_Iterator>::difference_type
  operator-(const reverse_iterator<_Iterator>& __x,
     const reverse_iterator<_Iterator>& __y)
  { return __y.base() - __x.base(); }

template<typename _Iterator>
  inline reverse_iterator<_Iterator>
  operator+(typename reverse_iterator<_Iterator>::difference_type __n,
     const reverse_iterator<_Iterator>& __x)
  { return reverse_iterator<_Iterator>(__x.base() - __n); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 280. Comparison of reverse_iterator to const reverse_iterator.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const reverse_iterator<_IteratorL>& __x,
      const reverse_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _IteratorL, typename _IteratorR>
376#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
  -> decltype(__y.base() - __x.base())
382#else
  inline typename reverse_iterator<_IteratorL>::difference_type
  operator-(const reverse_iterator<_IteratorL>& __x,
     const reverse_iterator<_IteratorR>& __y)
386#endif
  { return __y.base() - __x.base(); }
//@}

// 24.4.2.2.1 back_insert_iterator
/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator appends it to the container using
 *  push_back.
 *
 *  Tip:  Using the back_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class back_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit
    back_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the end, if you like).  Assigning a value to the %iterator will
     *  always append the value to the end of the container.
    */
427#if __cplusplus201103L < 201103L
    back_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_back(__value);
return *this;
    }
434#else
    back_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_back(__value);
return *this;
    }

    back_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_back(std::move(__value));
return *this;
    }
448#endif

    /// Simply returns *this.
    back_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    back_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of back_insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating back_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline back_insert_iterator<_Container>
  back_inserter(_Container& __x)
  { return back_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator prepends it to the container using
 *  push_front.
 *
 *  Tip:  Using the front_inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class front_insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /// The only way to create this %iterator is with a container.
    explicit front_insert_iterator(_Container& __x) : container(&__x) { }

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator doesn't really have a @a position in the
     *  container (you can think of the position as being permanently at
     *  the front, if you like).  Assigning a value to the %iterator will
     *  always prepend the value to the front of the container.
    */
517#if __cplusplus201103L < 201103L
    front_insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
container->push_front(__value);
return *this;
    }
524#else
    front_insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
container->push_front(__value);
return *this;
    }

    front_insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
container->push_front(std::move(__value));
return *this;
    }
538#endif

    /// Simply returns *this.
    front_insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    front_insert_iterator
    operator++(int)
    { return *this; }
  };

/**
 *  @param  __x  A container of arbitrary type.
 *  @return  An instance of front_insert_iterator working on @p x.
 *
 *  This wrapper function helps in creating front_insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container>
  inline front_insert_iterator<_Container>
  front_inserter(_Container& __x)
  { return front_insert_iterator<_Container>(__x); }

/**
 *  @brief  Turns assignment into insertion.
 *
 *  These are output iterators, constructed from a container-of-T.
 *  Assigning a T to the iterator inserts it in the container at the
 *  %iterator's position, rather than overwriting the value at that
 *  position.
 *
 *  (Sequences will actually insert a @e copy of the value before the
 *  %iterator's position.)
 *
 *  Tip:  Using the inserter function to create these iterators can
 *  save typing.
*/
template<typename _Container>
  class insert_iterator
  : public iterator<output_iterator_tag, void, void, void, void>
  {
  protected:
    _Container* container;
    typename _Container::iterator iter;

  public:
    /// A nested typedef for the type of whatever container you used.
    typedef _Container          container_type;

    /**
     *  The only way to create this %iterator is with a container and an
     *  initial position (a normal %iterator into the container).
    */
    insert_iterator(_Container& __x, typename _Container::iterator __i)
    : container(&__x), iter(__i) {}

    /**
     *  @param  __value  An instance of whatever type
     *                 container_type::const_reference is; presumably a
     *                 reference-to-const T for container<T>.
     *  @return  This %iterator, for chained operations.
     *
     *  This kind of %iterator maintains its own position in the
     *  container.  Assigning a value to the %iterator will insert the
     *  value into the container at the place before the %iterator.
     *
     *  The position is maintained such that subsequent assignments will
     *  insert values immediately after one another.  For example,
     *  @code
     *     // vector v contains A and Z
     *
     *     insert_iterator i (v, ++v.begin());
     *     i = 1;
     *     i = 2;
     *     i = 3;
     *
     *     // vector v contains A, 1, 2, 3, and Z
     *  @endcode
    */
628#if __cplusplus201103L < 201103L
    insert_iterator&
    operator=(typename _Container::const_reference __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }
636#else
    insert_iterator&
    operator=(const typename _Container::value_type& __value)
    {
iter = container->insert(iter, __value);
++iter;
return *this;
    }

    insert_iterator&
    operator=(typename _Container::value_type&& __value)
    {
iter = container->insert(iter, std::move(__value));
++iter;
return *this;
    }
652#endif

    /// Simply returns *this.
    insert_iterator&
    operator*()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++()
    { return *this; }

    /// Simply returns *this.  (This %iterator does not @a move.)
    insert_iterator&
    operator++(int)
    { return *this; }
  };

/**
 *  @param __x  A container of arbitrary type.
 *  @return  An instance of insert_iterator working on @p __x.
 *
 *  This wrapper function helps in creating insert_iterator instances.
 *  Typing the name of the %iterator requires knowing the precise full
 *  type of the container, which can be tedious and impedes generic
 *  programming.  Using this function lets you take advantage of automatic
 *  template parameter deduction, making the compiler match the correct
 *  types for you.
*/
template<typename _Container, typename _Iterator>
  inline insert_iterator<_Container>
  inserter(_Container& __x, _Iterator __i)
  {
    return insert_iterator<_Container>(__x,
			 typename _Container::iterator(__i));
  }

// @} group iterators

691_GLIBCXX_END_NAMESPACE_VERSION
692} // namespace

694namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
695{
696_GLIBCXX_BEGIN_NAMESPACE_VERSION

// This iterator adapter is @a normal in the sense that it does not
// change the semantics of any of the operators of its iterator
// parameter.  Its primary purpose is to convert an iterator that is
// not a class, e.g. a pointer, into an iterator that is a class.
// The _Container parameter exists solely so that different containers
// using this template can instantiate different types, even if the
// _Iterator parameter is the same.
using std::iterator_traits;
using std::iterator;
template<typename _Iterator, typename _Container>
  class __normal_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type 	difference_type;
    typedef typename __traits_type::reference 	reference;
    typedef typename __traits_type::pointer   	pointer;

    _GLIBCXX_CONSTEXPRconstexpr __normal_iterator() : _M_current(_Iterator()) { }

    explicit
    __normal_iterator(const _Iterator& __i) : _M_current(__i) { }

    // Allow iterator to const_iterator conversion
    template<typename _Iter>
      __normal_iterator(const __normal_iterator<_Iter,
	  typename __enable_if<
    	       (std::__are_same<_Iter, typename _Container::pointer>::__value),
      _Container>::__type>& __i)
      : _M_current(__i.base()) { }

    // Forward iterator requirements
    reference
    operator*() const
    { return *_M_current; }

    pointer
    operator->() const
    { return _M_current; }

    __normal_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    __normal_iterator
    operator++(int)
    { return __normal_iterator(_M_current++); }

    // Bidirectional iterator requirements
    __normal_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    __normal_iterator
    operator--(int)
    { return __normal_iterator(_M_current--); }

    // Random access iterator requirements
    reference
    operator[](const difference_type& __n) const
    { return _M_current[__n]; }

    __normal_iterator&
    operator+=(const difference_type& __n)
    { _M_current += __n; return *this; }

    __normal_iterator
    operator+(const difference_type& __n) const
    { return __normal_iterator(_M_current + __n); }

    __normal_iterator&
    operator-=(const difference_type& __n)
    { _M_current -= __n; return *this; }

    __normal_iterator
    operator-(const difference_type& __n) const
    { return __normal_iterator(_M_current - __n); }

    const _Iterator&
    base() const
    { return _M_current; }
  };

// Note: In what follows, the left- and right-hand-side iterators are
// allowed to vary in types (conceptually in cv-qualification) so that
// comparison between cv-qualified and non-cv-qualified iterators be
// valid.  However, the greedy and unfriendly operators in std::rel_ops
// will make overload resolution ambiguous (when in scope) if we don't
// provide overloads whose operands are of the same type.  Can someone
// remind me what generic programming is about? -- Gaby

// Forward iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() != __rhs.base(); }
19
←
Assuming the condition is true→
20
←
Returning the value 1, which participates in a condition later→

// Random access iterator requirements
template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
      const __normal_iterator<_IteratorR, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline bool
  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
      const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() >= __rhs.base(); }

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// According to the resolution of DR179 not only the various comparison
// operators but also operator- must accept mixed iterator/const_iterator
// parameters.
template<typename _IteratorL, typename _IteratorR, typename _Container>
881#if __cplusplus201103L >= 201103L
  // DR 685.
  inline auto
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
  -> decltype(__lhs.base() - __rhs.base())
887#else
  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
     const __normal_iterator<_IteratorR, _Container>& __rhs)
891#endif
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline typename __normal_iterator<_Iterator, _Container>::difference_type
  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
     const __normal_iterator<_Iterator, _Container>& __rhs)
  { return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container>
  inline __normal_iterator<_Iterator, _Container>
  operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
     __n, const __normal_iterator<_Iterator, _Container>& __i)
  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

906_GLIBCXX_END_NAMESPACE_VERSION
907} // namespace

909#if __cplusplus201103L >= 201103L

911namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
912{
913_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup iterators
 * @{
 */

// 24.4.3  Move iterators
/**
 *  Class template move_iterator is an iterator adapter with the same
 *  behavior as the underlying iterator except that its dereference
 *  operator implicitly converts the value returned by the underlying
 *  iterator's dereference operator to an rvalue reference.  Some
 *  generic algorithms can be called with move iterators to replace
 *  copying with moving.
 */
template<typename _Iterator>
  class move_iterator
  {
  protected:
    _Iterator _M_current;

    typedef iterator_traits<_Iterator>		__traits_type;

  public:
    typedef _Iterator					iterator_type;
    typedef typename __traits_type::iterator_category iterator_category;
    typedef typename __traits_type::value_type  	value_type;
    typedef typename __traits_type::difference_type	difference_type;
    // NB: DR 680.
    typedef _Iterator					pointer;
    typedef value_type&&				reference;

    move_iterator()
    : _M_current() { }

    explicit
    move_iterator(iterator_type __i)
    : _M_current(__i) { }

    template<typename _Iter>
move_iterator(const move_iterator<_Iter>& __i)
: _M_current(__i.base()) { }

    iterator_type
    base() const
    { return _M_current; }

    reference
    operator*() const
    { return std::move(*_M_current); }

    pointer
    operator->() const
    { return _M_current; }

    move_iterator&
    operator++()
    {
++_M_current;
return *this;
    }

    move_iterator
    operator++(int)
    {
move_iterator __tmp = *this;
++_M_current;
return __tmp;
    }

    move_iterator&
    operator--()
    {
--_M_current;
return *this;
    }

    move_iterator
    operator--(int)
    {
move_iterator __tmp = *this;
--_M_current;
return __tmp;
    }

    move_iterator
    operator+(difference_type __n) const
    { return move_iterator(_M_current + __n); }

    move_iterator&
    operator+=(difference_type __n)
    {
_M_current += __n;
return *this;
    }

    move_iterator
    operator-(difference_type __n) const
    { return move_iterator(_M_current - __n); }
  
    move_iterator&
    operator-=(difference_type __n)
    { 
_M_current -= __n;
return *this;
    }

    reference
    operator[](difference_type __n) const
    { return std::move(_M_current[__n]); }
  };

// Note: See __normal_iterator operators note from Gaby to understand
// why there are always 2 versions for most of the move_iterator
// operators.
template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator==(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return __x.base() == __y.base(); }

template<typename _Iterator>
  inline bool
  operator==(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return __x.base() == __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator!=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x == __y); }

template<typename _Iterator>
  inline bool
  operator!=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __x.base() < __y.base(); }

template<typename _Iterator>
  inline bool
  operator<(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __x.base() < __y.base(); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator<=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__y < __x); }

template<typename _Iterator>
  inline bool
  operator<=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  { return __y < __x; }

template<typename _Iterator>
  inline bool
  operator>(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  { return __y < __x; }

template<typename _IteratorL, typename _IteratorR>
  inline bool
  operator>=(const move_iterator<_IteratorL>& __x,
      const move_iterator<_IteratorR>& __y)
  { return !(__x < __y); }

template<typename _Iterator>
  inline bool
  operator>=(const move_iterator<_Iterator>& __x,
      const move_iterator<_Iterator>& __y)
  { return !(__x < __y); }

// DR 685.
template<typename _IteratorL, typename _IteratorR>
  inline auto
  operator-(const move_iterator<_IteratorL>& __x,
     const move_iterator<_IteratorR>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline auto
  operator-(const move_iterator<_Iterator>& __x,
     const move_iterator<_Iterator>& __y)
  -> decltype(__x.base() - __y.base())
  { return __x.base() - __y.base(); }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  operator+(typename move_iterator<_Iterator>::difference_type __n,
     const move_iterator<_Iterator>& __x)
  { return __x + __n; }

template<typename _Iterator>
  inline move_iterator<_Iterator>
  make_move_iterator(_Iterator __i)
  { return move_iterator<_Iterator>(__i); }

template<typename _Iterator, typename _ReturnType
  = typename conditional<__move_if_noexcept_cond
    <typename iterator_traits<_Iterator>::value_type>::value,
              _Iterator, move_iterator<_Iterator>>::type>
  inline _ReturnType
  __make_move_if_noexcept_iterator(_Iterator __i)
  { return _ReturnType(__i); }

// @} group iterators

1137_GLIBCXX_END_NAMESPACE_VERSION
1138} // namespace

1140#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) std::make_move_iterator(_Iter)
1141#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
1143#else
1144#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter)std::make_move_iterator(_Iter) (_Iter)
1145#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter)std::__make_move_if_noexcept_iterator(_Iter) (_Iter)
1146#endif // C++11

1148#endif