Guest User

Untitled

a guest
Nov 24th, 2017
71
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 21.30 KB | None | 0 0
  1. c:\repositories\sm-ssc\src\TimingSegments.h(29): error C2440: 'type cast' : cannot convert from 'BPMSegment' to 'int'
  2. No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
  3.  
  4.  
  5.  
  6. #ifndef TIMING_SEGMENTS_H // line 1
  7. #define TIMING_SEGMENTS_H
  8.  
  9. #include "NoteTypes.h" // Converting rows to beats and vice~versa.
  10.  
  11. /**
  12. * @brief The base timing segment for all of the changing glory.
  13. *
  14. * Do not derive from this class!! Instead, derive from TimingSegment<DerivedClass>!
  15. */
  16. struct BaseTimingSegment
  17. {
  18.  
  19. /** @brief Set up a BaseTimingSegment with default values. */
  20. BaseTimingSegment():
  21. startingRow(static_cast<int>(-1)) {};
  22.  
  23. BaseTimingSegment(const BaseTimingSegment &b)
  24. {
  25. *this = b;
  26. }
  27.  
  28. /**
  29. * @brief Set up a BaseTimingSegment with specified values.
  30. * @param s the starting row / beat. */
  31. template <typename StartType>
  32. BaseTimingSegment(StartType s): startingRow(0)
  33. {
  34. if ( (int)s == (float)s )
  35. {
  36. startingRow = ToNoteRow((int)s);
  37. }
  38. else
  39. {
  40. startingRow = ToNoteRow((float)s);
  41. }
  42. }
  43.  
  44. virtual ~BaseTimingSegment();
  45.  
  46. /**
  47. * @brief Set the starting row of the BaseTimingSegment.
  48. *
  49. * This is virtual to allow other segments to implement validation
  50. * as required by them.
  51. * @param s the supplied row. */
  52. virtual void SetRow( const int s );
  53.  
  54. /**
  55. * @brief Set the starting beat of the BaseTimingSegment.
  56. *
  57. * @param s the supplied beat. */
  58. void SetBeat( const float s );
  59.  
  60. /**
  61. * @brief Get the starting row of the BaseTimingSegment.
  62. * @return the starting row. */
  63. int GetRow() const;
  64.  
  65. /**
  66. * @brief Get the starting beat of the BaseTimingSegment.
  67. * @return the starting beat. */
  68. float GetBeat() const;
  69.  
  70. private:
  71. /** @brief The row in which this segment activates. */
  72. int startingRow;
  73.  
  74. };
  75.  
  76. /**
  77. * @brief The general TimingSegment for all of the changing glory.
  78. *
  79. * Each segment is supposed to derive from this one. */
  80. template <class DerivedSegment>
  81. struct TimingSegment: public BaseTimingSegment
  82. {
  83.  
  84. TimingSegment(): BaseTimingSegment(static_cast<int>(-1)) {};
  85.  
  86. template <typename StartType>
  87. TimingSegment(StartType s): BaseTimingSegment(s) {};
  88.  
  89. /**
  90. * @brief Compares two DrivedSegments to see if one is less than the other.
  91. * @param other the other TimingSegments to compare to.
  92. * @return the truth/falsehood of if the first is less than the second.
  93. *
  94. * This is virtual to allow other segments to implement comparison
  95. * as required by them.
  96. */
  97. virtual bool operator<( const DerivedSegment &other ) const;
  98.  
  99. /**
  100. * @brief Compares two DrivedSegments to see if they are equal to each other.
  101. * @param other the other FakeSegment to compare to.
  102. * @return the equality of the two segments.
  103. *
  104. * This is virtual to allow other segments to implement comparison
  105. * as required by them.
  106. */
  107. bool operator==( const DerivedSegment &other ) const
  108. {
  109. return !this->operator<(other) &&
  110. !other.operator<(*static_cast<const DerivedSegment *>(this));
  111. };
  112. /**
  113. * @brief Compares two DrivedSegments to see if they are not equal to each other.
  114. * @param other the other DrivedSegments to compare to.
  115. * @return the inequality of the two segments.
  116. */
  117. bool operator!=( const DerivedSegment &other ) const { return !this->operator==(other); };
  118. /**
  119. * @brief Compares two DrivedSegments to see if one is less than or equal to the other.
  120. * @param other the other DrivedSegments to compare to.
  121. * @return the truth/falsehood of if the first is less or equal to than the second.
  122. */
  123. bool operator<=( const DerivedSegment &other ) const { return !this->operator>(other); };
  124. /**
  125. * @brief Compares two DrivedSegments to see if one is greater than the other.
  126. * @param other the other DrivedSegments to compare to.
  127. * @return the truth/falsehood of if the first is greater than the second.
  128. */
  129. bool operator>( const DerivedSegment &other ) const
  130. {
  131. return other.operator<(*static_cast<const DerivedSegment *>(this));
  132. };
  133. /**
  134. * @brief Compares two DrivedSegments to see if one is greater than or equal to the other.
  135. * @param other the other DrivedSegments to compare to.
  136. * @return the truth/falsehood of if the first is greater than or equal to the second.
  137. */
  138. bool operator>=( const DerivedSegment &other ) const { return !this->operator<(other); };
  139.  
  140. };
  141.  
  142.  
  143. /**
  144. * @brief Identifies when a whole region of arrows is to be ignored.
  145. *
  146. * FakeSegments are similar to the Fake Tap Notes in that the contents
  147. * inside are neither for nor against the player. They can be useful for
  148. * mission modes, in conjunction with WarpSegments, or perhaps other
  149. * uses not thought up at the time of this comment. Unlike the Warp
  150. * Segments, these are not magically jumped over: instead, these are
  151. * drawn normally.
  152. *
  153. * These were inspired by the Pump It Up series. */
  154. struct FakeSegment : public TimingSegment<FakeSegment>
  155. {
  156. /**
  157. * @brief Create a simple Fake Segment with default values.
  158. *
  159. * It is best to override the values as soon as possible.
  160. */
  161. FakeSegment():
  162. TimingSegment<FakeSegment>(), lengthBeats(-1) {};
  163.  
  164. /**
  165. * @brief Create a Fake Segment with the specified values.
  166. * @param s the starting row of this segment.
  167. * @param r the number of rows this segment lasts.
  168. */
  169. template <typename StartType, typename LengthType>
  170. FakeSegment( StartType s, LengthType r ):
  171. TimingSegment<FakeSegment>(max((StartType)0, s)),
  172. lengthBeats(ToBeat(max((LengthType)0, r))) {};
  173.  
  174. /**
  175. * @brief Get the length in beats of the FakeSegment.
  176. * @return the length in beats. */
  177. float GetLength() const;
  178.  
  179. /**
  180. * @brief Set the length in beats of the FakeSegment.
  181. * @param b the length in beats. */
  182. void SetLength(const float b);
  183.  
  184. /**
  185. * @brief Compares two FakeSegments to see if one is less than the other.
  186. * @param other the other FakeSegment to compare to.
  187. * @return the truth/falsehood of if the first is less than the second.
  188. */
  189. bool operator<( const FakeSegment &other ) const;
  190.  
  191. private:
  192. /**
  193. * @brief The number of beats the FakeSegment is alive for.
  194. */
  195. float lengthBeats;
  196. };
  197.  
  198. /**
  199. * @brief Identifies when a song needs to warp to a new beat.
  200. *
  201. * A warp segment is used to replicate the effects of Negative BPMs without
  202. * abusing negative BPMs. Negative BPMs should be converted to warp segments.
  203. * WarpAt=WarpToRelative is the format, where both are in beats.
  204. * (Technically they're both rows though.) */
  205. struct WarpSegment : public TimingSegment<WarpSegment>
  206. {
  207. /**
  208. * @brief Create a simple Warp Segment with default values.
  209. *
  210. * It is best to override the values as soon as possible.
  211. */
  212. WarpSegment():
  213. TimingSegment<WarpSegment>(), lengthBeats(-1) {};
  214.  
  215. /**
  216. * @brief Create a Warp Segment with the specified values.
  217. * @param s the starting row of this segment.
  218. * @param r the number of rows this segment lasts.
  219. */
  220. template <typename StartType, typename LengthType>
  221. WarpSegment( StartType s, LengthType r ):
  222. TimingSegment<WarpSegment>(max((StartType)0, s)),
  223. lengthBeats(ToBeat(max((LengthType)0, r))) {};
  224.  
  225. /**
  226. * @brief Get the length in beats of the WarpSegment.
  227. * @return the length in beats. */
  228. float GetLength() const;
  229.  
  230. /**
  231. * @brief Set the length in beats of the WarpSegment.
  232. * @param b the length in beats. */
  233. void SetLength(const float b);
  234.  
  235. /*
  236. * @brief Compares two WarpSegments to see if one is less than the other.
  237. * @param other the other WarpSegment to compare to.
  238. * @return the truth/falsehood of if the first is less than the second.
  239. */
  240. bool operator<( const WarpSegment &other ) const;
  241. private:
  242. /**
  243. * @brief The number of beats the FakeSegment is alive for.
  244. */
  245. float lengthBeats;
  246. };
  247.  
  248. /**
  249. * @brief Identifies when a chart is to have a different tickcount value
  250. * for hold notes.
  251. *
  252. * A tickcount segment is used to better replicate the checkpoint hold
  253. * system used by various based video games. The number is used to
  254. * represent how many ticks can be counted in one beat.
  255. */
  256. struct TickcountSegment : public TimingSegment<TickcountSegment>
  257. {
  258. /**
  259. * @brief Creates a simple Tickcount Segment with default values.
  260. *
  261. * It is best to override the values as soon as possible.
  262. */
  263. TickcountSegment():
  264. TimingSegment<TickcountSegment>(), ticks(4) {};
  265.  
  266. /**
  267. * @brief Creates a TickcountSegment with specified values.
  268. * @param s the starting row / beat. */
  269. template <typename StartType>
  270. TickcountSegment( StartType s ):
  271. TimingSegment<TickcountSegment>(max((StartType)0, s)), ticks(4) {};
  272.  
  273. /**
  274. * @brief Creates a TickcountSegment with specified values.
  275. * @param s the starting row / beat.
  276. * @param t the amount of ticks counted per beat. */
  277. template <typename StartType>
  278. TickcountSegment( StartType s, int t ):
  279. TimingSegment<TickcountSegment>(max((StartType)0, s)), ticks(max(0, t)) {};
  280.  
  281. /**
  282. * @brief Get the number of ticks in this TickcountSegment.
  283. * @return the tickcount. */
  284. int GetTicks() const;
  285.  
  286. /**
  287. * @brief Set the number of ticks in this TickcountSegment.
  288. * @param i the tickcount. */
  289. void SetTicks(const int i);
  290.  
  291. /**
  292. * @brief Compares two TickcountSegments to see if one is less than the other.
  293. * @param other the other TickcountSegment to compare to.
  294. * @return the truth/falsehood of if the first is less than the second.
  295. */
  296. bool operator<( const TickcountSegment &other ) const;
  297.  
  298. private:
  299. /**
  300. * @brief The amount of ticks counted per beat.
  301. */
  302. int ticks;
  303. };
  304.  
  305. /**
  306. * @brief Identifies when a chart is to have a different combo multiplier value.
  307. *
  308. * Admitedly, this would primarily be used for mission mode style charts. However,
  309. * it can have its place during normal gameplay.
  310. */
  311. struct ComboSegment : public TimingSegment<ComboSegment>
  312. {
  313. /**
  314. * @brief Creates a simple Combo Segment with default values.
  315. *
  316. * It is best to override the values as soon as possible.
  317. */
  318. ComboSegment() :
  319. TimingSegment<ComboSegment>(), combo(1) { }
  320. /**
  321. * @brief Creates a Combo Segment with the specified values.
  322. * @param s the starting row / beat of this segment.
  323. * @param t the amount the combo increases on a succesful hit.
  324. */
  325. template <typename StartType>
  326. ComboSegment( StartType s, int t ):
  327. TimingSegment<ComboSegment>(max((StartType)0, s)),
  328. combo(max(0,t)) {}
  329.  
  330. /**
  331. * @brief Get the combo in this ComboSegment.
  332. * @return the combo. */
  333. int GetCombo() const;
  334.  
  335. /**
  336. * @brief Set the combo in this ComboSegment.
  337. * @param i the combo. */
  338. void SetCombo(const int i);
  339.  
  340. /**
  341. * @brief Compares two ComboSegments to see if one is less than the other.
  342. * @param other the other ComboSegment to compare to.
  343. * @return the truth/falsehood of if the first is less than the second.
  344. */
  345. bool operator<( const ComboSegment &other ) const;
  346. private:
  347. /**
  348. * @brief The amount the combo increases at this point.
  349. */
  350. int combo;
  351. };
  352.  
  353.  
  354. /**
  355. * @brief Identifies when a chart is entering a different section.
  356. *
  357. * This is meant for helping to identify different sections of a chart
  358. * versus relying on measures and beats alone.
  359. */
  360. struct LabelSegment : public TimingSegment<LabelSegment>
  361. {
  362. /**
  363. * @brief Creates a simple Label Segment with default values.
  364. *
  365. * It is best to override the values as soon as possible.
  366. */
  367. LabelSegment() :
  368. TimingSegment<LabelSegment>(), label("") { }
  369. /**
  370. * @brief Creates a Label Segment with the specified values.
  371. * @param s the starting row / beat of this segment.
  372. * @param l the label for this section.
  373. */
  374. template <typename StartType>
  375. LabelSegment( StartType s, RString l ):
  376. TimingSegment<LabelSegment>(max((StartType)0, s)),
  377. label(l) {}
  378.  
  379. /**
  380. * @brief Get the label in this LabelSegment.
  381. * @return the label. */
  382. RString GetLabel() const;
  383.  
  384. /**
  385. * @brief Set the label in this LabelSegment.
  386. * @param l the label. */
  387. void SetLabel(const RString l);
  388.  
  389. /**
  390. * @brief Compares two LabelSegments to see if one is less than the other.
  391. * @param other the other LabelSegment to compare to.
  392. * @return the truth/falsehood of if the first is less than the second.
  393. */
  394. bool operator<( const LabelSegment &other ) const;
  395.  
  396. private:
  397. /**
  398. * @brief The label/section name for this point.
  399. */
  400. RString label;
  401. };
  402.  
  403.  
  404.  
  405. /**
  406. * @brief Identifies when a song changes its BPM.
  407. */
  408. struct BPMSegment : public TimingSegment<BPMSegment>
  409. {
  410. /**
  411. * @brief Creates a simple BPM Segment with default values.
  412. *
  413. * It is best to override the values as soon as possible.
  414. */
  415. BPMSegment() :
  416. TimingSegment<BPMSegment>(), bps(-1.0f) { }
  417.  
  418. /**
  419. * @brief Creates a BPM Segment with the specified starting row and beats per second.
  420. * @param s the starting row / beat of this segment.
  421. * @param b the beats per minute to be turned into beats per second.
  422. */
  423. template <typename StartType>
  424. BPMSegment( StartType s, float bpm ):
  425. TimingSegment<BPMSegment>(max((StartType)0, s)), bps(0.0f) { SetBPM(bpm); }
  426.  
  427. /**
  428. * @brief Get the label in this LabelSegment.
  429. * @return the label. */
  430. float GetBPM() const;
  431.  
  432. /**
  433. * @brief Set the label in this LabelSegment.
  434. * @param l the label. */
  435. void SetBPM(const float bpm);
  436.  
  437. /**
  438. * @brief Get the label in this LabelSegment.
  439. * @return the label. */
  440. float GetBPS() const;
  441.  
  442. /**
  443. * @brief Set the label in this LabelSegment.
  444. * @param l the label. */
  445. void SetBPS(const float newBPS);
  446.  
  447. /**
  448. * @brief Compares two LabelSegments to see if one is less than the other.
  449. * @param other the other LabelSegment to compare to.
  450. * @return the truth/falsehood of if the first is less than the second.
  451. */
  452. bool operator<( const BPMSegment &other ) const;
  453.  
  454. private:
  455. /**
  456. * @brief The label/section name for this point.
  457. */
  458. float bps;
  459. };
  460.  
  461. /**
  462. * @brief Identifies when a song changes its time signature.
  463. *
  464. * This only supports simple time signatures. The upper number
  465. * (called the numerator here, though this isn't properly a
  466. * fraction) is the number of beats per measure. The lower number
  467. * (denominator here) is the note value representing one beat. */
  468. struct TimeSignatureSegment : public TimingSegment<TimeSignatureSegment>
  469. {
  470. /**
  471. * @brief Creates a simple Time Signature Segment with default values.
  472. */
  473. TimeSignatureSegment():
  474. TimingSegment<TimeSignatureSegment>(),
  475. numerator(4), denominator(4) { }
  476. /**
  477. * @brief Creates a Time Signature Segment with supplied values.
  478. *
  479. * The denominator will be 4 if this is called.
  480. * @param r the starting row / beat of the segment.
  481. * @param n the numerator for the segment.
  482. */
  483. template <typename StartType>
  484. TimeSignatureSegment( StartType r, int n ):
  485. TimingSegment<TimeSignatureSegment>(max((StartType)0, r)),
  486. numerator(max(1, n)), denominator(4) {}
  487. /**
  488. * @brief Creates a Time Signature Segment with supplied values.
  489. * @param r the starting row of the segment.
  490. * @param n the numerator for the segment.
  491. * @param d the denonimator for the segment.
  492. */
  493. template <typename StartType>
  494. TimeSignatureSegment( StartType r, int n, int d ):
  495. TimingSegment<TimeSignatureSegment>(max((StartType)0, r)),
  496. numerator(max(1, n)), denominator(max(1, d)) {}
  497.  
  498. /**
  499. * @brief Get the numerator in this TimeSignatureSegment.
  500. * @return the numerator. */
  501. int GetNum() const;
  502.  
  503. /**
  504. * @brief Set the numerator in this TimeSignatureSegment.
  505. * @param i the numerator. */
  506. void SetNum(const int i);
  507.  
  508. /**
  509. * @brief Get the denominator in this TimeSignatureSegment.
  510. * @return the denominator. */
  511. int GetDen() const;
  512.  
  513. /**
  514. * @brief Set the denominator in this TimeSignatureSegment.
  515. * @param i the denominator. */
  516. void SetDen(const int i);
  517.  
  518. /**
  519. * @brief Retrieve the number of note rows per measure within the TimeSignatureSegment.
  520. *
  521. * With BeatToNoteRow(1) rows per beat, then we should have BeatToNoteRow(1)*m_iNumerator
  522. * beats per measure. But if we assume that every BeatToNoteRow(1) rows is a quarter note,
  523. * and we want the beats to be 1/m_iDenominator notes, then we should have
  524. * BeatToNoteRow(1)*4 is rows per whole note and thus BeatToNoteRow(1)*4/m_iDenominator is
  525. * rows per beat. Multiplying by m_iNumerator gives rows per measure.
  526. * @returns the number of note rows per measure.
  527. */
  528. int GetNoteRowsPerMeasure() const;
  529.  
  530. /**
  531. * @brief Compares two TimeSignatureSegments to see if one is less than the other.
  532. * @param other the other TimeSignatureSegment to compare to.
  533. * @return the truth/falsehood of if the first is less than the second.
  534. */
  535. bool operator<( const TimeSignatureSegment &other ) const;
  536. private:
  537. /**
  538. * @brief The numerator of the TimeSignatureSegment.
  539. */
  540. int numerator;
  541. /**
  542. * @brief The denominator of the TimeSignatureSegment.
  543. */
  544. int denominator;
  545. };
  546.  
  547. /**
  548. * @brief Identifies when the arrow scroll changes.
  549. *
  550. * SpeedSegments take a Player's scrolling BPM (Step's BPM * speed mod),
  551. * and then multiplies it with the percentage value. No matter the player's
  552. * speed mod, the ratio will be the same. Unlike forced attacks, these
  553. * cannot be turned off at a set time: reset it by setting the precentage
  554. * back to 1.
  555. *
  556. * These were inspired by the Pump It Up series. */
  557. struct SpeedSegment : public TimingSegment<SpeedSegment>
  558. {
  559. /** @brief Sets up the SpeedSegment with default values. */
  560. SpeedSegment():
  561. TimingSegment<SpeedSegment>(0),
  562. ratio(1), length(0), unit(0) {}
  563.  
  564. /**
  565. * @brief Sets up the SpeedSegment with specified values.
  566. * @param r The row / beat this activates.
  567. * @param p The percentage to use. */
  568. template <typename StartType>
  569. SpeedSegment( StartType r, float p):
  570. TimingSegment<SpeedSegment>(max((StartType)0, r)),
  571. ratio(p), length(0), unit(0) {}
  572.  
  573. /**
  574. * @brief Sets up the SpeedSegment with specified values.
  575. * @param r The row / beat this activates.
  576. * @param p The percentage to use.
  577. * @param w The number of beats to wait. */
  578. template <typename StartType>
  579. SpeedSegment(StartType r, float p, float w):
  580. TimingSegment<SpeedSegment>(max((StartType)0, r)),
  581. ratio(p), length(w), unit(0) {}
  582.  
  583.  
  584. /**
  585. * @brief Sets up the SpeedSegment with specified values.
  586. * @param r The row / beat this activates.
  587. * @param p The percentage to use.
  588. * @param w The number of beats/seconds to wait.
  589. * @param k The mode used for the wait variable. */
  590. template <typename StartType>
  591. SpeedSegment(StartType r, float p, float w, unsigned short k):
  592. TimingSegment<SpeedSegment>(max((StartType)0, r)),
  593. ratio(p), length(w), unit(k) {}
  594.  
  595. /**
  596. * @brief Get the ratio in this SpeedSegment.
  597. * @return the ratio. */
  598. float GetRatio() const;
  599.  
  600. /**
  601. * @brief Set the ratio in this SpeedSegment.
  602. * @param i the ratio. */
  603. void SetRatio(const float i);
  604.  
  605. /**
  606. * @brief Get the length in this SpeedSegment.
  607. * @return the length. */
  608. float GetLength() const;
  609.  
  610. /**
  611. * @brief Set the length in this SpeedSegment.
  612. * @param i the length. */
  613. void SetLength(const float i);
  614.  
  615. /**
  616. * @brief Get the unit in this SpeedSegment.
  617. * @return the unit. */
  618. unsigned short GetUnit() const;
  619.  
  620. /**
  621. * @brief Set the unit in this SpeedSegment.
  622. * @param i the unit. */
  623. void SetUnit(const unsigned short i);
  624.  
  625. /**
  626. * @brief Set the unit in this SpeedSegment.
  627. *
  628. * This one is offered for quicker compatibility.
  629. * @param i the unit. */
  630. void SetUnit(const int i);
  631.  
  632. /**
  633. * @brief Compares two SpeedSegments to see if one is less than the other.
  634. * @param other the other SpeedSegment to compare to.
  635. * @return the truth/falsehood of if the first is less than the second.
  636. */
  637. bool operator<( const SpeedSegment &other ) const;
  638. private:
  639. /** @brief The percentage (ratio) to use when multiplying the Player's BPM. */
  640. float ratio;
  641. /**
  642. * @brief The number of beats or seconds to wait for the change to take place.
  643. *
  644. * A value of 0 means this is immediate. */
  645. float length;
  646. /**
  647. * @brief The mode that this segment uses for the math.
  648. *
  649. * 0: beats
  650. * 1: seconds
  651. * other
  652. */
  653. unsigned short unit;
  654.  
  655. };
  656.  
  657. #endif
  658.  
  659. /**
  660. * @file
  661. * @author Jason Felds (c) 2011
  662. * @section LICENSE
  663. * All rights reserved.
  664. *
  665. * Permission is hereby granted, free of charge, to any person obtaining a
  666. * copy of this software and associated documentation files (the
  667. * "Software"), to deal in the Software without restriction, including
  668. * without limitation the rights to use, copy, modify, merge, publish,
  669. * distribute, and/or sell copies of the Software, and to permit persons to
  670. * whom the Software is furnished to do so, provided that the above
  671. * copyright notice(s) and this permission notice appear in all copies of
  672. * the Software and that both the above copyright notice(s) and this
  673. * permission notice appear in supporting documentation.
  674. *
  675. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  676. * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  677. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
  678. * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
  679. * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
  680. * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  681. * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  682. * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  683. * PERFORMANCE OF THIS SOFTWARE.
  684. */
Add Comment
Please, Sign In to add comment