}
            return -1;
        }

        public void add(ScaledUnits<Q> units) {
            this.units.add(units);
            Collections.sort(this.units);
        }
    }

    private static class ScaledUnits<Q> extends Units<Q> {
        private final BaseUnits<Q> baseUnits;

// limitations under the License.

package monitoring

// Unit encodes the standard name for describing the quantity
// measured by a Metric (if applicable).
type Unit string

// Predefined units for use with the monitoring package.
const (
	None         Unit = "1"
	Bytes        Unit = "By"
	Seconds      Unit = "s"
	Milliseconds Unit = "ms"

    }

    def "can add amounts with different units of same quantity"() {
        def sum = Amount.valueOf(valueA, unitsA) + Amount.valueOf(valueB, unitsB)
        expect:
        sum == Amount.valueOf(valueC, unitsC)
        sum.toString() == Amount.valueOf(valueC, unitsC).toString()

        where:
        valueA | unitsA        | valueB | unitsB        | valueC  | unitsC

			break
		}
		b.skip(int(len))
		if len > 0 {
			nunit++
		}
	}
	if b.err != nil {
		return nil, b.err
	}

	// Again, this time writing them down.
	b = makeBuf(d, unknownFormat{}, "info", 0, d.info)
	units := make([]unit, nunit)
	for i := range units {
		u := &units[i]
		u.base = b.off
		var n Offset
		if b.err != nil {
			return nil, b.err
		}
		for n == 0 {

        }
        int diff = units.compareTo(other.units);
        if (diff == 0) {
            return new Amount<>(value.add(other.value), units);
        }
        if (diff < 0) {
            return new Amount<>(value.add(other.units.scaleTo(other.value, units)), units);
        }
        return new Amount<>(units.scaleTo(value, other.units).add(other.value), other.units);
    }

class UnitsTest extends Specification {
    def "can compare units of same quantity"() {
        def base = Units.base(Void.class, "base")
        def units1 = base.times(12, "units1")
        def units2 = base.times(33, "units2")

        expect:
        base < units1
        base < units2
        units1 > base
        units1 < units2
        units2 > base
        units2 > units1
    }

		pkgs = append(pkgs, importpath)
	}
	slices.Sort(pkgs)
	for _, importpath := range pkgs {
		p := fm.pm[importpath]
		units := make([]extcu, 0, len(p.unitTable))
		for u := range p.unitTable {
			units = append(units, u)
		}
		p.sortUnits(units)
		for _, u := range units {
			count := p.unitTable[u]
			file := p.funcs[u.fnfid].file
			if _, err := fmt.Fprintf(w, "%s:%d.%d,%d.%d %d %d\n",

 */
public class OperationProgressDetails {
    private final long progress;
    private final long total;
    private final String units;

    public OperationProgressDetails(long progress, long total, String units) {
        this.progress = progress;
        this.total = total;
        this.units = units;
    }

    public long getProgress() {
        return progress;
    }

    public long getTotal() {

    private final long progress;
    private final long total;
    private final String units;

    public DefaultStatusEvent(long eventTime, DefaultFileDownloadDescriptor descriptor, long progress, long total, String units) {
        super(eventTime, descriptor);
        this.progress = progress;
        this.total = total;
        this.units = units;
    }

    @Override
    public String getDisplayName() {

import java.math.BigDecimal;

public class DataAmount {
    public static final Units<DataAmount> BYTES = Units.base(DataAmount.class, "B");
    public static final Units<DataAmount> KILO_BYTES = BYTES.times(1024, "kB");
    public static final Units<DataAmount> MEGA_BYTES = KILO_BYTES.times(1024, "MB");
    public static final Units<DataAmount> GIGA_BYTES = MEGA_BYTES.times(1024, "GB");