LCOV - code coverage report
Current view: top level - lib/src/game - notifying_vector2.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 84 84 100.0 %
Date: 2021-08-10 15:50:53 Functions: 0 0 -

          Line data    Source code
       1             : import 'dart:typed_data';
       2             : import 'package:flutter/foundation.dart';
       3             : import 'package:vector_math/vector_math_64.dart';
       4             : 
       5             : /// Extension of the standard [Vector2] class, implementing the [ChangeNotifier]
       6             : /// functionality. This allows any interested party to be notified when the
       7             : /// value of this vector changes.
       8             : ///
       9             : /// This class can be used as a regular [Vector2] class. However, if you do
      10             : /// subscribe to notifications, don't forget to eventually unsubscribe in
      11             : /// order to avoid resource leaks.
      12             : ///
      13             : /// Direct modification of this vector's [storage] is not allowed.
      14             : ///
      15             : class NotifyingVector2 extends Vector2 with ChangeNotifier {
      16           2 :   NotifyingVector2() : super.zero();
      17             : 
      18           1 :   @override
      19             :   void setValues(double x, double y) {
      20           1 :     super.setValues(x, y);
      21           1 :     notifyListeners();
      22             :   }
      23             : 
      24           1 :   @override
      25             :   void setFrom(Vector2 v) {
      26           1 :     super.setFrom(v);
      27           1 :     notifyListeners();
      28             :   }
      29             : 
      30           1 :   @override
      31             :   void setZero() {
      32           1 :     super.setZero();
      33           1 :     notifyListeners();
      34             :   }
      35             : 
      36           1 :   @override
      37             :   void splat(double arg) {
      38           1 :     super.splat(arg);
      39           1 :     notifyListeners();
      40             :   }
      41             : 
      42           1 :   @override
      43             :   void operator []=(int i, double v) {
      44           1 :     super[i] = v;
      45           1 :     notifyListeners();
      46             :   }
      47             : 
      48           1 :   @override
      49             :   set length(double l) {
      50           1 :     super.length = l;
      51           1 :     notifyListeners();
      52             :   }
      53             : 
      54           1 :   @override
      55             :   double normalize() {
      56           1 :     final l = super.normalize();
      57           1 :     notifyListeners();
      58             :     return l;
      59             :   }
      60             : 
      61           1 :   @override
      62             :   void postmultiply(Matrix2 arg) {
      63           1 :     super.postmultiply(arg);
      64           1 :     notifyListeners();
      65             :   }
      66             : 
      67           1 :   @override
      68             :   void add(Vector2 arg) {
      69           1 :     super.add(arg);
      70           1 :     notifyListeners();
      71             :   }
      72             : 
      73           1 :   @override
      74             :   void addScaled(Vector2 arg, double factor) {
      75           1 :     super.addScaled(arg, factor);
      76           1 :     notifyListeners();
      77             :   }
      78             : 
      79           1 :   @override
      80             :   void sub(Vector2 arg) {
      81           1 :     super.sub(arg);
      82           1 :     notifyListeners();
      83             :   }
      84             : 
      85           1 :   @override
      86             :   void multiply(Vector2 arg) {
      87           1 :     super.multiply(arg);
      88           1 :     notifyListeners();
      89             :   }
      90             : 
      91           1 :   @override
      92             :   void divide(Vector2 arg) {
      93           1 :     super.divide(arg);
      94           1 :     notifyListeners();
      95             :   }
      96             : 
      97           1 :   @override
      98             :   void scale(double arg) {
      99           1 :     super.scale(arg);
     100           1 :     notifyListeners();
     101             :   }
     102             : 
     103           1 :   @override
     104             :   void negate() {
     105           1 :     super.negate();
     106           1 :     notifyListeners();
     107             :   }
     108             : 
     109           1 :   @override
     110             :   void absolute() {
     111           1 :     super.absolute();
     112           1 :     notifyListeners();
     113             :   }
     114             : 
     115           1 :   @override
     116             :   void clamp(Vector2 min, Vector2 max) {
     117           1 :     super.clamp(min, max);
     118           1 :     notifyListeners();
     119             :   }
     120             : 
     121           1 :   @override
     122             :   void clampScalar(double min, double max) {
     123           1 :     super.clampScalar(min, max);
     124           1 :     notifyListeners();
     125             :   }
     126             : 
     127           1 :   @override
     128             :   void floor() {
     129           1 :     super.floor();
     130           1 :     notifyListeners();
     131             :   }
     132             : 
     133           1 :   @override
     134             :   void ceil() {
     135           1 :     super.ceil();
     136           1 :     notifyListeners();
     137             :   }
     138             : 
     139           1 :   @override
     140             :   void round() {
     141           1 :     super.round();
     142           1 :     notifyListeners();
     143             :   }
     144             : 
     145           1 :   @override
     146             :   void roundToZero() {
     147           1 :     super.roundToZero();
     148           1 :     notifyListeners();
     149             :   }
     150             : 
     151           1 :   @override
     152             :   void copyFromArray(List<double> array, [int offset = 0]) {
     153           1 :     super.copyFromArray(array, offset);
     154           1 :     notifyListeners();
     155             :   }
     156             : 
     157           1 :   @override
     158             :   set xy(Vector2 arg) {
     159           1 :     super.xy = arg;
     160           1 :     notifyListeners();
     161             :   }
     162             : 
     163           1 :   @override
     164             :   set yx(Vector2 arg) {
     165           1 :     super.yx = arg;
     166           1 :     notifyListeners();
     167             :   }
     168             : 
     169           1 :   @override
     170             :   set x(double x) {
     171           1 :     super.x = x;
     172           1 :     notifyListeners();
     173             :   }
     174             : 
     175           1 :   @override
     176             :   set y(double y) {
     177           1 :     super.y = y;
     178           1 :     notifyListeners();
     179             :   }
     180             : 
     181           1 :   @override
     182           2 :   Float64List get storage => UnmodifiableFloat64ListView(super.storage);
     183             : }

Generated by: LCOV version 1.15