ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-4/src/visitors/OtherVisitor.cpp
(Generate patch)

Comparing trunk/OOPSE-4/src/visitors/OtherVisitor.cpp (file contents):
Revision 2008 by tim, Sun Feb 13 19:10:25 2005 UTC vs.
Revision 3116 by chuckv, Tue Jan 16 22:18:04 2007 UTC

# Line 1 | Line 1
1 < /*
1 > /*
2   * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4   * The University of Notre Dame grants you ("Licensee") a
# Line 46 | Line 46 | namespace oopse {
46   #include "brains/SimInfo.hpp"
47   namespace oopse {
48  
49 < //----------------------------------------------------------------------------//
50 < void IgnoreVisitor::visit(Atom *atom) {
51 <    if (isIgnoreType(atom->getType()))
52 <        internalVisit(atom);
53 < }
49 >  void WrappingVisitor::visit(Atom *atom) {
50 >    internalVisit(atom);
51 >  }
52  
53 < void IgnoreVisitor::visit(DirectionalAtom *datom) {
54 <    if (isIgnoreType(datom->getType()))
55 <        internalVisit(datom);
58 < }
53 >  void WrappingVisitor::visit(DirectionalAtom *datom) {
54 >    internalVisit(datom);
55 >  }
56  
57 < void IgnoreVisitor::visit(RigidBody *rb) {
58 <    std::vector<Atom *>           myAtoms;
59 <    std::vector<Atom *>::iterator atomIter;
63 <    AtomInfo *                    atomInfo;
57 >  void WrappingVisitor::visit(RigidBody *rb) {
58 >    internalVisit(rb);
59 >  }
60  
61 <    if (isIgnoreType(rb->getType())) {
66 <        internalVisit(rb);
67 <
68 <        myAtoms = rb->getAtoms();
69 <
70 <        for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
71 <            internalVisit(*atomIter);
72 <    }
73 < }
74 <
75 < bool IgnoreVisitor::isIgnoreType(const std::string&name) {
76 < return itList.find(name) != itList.end() ? true : false;
77 < }
78 <
79 < void IgnoreVisitor::internalVisit(StuntDouble *sd) {
80 <    info->getSelectionManager()->clearSelection(sd);
81 <    //GenericData *data;
82 <    //data = sd->getPropertyByName("IGNORE");
83 <    //
84 <    ////if this stuntdoulbe is already marked as ignore just skip it
85 <    //if (data == NULL) {
86 <    //    data = new GenericData;
87 <    //    data->setID("IGNORE");
88 <    //    sd->addProperty(data);
89 <    //}
90 < }
91 <
92 < const std::string IgnoreVisitor::toString() {
93 <    char                            buffer[65535];
94 <    std::string                     result;
95 <    std::set<std::string>::iterator i;
96 <
97 <    sprintf(buffer,
98 <            "------------------------------------------------------------------\n");
99 <    result += buffer;
100 <
101 <    sprintf(buffer, "Visitor name: %s\n", visitorName.c_str());
102 <    result += buffer;
103 <
104 <    sprintf(buffer, "Visitor Description: ignore  stuntdoubles\n");
105 <    result += buffer;
106 <
107 <    //print the ignore type list
108 <    sprintf(buffer, "Ignore type list contains below types:\n");
109 <    result += buffer;
110 <
111 <    for( i = itList.begin(); i != itList.end(); ++i ) {
112 <        sprintf(buffer, "%s\t", i->c_str());
113 <        result += buffer;
114 <    }
115 <
116 <    sprintf(buffer, "\n");
117 <    result += buffer;
118 <
119 <    sprintf(buffer,
120 <            "------------------------------------------------------------------\n");
121 <    result += buffer;
122 <
123 <    return result;
124 < }
125 <
126 < //----------------------------------------------------------------------------//
127 <
128 < void WrappingVisitor::visit(Atom *atom) {
129 < internalVisit(atom);
130 < }
131 <
132 < void WrappingVisitor::visit(DirectionalAtom *datom) {
133 < internalVisit(datom);
134 < }
135 <
136 < void WrappingVisitor::visit(RigidBody *rb) {
137 < internalVisit(rb);
138 < }
139 <
140 < void WrappingVisitor::internalVisit(StuntDouble *sd) {
61 >  void WrappingVisitor::internalVisit(StuntDouble *sd) {
62      GenericData *                     data;
63      AtomData *                        atomData;
64      AtomInfo *                        atomInfo;
# Line 146 | Line 67 | void WrappingVisitor::internalVisit(StuntDouble *sd) {
67      data = sd->getPropertyByName("ATOMDATA");
68  
69      if (data != NULL) {
70 <        atomData = dynamic_cast<AtomData *>(data);
70 >      atomData = dynamic_cast<AtomData *>(data);
71  
72 <        if (atomData == NULL)
73 <            return;
72 >      if (atomData == NULL)
73 >        return;
74      } else
75 <        return;
75 >      return;
76  
77      Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
78      
79      for( atomInfo = atomData->beginAtomInfo(i); atomInfo; atomInfo = atomData->nextAtomInfo(i) ) {
80 <        currSnapshot->wrapVector(atomInfo->pos);
80 >      Vector3d newPos = atomInfo->pos - origin_;
81 >      currSnapshot->wrapVector(newPos);
82 >      atomInfo->pos = newPos;
83      }
84 < }
84 >  }
85  
86 < const std::string WrappingVisitor::toString() {
86 >  void WrappingVisitor::update() {
87 >    if (useCom_){
88 >      origin_ = info->getCom();
89 >    }
90 >  }
91 >  
92 >  const std::string WrappingVisitor::toString() {
93      char        buffer[65535];
94      std::string result;
95  
# Line 180 | Line 109 | const std::string WrappingVisitor::toString() {
109      result += buffer;
110  
111      return result;
112 < }
112 >  }
113  
114 < //----------------------------------------------------------------------------//
114 >  //----------------------------------------------------------------------------//
115  
116 < ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
116 >  ReplicateVisitor::ReplicateVisitor(SimInfo *info, Vector3i opt) :
117      BaseVisitor() {
118 <    this->info = info;
119 <    visitorName = "ReplicateVisitor";
120 <    this->replicateOpt = opt;
118 >      this->info = info;
119 >      visitorName = "ReplicateVisitor";
120 >      this->replicateOpt = opt;
121  
122 <    //generate the replicate directions
123 <    for( int i = 0; i <= replicateOpt[0]; i++ ) {
122 >      //generate the replicate directions
123 >      for( int i = 0; i <= replicateOpt[0]; i++ ) {
124          for( int j = 0; j <= replicateOpt[1]; j++ ) {
125 <            for( int k = 0; k <= replicateOpt[2]; k++ ) {
126 <                //skip original frame
127 <                if (i == 0 && j == 0 && k == 0) {
128 <                    continue;
129 <                } else {
130 <                    dir.push_back(Vector3i(i, j, k));
131 <                }
132 <            }
125 >          for( int k = 0; k <= replicateOpt[2]; k++ ) {
126 >            //skip original frame
127 >            if (i == 0 && j == 0 && k == 0) {
128 >              continue;
129 >            } else {
130 >              dir.push_back(Vector3i(i, j, k));
131 >            }
132 >          }
133          }
134 <    }
134 >      }
135      
136 < }
136 >    }
137  
138 < void ReplicateVisitor::visit(Atom *atom) {
139 < internalVisit(atom);
140 < }
138 >  void ReplicateVisitor::visit(Atom *atom) {
139 >    internalVisit(atom);
140 >  }
141  
142 < void ReplicateVisitor::visit(DirectionalAtom *datom) {
143 < internalVisit(datom);
144 < }
142 >  void ReplicateVisitor::visit(DirectionalAtom *datom) {
143 >    internalVisit(datom);
144 >  }
145  
146 < void ReplicateVisitor::visit(RigidBody *rb) {
147 < internalVisit(rb);
148 < }
146 >  void ReplicateVisitor::visit(RigidBody *rb) {
147 >    internalVisit(rb);
148 >  }
149  
150 < void ReplicateVisitor::internalVisit(StuntDouble *sd) {
150 >  void ReplicateVisitor::internalVisit(StuntDouble *sd) {
151      GenericData *          data;
152      AtomData *             atomData;
153  
# Line 226 | Line 155 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
155      data = sd->getPropertyByName("ATOMDATA");
156  
157      if (data != NULL) {
158 <        atomData = dynamic_cast<AtomData *>(data);
158 >      atomData = dynamic_cast<AtomData *>(data);
159  
160 <        if (atomData == NULL) {
161 <            return;
162 <        }
160 >      if (atomData == NULL) {
161 >        return;
162 >      }
163      } else {
164 <        return;
164 >      return;
165      }
166  
167      Snapshot* currSnapshot = info->getSnapshotManager()->getCurrentSnapshot();
# Line 241 | Line 170 | void ReplicateVisitor::internalVisit(StuntDouble *sd)
170      std::vector<AtomInfo *> atomInfoList = atomData->getData();
171  
172      replicate(atomInfoList, atomData, box);
173 < }
173 >  }
174  
175 < void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
175 >  void ReplicateVisitor::replicate(std::vector<AtomInfo *>&infoList, AtomData *data, const Mat3x3d& box) {
176      AtomInfo* newAtomInfo;
177      std::vector<Vector3i>::iterator dirIter;
178      std::vector<AtomInfo *>::iterator i;
179  
180      for( dirIter = dir.begin(); dirIter != dir.end(); ++dirIter ) {
181 <        for( i = infoList.begin(); i != infoList.end(); i++ ) {
182 <            newAtomInfo = new AtomInfo();
183 <            *newAtomInfo = *(*i);
181 >      for( i = infoList.begin(); i != infoList.end(); i++ ) {
182 >        newAtomInfo = new AtomInfo();
183 >        *newAtomInfo = *(*i);
184  
185 <            for( int j = 0; j < 3; j++ )
186 <                newAtomInfo->pos[j] += (*dirIter)[0]*box(j, 0) + (*dirIter)[1]*box(j, 1) + (*dirIter)[2]*box(j, 2);
185 >        for( int j = 0; j < 3; j++ )
186 >          newAtomInfo->pos[j] += (*dirIter)[0]*box(j, 0) + (*dirIter)[1]*box(j, 1) + (*dirIter)[2]*box(j, 2);
187  
188 <            data->addAtomInfo(newAtomInfo);
189 <        }
188 >        data->addAtomInfo(newAtomInfo);
189 >      }
190      } // end for(dirIter)  
191 < }
191 >  }
192  
193 < const std::string ReplicateVisitor::toString() {
193 >  const std::string ReplicateVisitor::toString() {
194      char                            buffer[65535];
195      std::string                     result;
196      std::set<std::string>::iterator i;
# Line 292 | Line 221 | const std::string ReplicateVisitor::toString() {
221      result += buffer;
222  
223      return result;
224 < }
224 >  }
225  
226 < //----------------------------------------------------------------------------//
226 >  //----------------------------------------------------------------------------//
227  
228 < XYZVisitor::XYZVisitor(SimInfo *info, bool printDipole) :
229 <    BaseVisitor() {
230 <    this->info = info;
231 <    visitorName = "XYZVisitor";
303 <    this->printDipole = printDipole;
304 < }
228 >  XYZVisitor::XYZVisitor(SimInfo *info) :
229 >    BaseVisitor(), seleMan(info), evaluator(info){
230 >      this->info = info;
231 >      visitorName = "XYZVisitor";
232  
233 < void XYZVisitor::visit(Atom *atom) {
233 >      evaluator.loadScriptString("select all");
234 >
235 >      if (!evaluator.isDynamic()) {
236 >        seleMan.setSelectionSet(evaluator.evaluate());
237 >      }
238 >      posOnly_ = false;
239 >    }
240 >
241 >  XYZVisitor::XYZVisitor(SimInfo *info, const std::string& script) :
242 >    BaseVisitor(), seleMan(info), evaluator(info) {
243 >      this->info = info;
244 >      visitorName = "XYZVisitor";
245 >
246 >      evaluator.loadScriptString(script);
247 >
248 >      if (!evaluator.isDynamic()) {
249 >        seleMan.setSelectionSet(evaluator.evaluate());
250 >      }
251 >      posOnly_ = false;
252 >    }
253 >    
254 >  void XYZVisitor::visit(Atom *atom) {
255      if (isSelected(atom))
256 <        internalVisit(atom);
257 < }
256 >      internalVisit(atom);
257 >  }
258  
259 < void XYZVisitor::visit(DirectionalAtom *datom) {
259 >  void XYZVisitor::visit(DirectionalAtom *datom) {
260      if (isSelected(datom))
261 <        internalVisit(datom);
262 < }
263 <
264 < void XYZVisitor::visit(RigidBody *rb) {
261 >      internalVisit(datom);
262 >  }
263 >
264 >  void XYZVisitor::visit(RigidBody *rb) {
265      if (isSelected(rb))
266 <        internalVisit(rb);
267 < }
266 >      internalVisit(rb);
267 >  }
268  
269 < void XYZVisitor::internalVisit(StuntDouble *sd) {
269 >  void XYZVisitor::update() {
270 >    //if dynamic, we need to re-evaluate the selection
271 >    if (evaluator.isDynamic()) {
272 >      seleMan.setSelectionSet(evaluator.evaluate());
273 >    }
274 >  }
275 >
276 >  void XYZVisitor::internalVisit(StuntDouble *sd) {
277      GenericData *                     data;
278      AtomData *                        atomData;
279      AtomInfo *                        atomInfo;
# Line 329 | Line 284 | void XYZVisitor::internalVisit(StuntDouble *sd) {
284      data = sd->getPropertyByName("ATOMDATA");
285  
286      if (data != NULL) {
287 <        atomData = dynamic_cast<AtomData *>(data);
287 >      atomData = dynamic_cast<AtomData *>(data);
288  
289 <        if (atomData == NULL)
290 <            return;
289 >      if (atomData == NULL)
290 >        return;
291      } else
292 <        return;
292 >      return;
293  
294 <    for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
295 <        atomInfo = atomData->nextAtomInfo(i) ) {
296 <        if (printDipole)
297 <            sprintf(buffer,
298 <                    "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
299 <                    atomInfo->AtomType.c_str(),
300 <                    atomInfo->pos[0],
301 <                    atomInfo->pos[1],
302 <                    atomInfo->pos[2],
303 <                    atomInfo->dipole[0],
304 <                    atomInfo->dipole[1],
305 <                    atomInfo->dipole[2]); else
306 <            sprintf(buffer,                     "%s%15.8f%15.8f%15.8f",
307 <                    atomInfo->AtomType.c_str(), atomInfo->pos[0],
308 <                    atomInfo->pos[1],           atomInfo->pos[2]);
309 <
310 <        frame.push_back(buffer);
294 >    if (posOnly_){
295 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
296 >           atomInfo = atomData->nextAtomInfo(i) ) {
297 >        sprintf(buffer,
298 >                "%s%15.8f%15.8f%15.8f",
299 >                atomInfo->atomTypeName.c_str(),
300 >                atomInfo->pos[0],
301 >                atomInfo->pos[1],
302 >                atomInfo->pos[2]);
303 >        frame.push_back(buffer);
304 >      }
305 >    }else{
306 >      for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
307 >           atomInfo = atomData->nextAtomInfo(i) ) {
308 >        sprintf(buffer,
309 >                "%s%15.8f%15.8f%15.8f%15.8f%15.8f%15.8f",
310 >                atomInfo->atomTypeName.c_str(),
311 >                atomInfo->pos[0],
312 >                atomInfo->pos[1],
313 >                atomInfo->pos[2],
314 >                atomInfo->dipole[0],
315 >                atomInfo->dipole[1],
316 >                atomInfo->dipole[2]);
317 >        frame.push_back(buffer);
318 >      }
319      }
320 < }
320 >  }
321  
322 < bool XYZVisitor::isSelected(StuntDouble *sd) {
323 <    return info->getSelectionManager()->isSelected(sd);
324 < }
322 >  bool XYZVisitor::isSelected(StuntDouble *sd) {
323 >    return seleMan.isSelected(sd);
324 >  }
325  
326 < void XYZVisitor::writeFrame(std::ostream &outStream) {
326 >  void XYZVisitor::writeFrame(std::ostream &outStream) {
327      std::vector<std::string>::iterator i;
328      char buffer[1024];
329  
330      if (frame.size() == 0)
331 <        std::cerr << "Current Frame does not contain any atoms" << std::endl;
331 >      std::cerr << "Current Frame does not contain any atoms" << std::endl;
332  
333      //total number of atoms  
334      outStream << frame.size() << std::endl;
# Line 384 | Line 347 | void XYZVisitor::writeFrame(std::ostream &outStream) {
347      outStream << buffer << std::endl;
348  
349      for( i = frame.begin(); i != frame.end(); ++i )
350 <        outStream << *i << std::endl;
351 < }
350 >      outStream << *i << std::endl;
351 >  }
352  
353 < const std::string XYZVisitor::toString() {
353 >  const std::string XYZVisitor::toString() {
354      char        buffer[65535];
355      std::string result;
356  
# Line 407 | Line 370 | const std::string XYZVisitor::toString() {
370      result += buffer;
371  
372      return result;
373 < }
373 >  }
374  
375 < //----------------------------------------------------------------------------//
375 >  //----------------------------------------------------------------------------//
376  
377 < void PrepareVisitor::internalVisit(Atom *atom) {
377 >  void PrepareVisitor::internalVisit(Atom *atom) {
378      GenericData *data;
379      AtomData *   atomData;
380  
# Line 419 | Line 382 | void PrepareVisitor::internalVisit(Atom *atom) {
382      data = atom->getPropertyByName("VISITED");
383  
384      if (data != NULL) {
385 <    atom->removeProperty("VISITED");
385 >      atom->removeProperty("VISITED");
386      }
387  
388      //remove atomdata
389      data = atom->getPropertyByName("ATOMDATA");
390  
391      if (data != NULL) {
392 <        atomData = dynamic_cast<AtomData *>(data);
392 >      atomData = dynamic_cast<AtomData *>(data);
393  
394 <        if (atomData != NULL)
395 <            atom->removeProperty("ATOMDATA");
394 >      if (atomData != NULL)
395 >        atom->removeProperty("ATOMDATA");
396      }
397 < }
397 >  }
398  
399 < void PrepareVisitor::internalVisit(RigidBody *rb) {
399 >  void PrepareVisitor::internalVisit(RigidBody *rb) {
400      GenericData* data;
401      AtomData* atomData;
402      std::vector<Atom *> myAtoms;
# Line 443 | Line 406 | void PrepareVisitor::internalVisit(RigidBody *rb) {
406      data = rb->getPropertyByName("VISITED");
407  
408      if (data != NULL) {
409 <    rb->removeProperty("VISITED");
409 >      rb->removeProperty("VISITED");
410      }
411  
412      //remove atomdata
413      data = rb->getPropertyByName("ATOMDATA");
414  
415      if (data != NULL) {
416 <        atomData = dynamic_cast<AtomData *>(data);
416 >      atomData = dynamic_cast<AtomData *>(data);
417  
418 <        if (atomData != NULL)
419 <            rb->removeProperty("ATOMDATA");
418 >      if (atomData != NULL)
419 >        rb->removeProperty("ATOMDATA");
420      }
421  
422      myAtoms = rb->getAtoms();
423  
424      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end(); ++atomIter )
425 <        internalVisit(*atomIter);
426 < }
425 >      internalVisit(*atomIter);
426 >  }
427  
428 < const std::string PrepareVisitor::toString() {
429 <     char buffer[65535];
430 <     std::string result;
428 >  const std::string PrepareVisitor::toString() {
429 >    char buffer[65535];
430 >    std::string result;
431  
432 <     sprintf(buffer,
433 <             "------------------------------------------------------------------\n");
434 <     result += buffer;
432 >    sprintf(buffer,
433 >            "------------------------------------------------------------------\n");
434 >    result += buffer;
435  
436 <     sprintf(buffer, "Visitor name: %s", visitorName.c_str());
437 <     result += buffer;
436 >    sprintf(buffer, "Visitor name: %s", visitorName.c_str());
437 >    result += buffer;
438  
439 <     sprintf(buffer,
440 <             "Visitor Description: prepare for operation of other vistors\n");
441 <     result += buffer;
439 >    sprintf(buffer,
440 >            "Visitor Description: prepare for operation of other vistors\n");
441 >    result += buffer;
442  
443 <     sprintf(buffer,
444 <             "------------------------------------------------------------------\n");
445 <     result += buffer;
443 >    sprintf(buffer,
444 >            "------------------------------------------------------------------\n");
445 >    result += buffer;
446  
447 <     return result;
448 < }
447 >    return result;
448 >  }
449  
450 < //----------------------------------------------------------------------------//
450 >  //----------------------------------------------------------------------------//
451  
452 < WaterTypeVisitor::WaterTypeVisitor() {
452 >  WaterTypeVisitor::WaterTypeVisitor() {
453      visitorName = "WaterTypeVisitor";
454      waterTypeList.insert("TIP3P_RB_0");
455      waterTypeList.insert("TIP4P_RB_0");
456      waterTypeList.insert("TIP5P_RB_0");
457      waterTypeList.insert("SPCE_RB_0");
458 < }
458 >  }
459  
460 < void WaterTypeVisitor::visit(RigidBody *rb) {
460 >  void WaterTypeVisitor::visit(RigidBody *rb) {
461      std::string rbName;
462      std::vector<Atom *> myAtoms;
463      std::vector<Atom *>::iterator atomIter;
# Line 506 | Line 469 | void WaterTypeVisitor::visit(RigidBody *rb) {
469      rbName = rb->getType();
470  
471      if (waterTypeList.find(rbName) != waterTypeList.end()) {
472 <        myAtoms = rb->getAtoms();
472 >      myAtoms = rb->getAtoms();
473  
474 <        for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
475 <            ++atomIter ) {
476 <            data = (*atomIter)->getPropertyByName("ATOMDATA");
474 >      for( atomIter = myAtoms.begin(); atomIter != myAtoms.end();
475 >           ++atomIter ) {
476 >        data = (*atomIter)->getPropertyByName("ATOMDATA");
477  
478 <            if (data != NULL) {
479 <                atomData = dynamic_cast<AtomData *>(data);
478 >        if (data != NULL) {
479 >          atomData = dynamic_cast<AtomData *>(data);
480  
481 <                if (atomData == NULL)
482 <                    continue;
483 <            } else
484 <                continue;
481 >          if (atomData == NULL)
482 >            continue;
483 >        } else
484 >          continue;
485  
486 <            for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
487 <                atomInfo = atomData->nextAtomInfo(i) ) {
488 <            replaceType(atomInfo->AtomType);
489 <            } //end for(atomInfo)
490 <        }     //end for(atomIter)
486 >        for( atomInfo = atomData->beginAtomInfo(i); atomInfo;
487 >             atomInfo = atomData->nextAtomInfo(i) ) {
488 >          atomInfo->atomTypeName = trimmedName(atomInfo->atomTypeName);
489 >        } //end for(atomInfo)
490 >      }     //end for(atomIter)
491      }         //end if (waterTypeList.find(rbName) != waterTypeList.end())
492 < }
492 >  }
493  
494 < void WaterTypeVisitor::replaceType(std::string&atomType) {
495 < atomType = atomType.substr(0, atomType.find('_'));
496 < }
494 >  std::string WaterTypeVisitor::trimmedName(const std::string&atomTypeName) {
495 >    return atomTypeName.substr(0, atomTypeName.find('_'));
496 >  }
497  
498 < const std::string WaterTypeVisitor::toString() {
498 >  const std::string WaterTypeVisitor::toString() {
499      char buffer[65535];
500      std::string result;
501  
# Line 552 | Line 515 | const std::string WaterTypeVisitor::toString() {
515      result += buffer;
516  
517      return result;
518 < }
518 >  }
519  
520   } //namespace oopse

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines