decode method

Unit? decode(dynamic data, { bool allowNull = true, })

Decodes a data to a Unit.

If allowNull is true and the data cannot be decoded successfully, then null is returned. However, if allowNull is false and the data cannot be decoded successfully, then an UnimplementedError is thrown.

The allowNull is very handy when an API changes and a new enum value is added or removed, and users are still using an old app with the old code.

Implementation

Unit? decode(dynamic data, {bool allowNull = true}) {
  if (data != null) {
    switch (data) {
      case r'meter':
        return Unit.meter;
      case r'kilogram':
        return Unit.kilogram;
      case r'second':
        return Unit.second;
      case r'ampere':
        return Unit.ampere;
      case r'kelvin':
        return Unit.kelvin;
      case r'mole':
        return Unit.mole;
      case r'candela':
        return Unit.candela;
      case r'pascal':
        return Unit.pascal;
      case r'joule':
        return Unit.joule;
      case r'watt':
        return Unit.watt;
      case r'newton':
        return Unit.newton;
      case r'coulomb':
        return Unit.coulomb;
      case r'volt':
        return Unit.volt;
      case r'ohm':
        return Unit.ohm;
      case r'farad':
        return Unit.farad;
      case r'henry':
        return Unit.henry;
      case r'tesla':
        return Unit.tesla;
      case r'weber':
        return Unit.weber;
      case r'hertz':
        return Unit.hertz;
      case r'lux':
        return Unit.lux;
      case r'becquerel':
        return Unit.becquerel;
      case r'gray':
        return Unit.gray;
      case r'sievert':
        return Unit.sievert;
      case r'radian':
        return Unit.radian;
      case r'steradian':
        return Unit.steradian;
      case r'lumen':
        return Unit.lumen;
      case r'liter':
        return Unit.liter;
      case r'tonne':
        return Unit.tonne;
      case r'bar':
        return Unit.bar;
      case r'minute':
        return Unit.minute;
      case r'hour':
        return Unit.hour;
      case r'day':
        return Unit.day;
      case r'degree Celsius':
        return Unit.degreeCelsius;
      case r'degree Fahrenheit':
        return Unit.degreeFahrenheit;
      case r'calorie':
        return Unit.calorie;
      case r'electronvolt':
        return Unit.electronvolt;
      case r'astronomical unit':
        return Unit.astronomicalUnit;
      case r'light-year':
        return Unit.lightYear;
      case r'parsec':
        return Unit.parsec;
      case r'angstrom':
        return Unit.angstrom;
      case r'barn':
        return Unit.barn;
      case r'bit':
        return Unit.bit;
      case r'byte':
        return Unit.byte;
      case r'kilobyte':
        return Unit.kilobyte;
      case r'megabyte':
        return Unit.megabyte;
      case r'gigabyte':
        return Unit.gigabyte;
      case r'terabyte':
        return Unit.terabyte;
      case r'cubic meter':
        return Unit.cubicMeter;
      case r'square meter':
        return Unit.squareMeter;
      case r'kilometer':
        return Unit.kilometer;
      case r'mile':
        return Unit.mile;
      case r'foot':
        return Unit.foot;
      case r'inch':
        return Unit.inch;
      case r'yard':
        return Unit.yard;
      case r'gallon':
        return Unit.gallon;
      case r'pint':
        return Unit.pint;
      case r'ounce':
        return Unit.ounce;
      case r'pound':
        return Unit.pound;
      case r'ton':
        return Unit.ton;
      case r'nautical mile':
        return Unit.nauticalMile;
      case r'knots':
        return Unit.knots;
      case r'mach':
        return Unit.mach;
      case r'dyne':
        return Unit.dyne;
      case r'erg':
        return Unit.erg;
      case r'poise':
        return Unit.poise;
      case r'stokes':
        return Unit.stokes;
      case r'atmosphere':
        return Unit.atmosphere;
      case r'decibel':
        return Unit.decibel;
      case r'siemens':
        return Unit.siemens;
      case r'kelvin per watt':
        return Unit.kelvinPerWatt;
      case r'joule per kelvin':
        return Unit.joulePerKelvin;
      case r'kilogram per cubic meter':
        return Unit.kilogramPerCubicMeter;
      case r'cubic meter per second':
        return Unit.cubicMeterPerSecond;
      case r'kilogram per second':
        return Unit.kilogramPerSecond;
      case r'meter per second':
        return Unit.meterPerSecond;
      case r'meter per second squared':
        return Unit.meterPerSecondSquared;
      default:
        if (!allowNull) {
          throw ArgumentError('Unknown enum value to decode: $data');
        }
    }
  }
  return null;
}