reign/lib/type-class/primitive-type/index.js

A persistent, typed-objects implementation.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Primitive = exports.MIN_TYPE_ID = undefined;
exports.make = make;

var _backing = require("backing");

var _backing2 = _interopRequireDefault(_backing);

var _ = require("../");

var _2 = require("../../");

var _symbols = require("../../symbols");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const MIN_TYPE_ID = exports.MIN_TYPE_ID = 1;

class Primitive extends _.TypedObject {}

exports.Primitive = Primitive; /**
                                * Makes a PrimitiveType type class for a given realm.
                                */

function make(realm) {
  const TypeClass = realm.TypeClass;
  const backing = realm.backing;

  let typeCounter = 0;

  return new TypeClass('PrimitiveType', config => {
    return primitive => {
      typeCounter++;
      const name = config.name || `%Primitive<0x${ typeCounter.toString(16) }>`;
      const id = config.id || MIN_TYPE_ID + typeCounter;

      // Issue 252
      primitive[_symbols.$CanBeEmbedded] = true;
      // Issue 252
      primitive[_symbols.$CanBeReferenced] = false;
      // Issue 252
      primitive[_symbols.$CanContainReferences] = false;
      let PrimitiveArray;
      // Issue 285
      Object.defineProperties(primitive, {
        Array: {
          get: function get() {
            if (PrimitiveArray === undefined) {
              PrimitiveArray = new realm.ArrayType(primitive);
            }
            return PrimitiveArray;
          }
        }
      });
      return Object.assign({
        name: name,
        id: id,
        gc: false,
        accepts: function accepts(input) {
          return false;
        },
        cast: function cast(input) {
          return input;
        },
        initialize: function initialize(backing, address, initialValue) {
          primitive.store(backing, address, initialValue);
        },
        clear: function clear(backing, address) {
          primitive.store(backing, address, primitive.emptyValue());
        },
        destructor: function destructor() {
          // no-op
        },
        constructor: function constructor(input, address) {
          if (this instanceof Primitive) {
            throw new TypeError(`${ name } is not a constructor.`);
          }
          return primitive.cast(input);
        },

        prototype: Primitive.prototype,
        equal: function equal(valueA, valueB) {
          return valueA === valueB;
        },
        compareValues: function compareValues(valueA, valueB) {
          if (valueA === valueB) {
            return 0;
          } else if (valueA > valueB) {
            return 1;
          } else {
            return -1;
          }
        },
        compareAddresses: function compareAddresses(backing, addressA, addressB) {
          if (addressA === addressB) {
            return 0;
          } else if (addressA === 0) {
            return -1;
          } else if (addressB === 0) {
            return 1;
          }

          const valueA = primitive.load(backing, addressA);
          const valueB = primitive.load(backing, addressB);
          if (valueA === valueB) {
            return 0;
          } else if (valueA > valueB) {
            return 1;
          } else {
            return -1;
          }
        },
        compareAddressValue: function compareAddressValue(backing, address, value) {
          const loaded = primitive.load(backing, address);
          if (loaded === value) {
            return 0;
          } else if (loaded > value) {
            return 1;
          } else {
            return -1;
          }
        }
      }, config);
    };
  });
};