CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Attributes
edmtest::OtherThingAnalyzer Class Reference
Inheritance diagram for edmtest::OtherThingAnalyzer:
edm::stream::EDAnalyzer<> edm::stream::EDAnalyzerBase edm::EDConsumerBase

Public Member Functions

void analyze (edm::Event const &e, edm::EventSetup const &c) override
 
void doit (edm::Event const &event, std::string const &label)
 
 OtherThingAnalyzer (edm::ParameterSet const &pset)
 
- Public Member Functions inherited from edm::stream::EDAnalyzer<>
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzer ()=default
 
 EDAnalyzer (const EDAnalyzer &)=delete
 
const EDAnalyzer & operator= (const EDAnalyzer &)=delete
 
- Public Member Functions inherited from edm::stream::EDAnalyzerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzerBase ()
 
 EDAnalyzerBase (const EDAnalyzerBase &)=delete
 
ModuleDescription const & moduleDescription () const
 
const EDAnalyzerBase & operator= (const EDAnalyzerBase &)=delete
 
 ~EDAnalyzerBase () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ESResolverIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
std::vector< ESResolverIndex > const & esGetTokenIndicesVector (edm::Transition iTrans) const
 
std::vector< ESRecordIndex > const & esGetTokenRecordIndicesVector (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
void selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
- Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 

Private Attributes

edm::InputTag otherTag_
 
bool thingWasDropped_
 

Additional Inherited Members

- Public Types inherited from edm::stream::EDAnalyzer<>
using CacheTypes = CacheContexts< T... >
 
using GlobalCache = typename CacheTypes::GlobalCache
 
using HasAbility = AbilityChecker< T... >
 
using InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
 
using LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
 
using LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
 
using LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
 
using RunCache = typename CacheTypes::RunCache
 
using RunContext = RunContextT< RunCache, GlobalCache >
 
using RunSummaryCache = typename CacheTypes::RunSummaryCache
 
- Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B > consumes (edm::InputTag tag) noexcept
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<Transition Tr = Transition::Event>
constexpr auto esConsumes ()
 
template<Transition Tr = Transition::Event>
auto esConsumes (ESInputTag tag)
 
template<Transition Tr = Transition::Event>
ESGetTokenGeneric esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
 Used with EventSetupRecord::doGet. More...
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
void resetItemsToGetFrom (BranchType iType)
 

Detailed Description

Definition at line 15 of file OtherThingAnalyzer.cc.

Constructor & Destructor Documentation

◆ OtherThingAnalyzer()

edmtest::OtherThingAnalyzer::OtherThingAnalyzer ( edm::ParameterSet const &  pset)
explicit

Definition at line 30 of file OtherThingAnalyzer.cc.

References otherTag_.

31  : thingWasDropped_(pset.getUntrackedParameter<bool>("thingWasDropped")),
32  otherTag_(pset.getUntrackedParameter<edm::InputTag>("other")) {
33  consumes<OtherThingCollection>(otherTag_);
34  }
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27

Member Function Documentation

◆ analyze()

void edmtest::OtherThingAnalyzer::analyze ( edm::Event const &  e,
edm::EventSetup const &  c 
)
overridevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 36 of file OtherThingAnalyzer.cc.

References doit(), MillePedeFileConverter_cfg::e, and AlCaHLTBitMon_QueryRunRegistry::string.

36 { doit(e, std::string("testUserTag")); }
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edmtest::OtherThingAnalyzer::doit
void doit(edm::Event const &event, std::string const &label)
Definition: OtherThingAnalyzer.cc:38

◆ doit()

void edmtest::OtherThingAnalyzer::doit ( edm::Event const &  event,
std::string const &  label 
)

Definition at line 38 of file OtherThingAnalyzer.cc.

References cms::cuda::assert(), Exception, edm::Event::getByLabel(), mps_fire::i, label, otherTag_, edm::View< T >::size(), thingWasDropped_, x, protons_cff::xi, and SiPixelPI::zero.

Referenced by analyze().

38  {
39  edm::Handle<OtherThingCollection> otherThings;
40  dv.getByLabel(otherTag_, otherThings);
41  edm::LogInfo("OtherThingAnalyzer") << " --------------- next event ------------ \n";
42  int i = 0;
43  for (OtherThingCollection::const_iterator it = otherThings->begin(), itEnd = otherThings->end(); it != itEnd;
44  ++it, ++i) {
45  OtherThing const& otherThing = *it;
46 
47  if (otherThing.oneNullOneNot.size() != 2) {
48  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
49  << " oneNullOneNot has wrong length: " << otherThing.oneNullOneNot.size() << " should be 2\n";
50  }
51  if (otherThing.oneNullOneNot[0].isNonnull()) {
52  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << " expected null Ref is not null\n";
53  }
54  if (otherThing.oneNullOneNot[1].isNull()) {
55  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << " expected non-null Ref is null\n";
56  }
57 
58  bool shouldBeTrue = otherThing.refVec[0] != otherThing.refVec[1];
59  if (!shouldBeTrue) {
60  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "Inequality has incorrect value\n";
61  }
62  shouldBeTrue = otherThing.refVec[0] == otherThing.refVec[0];
63  if (!shouldBeTrue) {
64  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "Equality has incorrect value\n";
65  }
66  shouldBeTrue = otherThing.refProd == otherThing.refProd;
67  if (!shouldBeTrue) {
68  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
69  << "RefProd Equality has incorrect value\n";
70  }
71  shouldBeTrue = otherThing.refVec[0].isNonnull();
72  if (!shouldBeTrue) {
73  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
74  << "Non-null check has incorrect value\n";
75  }
76  shouldBeTrue = otherThing.refProd.isNonnull();
77  if (!shouldBeTrue) {
78  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
79  << "RefProd non-null check has incorrect value\n";
80  }
81  shouldBeTrue = !(!otherThing.refVec[0]);
82  if (!shouldBeTrue) {
83  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "'!' has incorrect value\n";
84  }
85  shouldBeTrue = !(!otherThing.refProd);
86  if (!shouldBeTrue) {
87  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "RefProd '!' has incorrect value\n";
88  }
89  shouldBeTrue = !otherThing.refVec.empty();
90  if (!shouldBeTrue) {
91  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "empty() has incorrect value\n";
92  }
93  shouldBeTrue = (otherThing.refVec == otherThing.refVec);
94  if (!shouldBeTrue) {
95  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
96  << "RefVector equality has incorrect value\n";
97  }
98  shouldBeTrue = !(otherThing.refVec != otherThing.refVec);
99  if (!shouldBeTrue) {
100  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
101  << "RefVector inequality has incorrect value\n";
102  }
103  assert(otherThing.refProd.isAvailable() != thingWasDropped_);
104  assert(otherThing.ref.isAvailable() != thingWasDropped_);
105  assert(otherThing.refVec.isAvailable() != thingWasDropped_);
106 
107  if (otherThing.ptrOneNullOneNot.size() != 2) {
108  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
109  << " ptrOneNullOneNot has wrong length: " << otherThing.ptrOneNullOneNot.size() << " should be 2\n";
110  }
111  if (otherThing.ptrOneNullOneNot[0].isNonnull()) {
112  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << " expected null Ptr is not null\n";
113  }
114  if (otherThing.ptrOneNullOneNot[1].isNull()) {
115  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << " expected non-null Ptr is null\n";
116  }
117 
118  shouldBeTrue = otherThing.ptrVec[0] != otherThing.ptrVec[1];
119  if (!shouldBeTrue) {
120  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "Inequality has incorrect value\n";
121  }
122  shouldBeTrue = otherThing.ptrVec[0] == otherThing.ptrVec[0];
123  if (!shouldBeTrue) {
124  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "Equality has incorrect value\n";
125  }
126  shouldBeTrue = otherThing.ptrVec[0].isNonnull();
127  if (!shouldBeTrue) {
128  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
129  << "Non-null check has incorrect value\n";
130  }
131  shouldBeTrue = !(!otherThing.ptrVec[0]);
132  if (!shouldBeTrue) {
133  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "'!' has incorrect value\n";
134  }
135  shouldBeTrue = !otherThing.ptrVec.empty();
136  if (!shouldBeTrue) {
137  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "empty() has incorrect value\n";
138  }
139  shouldBeTrue = (otherThing.ptrVec == otherThing.ptrVec);
140  if (!shouldBeTrue) {
141  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
142  << "PtrVector equality has incorrect value\n";
143  }
144  assert(otherThing.ptr.isAvailable() != thingWasDropped_);
145  assert(otherThing.ptrVec.isAvailable() != thingWasDropped_);
146 
147  if (thingWasDropped_)
148  return;
149  {
150  ThingCollection const& tcoll = *otherThing.refProd;
151  ThingCollection::size_type size1 = tcoll.size();
152  ThingCollection::size_type size2 = otherThing.refProd->size();
153  if (size1 == 0 || size1 != size2) {
154  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
155  << " RefProd size mismatch " << std::endl;
156  }
157 
158  Thing const& tc = *otherThing.ref;
159  int const& x = otherThing.ref->a;
160  if (tc.a == i && x == i) {
161  edm::LogInfo("OtherThingAnalyzer")
162  << " ITEM " << i << " LABEL " << label << " dereferenced from edm::Ref successfully.\n";
163  } else {
164  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
165  << "ITEM " << i << " has incorrect edm::Ref value " << tc.a << '\n';
166  }
167 
168  edm::View<Thing> const& viewThing = *otherThing.refToBaseProd;
169  edm::View<Thing>::size_type const viewSize1 = viewThing.size();
170  edm::View<Thing>::size_type const viewSize2 = otherThing.refToBaseProd->size();
171  if (viewSize1 == 0 || viewSize2 != viewSize1) {
172  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
173  << " RefToBaseProd size mismatch " << std::endl;
174  }
175  if (viewSize1 != size1) {
176  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
177  << " RefToBaseProd size mismatch to RefProd size" << std::endl;
178  }
179  edm::Ref<ThingCollection> refFromCast = otherThing.refToBase.castTo<edm::Ref<ThingCollection> >();
180  edm::Ptr<Thing> ptrFromCast = otherThing.refToBase.castTo<edm::Ptr<Thing> >();
181  Thing const& tcBase = *otherThing.refToBase;
182  if (tcBase.a != refFromCast->a) {
183  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
184  << " Ref from RefToBase::castTo has incorrect value " << '\n';
185  }
186  if (tcBase.a != ptrFromCast->a) {
187  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
188  << " Ptr from RefToBase::castTo has incorrect value " << '\n';
189  }
190  int const& xBase = otherThing.refToBase->a;
191  if (tcBase.a == i && xBase == i) {
192  edm::LogInfo("OtherThingAnalyzer")
193  << " ITEM " << i << " LABEL " << label << " RefToBase dereferenced successfully.\n";
194  } else {
195  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
196  << "ITEM " << i << " RefToBase has incorrect value " << tc.a << '\n';
197  }
198 
199  Thing const& tcv = *otherThing.refVec[0];
200  int const& xv = otherThing.refVec[0]->a;
201  if (xv != tcv.a || xv != i) {
202  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
203  << "VECTOR ITEM 0 " << i << " has incorrect value " << tcv.a << '\n';
204  }
205  Thing const& tcv1 = *otherThing.refVec[1];
206  int const& xv1 = otherThing.refVec[1]->a;
207  if (xv1 != tcv1.a || xv1 != 19 - i) {
208  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
209  << "VECTOR ITEM 1 " << i << " has incorrect value " << tcv1.a << '\n';
210  }
211  for (edm::RefVector<ThingCollection>::iterator iterRefVector = otherThing.refVec.begin(),
212  iterRefVectorEnd = otherThing.refVec.end();
213  iterRefVector != iterRefVectorEnd;
214  ++iterRefVector) {
215  edm::Ref<ThingCollection> tcol = *iterRefVector;
216  Thing const& ti = **iterRefVector;
217  int const& xi = (*iterRefVector)->a;
218  if (xi != ti.a) {
219  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
220  << "iterator item " << ti.a << " " << xi << '\n';
221  } else if (iterRefVector == otherThing.refVec.begin() && xi != i) {
222  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "iterator item 0" << xi << '\n';
223  } else if (iterRefVector != otherThing.refVec.begin() && xi != 19 - i) {
224  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "iterator item 1" << xi << '\n';
225  }
226  }
227  edm::RefVector<ThingCollection>::iterator it0 = otherThing.refVec.begin();
228  int zero = (*it0)->a;
229  edm::RefVector<ThingCollection>::iterator it1 = it0 + 1;
230  int one = (*it1)->a;
231  it1 = 1 + it0;
232  int x1 = (*it1)->a;
233  if (x1 != one)
234  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
235  << "operator+ iterator error: " << x1 << " " << one << '\n';
236  it0 = it1 - 1;
237  int x0 = (*it0)->a;
238  if (x0 != zero)
239  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
240  << "operator- iterator error: " << x0 << " " << zero << '\n';
241  x0 = (*(it0++))->a;
242  if (x0 != zero)
243  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
244  << "operator++ iterator error: " << x0 << " " << zero << '\n';
245  x1 = (*it0)->a;
246  if (x1 != one)
247  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
248  << "operator++ iterator error 2: " << x1 << " " << one << '\n';
249  x1 = (*(it0--))->a;
250  if (x1 != one)
251  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
252  << "operator-- iterator error: " << x1 << " " << one << '\n';
253  x0 = (*it0)->a;
254  if (x0 != zero)
255  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
256  << "operator-- iterator error 2: " << x0 << " " << zero << '\n';
257  x1 = it0[1]->a;
258  if (x1 != one)
259  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
260  << "operator[] iterator error: " << x1 << " " << one << '\n';
261  x1 = it1[0]->a;
262  if (x1 != one)
263  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
264  << "operator[] iterator error 2: " << x1 << " " << one << '\n';
265  }
266  {
267  Thing const& tc = *otherThing.ptr;
268  int const& x = otherThing.ptr->a;
269  if (tc.a == i && x == i) {
270  edm::LogInfo("OtherThingAnalyzer")
271  << " ITEM " << i << " LABEL " << label << " dereferenced from edm::Ptr successfully.\n";
272  } else {
273  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
274  << "ITEM " << i << " has incorrect edm::Ptr value " << tc.a << '\n';
275  }
276 
277  Thing const& tcv = *otherThing.ptrVec[0];
278  int const& xv = otherThing.ptrVec[0]->a;
279  if (xv != tcv.a || xv != i) {
280  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
281  << "VECTOR ITEM 0 " << i << " has incorrect value " << tcv.a << '\n';
282  }
283  Thing const& tcv1 = *otherThing.ptrVec[1];
284  int const& xv1 = otherThing.ptrVec[1]->a;
285  if (xv1 != tcv1.a || xv1 != 19 - i) {
286  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
287  << "VECTOR ITEM 1 " << i << " has incorrect value " << tcv1.a << '\n';
288  }
289  for (edm::PtrVector<Thing>::const_iterator iterPtrVec = otherThing.ptrVec.begin(),
290  iterPtrVecEnd = otherThing.ptrVec.end();
291  iterPtrVec != iterPtrVecEnd;
292  ++iterPtrVec) {
293  edm::Ptr<Thing> tcol = *iterPtrVec;
294  Thing const& ti = **iterPtrVec;
295  int const& xi = (*iterPtrVec)->a;
296  if (xi != ti.a) {
297  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
298  << "iterator item " << ti.a << " " << xi << '\n';
299  } else if (iterPtrVec == otherThing.ptrVec.begin() && xi != i) {
300  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "iterator item 0" << xi << '\n';
301  } else if (iterPtrVec != otherThing.ptrVec.begin() && xi != 19 - i) {
302  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze") << "iterator item 1" << xi << '\n';
303  }
304  }
305  edm::PtrVector<Thing>::const_iterator it0 = otherThing.ptrVec.begin();
306  int zero = (*it0)->a;
307  edm::PtrVector<Thing>::const_iterator it1 = it0 + 1;
308  int one = (*it1)->a;
309  it1 = it0 + 1;
310  int x1 = (*it1)->a;
311  if (x1 != one)
312  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
313  << "operator+ iterator error: " << x1 << " " << one << '\n';
314  it0 = it1 - 1;
315  int x0 = (*it0)->a;
316  if (x0 != zero)
317  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
318  << "operator- iterator error: " << x0 << " " << zero << '\n';
319  x0 = (*(it0++))->a;
320  if (x0 != zero)
321  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
322  << "operator++ iterator error: " << x0 << " " << zero << '\n';
323  x1 = (*it0)->a;
324  if (x1 != one)
325  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
326  << "operator++ iterator error 2: " << x1 << " " << one << '\n';
327  x1 = (*(it0--))->a;
328  if (x1 != one)
329  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
330  << "operator-- iterator error: " << x1 << " " << one << '\n';
331  x0 = (*it0)->a;
332  if (x0 != zero)
333  throw cms::Exception("Inconsistent Data", "OtherThingAnalyzer::analyze")
334  << "operator-- iterator error 2: " << x0 << " " << zero << '\n';
335  }
336  }
337  }
edm::View::size_type
unsigned int size_type
Definition: View.h:90
mps_fire.i
i
Definition: mps_fire.py:429
protons_cff.xi
xi
Definition: protons_cff.py:21
cms::cuda::assert
assert(be >=bs)
trigger::size_type
uint16_t size_type
Definition: TriggerTypeDefs.h:18
edm::View::size
size_type size() const
label
char const * label
Definition: PFTauDecayModeTools.cc:11
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:131
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33

◆ fillDescriptions()

void edmtest::OtherThingAnalyzer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
static

Definition at line 339 of file OtherThingAnalyzer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

339  {
340  edm::ParameterSetDescription desc;
341  desc.addUntracked<bool>("thingWasDropped", false)
342  ->setComment(
343  "true if the ref to the ThingCollection in the OtherThingCollection can not be resolved since the "
344  "ThingCollection was not stored.");
345  desc.addUntracked<edm::InputTag>("other", edm::InputTag("OtherThing", "testUserTag"))
346  ->setComment("Where to get the OtherThingCollection");
347  descriptions.add("otherThingAnalyzer", desc);
348  }
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57

Member Data Documentation

◆ otherTag_

edm::InputTag edmtest::OtherThingAnalyzer::otherTag_
private

Definition at line 27 of file OtherThingAnalyzer.cc.

Referenced by doit(), and OtherThingAnalyzer().

◆ thingWasDropped_

bool edmtest::OtherThingAnalyzer::thingWasDropped_
private

Definition at line 26 of file OtherThingAnalyzer.cc.

Referenced by doit().

Generated for CMSSW Reference Manual by doxygen 1.8.14