Class Integer

packages/runtime/src/types/integer.ts:34–108

  return roundHalfAwayFromZero(parseFloat(value));
}

// ABAP rounds a half away from zero when a float is moved to an integer,
// on both sides: 0.5 is 1 and -0.5 is -1. Math.round rounds a half towards
// positive infinity, so -0.5 was 0 (and -0 at that)
export function roundHalfAwayFromZero(value: number): number {
  const rounded = value < 0 ? -Math.round(-value) : Math.round(value);
  return rounded === 0 ? 0 : rounded;
}

export class Integer implements INumeric {
  private value: number;
  private constant: boolean = false;
  private integerCalculationType = true;
  private readonly qualifiedName: string | undefined;

  public constructor(input?: {qualifiedName?: string}) {
    this.value = 0;
    this.qualifiedName = input?.qualifiedName;
  }

  /** ABAP determines the calculation type from the operand types, character-like operands raise it
   * above type i even if the intermediate result is integer, ie. "'1.0' * 18 / 16" is not rounded */
  public clearIntegerCalculationType(): Integer {
    this.integerCalculationType = false;
    return this;
  }

  public isIntegerCalculationType(): boolean {
    return this.integerCalculationType;
  }

  public getQualifiedName() {
    return this.qualifiedName;
  }

  public clone(): Integer {
    const n = new Integer({qualifiedName: this.qualifiedName});
    // set without trigger checks and padding
    n.value = this.value;
    return n;
  }

  public setConstant() {
    this.constant = true;
    return this;
  }

  public set(value: INumeric | ICharacter | Hex | string | number | Integer | Float | DecFloat34) {
    if (this.constant === true) {
      throw new Error("Changing constant");
    }

    if (typeof value === "number") {
      this.value = roundHalfAwayFromZero(value);
    } else if (value instanceof Integer) {
      this.set(value.get());
    } else if (value instanceof Character) {
      this.value = toInteger(value.get());