#Structs: Fixed Layout Objects and Some Synchronization Primitives S2

struct Box {
  constructor(x) { this.x = x; }
  x;
}

let box = new Box(0);
box.x = 42;  // x 已声明
assertThrows(() => { box.y = 8.8; });        // 结构体是密封的
assertThrows(() => { box.__proto__ = {}; }); // 结构体是密封的

struct Point extends Box { // 允许，因为 Box 也是结构体
  constructor(x, y) {
    this.y = y;  // this 值立即可用
    super(x);    // 调用超类构造函数
    return {};   // 返回值被丢弃，没有返回覆盖
  }

  distance(other) {
    return Math.sqrt((other.x - this.x) ** 2 +
                     (other.y - this.y) ** 2);
  }

  y;
}

let p = new Point(1, 2);
let fake = { x: 4, y: 5 };
// 方法是非通用的
assertThrows(() => Point.prototype.distance.call(fake, p));
p.distance(fake); // 允许，接收者是 Point

// main.js
shared struct SharedBox {
  x;
}

let sharedBox = new SharedBox();
let sharedBox2 = new SharedBox();

sharedBox.x = 42;          // x 已声明，右侧是原始值
sharedBox.x = sharedBox2;  // x 已声明，右侧是共享的
assertThrows(() => { sharedBox.x = {}; }) // 右侧不是共享结构体

// 可以编程测试一个值是否可以共享
assert(Reflect.canBeShared(sharedBox2));
assert(!Reflect.canBeShared({}));

let worker = new Worker('worker.js');
worker.postMessage({ sharedBox });

sharedBox.x = "main";      // x 已声明，右侧是原始值
console.log(sharedBox.x);

// worker.js
onmessage = function(e) {
  let sharedBox = e.data.sharedBox;
  sharedBox.x = "worker";  // x 已声明，右侧是原始值
  console.log(sharedBox.x);
};

let sharedArray = new SharedArray(100);
assert(sharedArray.length === 100);
for (i = 0; i < sharedArray.length; i++) {
  // 像共享结构体一样，所有元素初始化为 undefined
  assert(sharedArray[i] === undefined);
}

let worker = new Worker('worker_array.js');
worker.postMessage({ sharedArray });

sharedArray[0] = "main";
console.log(sharedArray[0]);

// worker_array.js
onmessage = function(e) {
  let sharedArray = e.data.sharedArray;
  sharedArray[0] = "worker";
  console.log(sharedArray[0]);
};

class Atomics {
  // ... 现有内容

  // 在 struct[fieldName] 上执行 seq-cst 加载。
  static load(struct, fieldName);

  // 在 struct[fieldName] 上执行 value 的 seq-cst 存储。
  static store(struct, fieldName, value);

  // 在 struct[fieldName] 上使用 newValue 执行 seq-cst 交换。
  //
  // newValue 必须是原始值或共享结构体。
  //
  // 返回旧值。
  static exchange(struct, fieldName, newValue);

  // 在 struct[fieldName] 上执行 seq-cst 比较交换。
  //
  // 如果 struct[fieldName] 中的现有值等于 expected，则将其替换为
  // replacement。
  //
  // replacement 必须是原始值或共享结构体。
  //
  // 返回替换前 struct[fieldName] 中的值，
  // 无论值是否被交换。
  static compareExchange(struct, fieldName, expected, replacement);
}

shared struct Atomics.Mutex {
  // 创建一个新的互斥锁。
  constructor();

  // 尝试在 mutex 上获取锁。
  //
  // 如果互斥锁已被锁定，则阻塞当前代理，直到获取锁。
  //
  // 如果 unlockToken 不是 undefined，则它必须是一个空的 UnlockToken。
  //
  // 如果 unlockToken 是 undefined，则返回一个新的 UnlockToken。
  // 否则返回传入的 unlockToken。
  static lock(mutex: Mutex,
              unlockToken: UnlockToken|undefined = undefined)
             : UnlockedToken;

  // 尝试在 mutex 上获取锁。
  //
  // 如果 timeout 不是 Infinity，则只阻塞 timeout 毫秒。如果
  // 操作超时而未获取锁，则返回 null。
  //
  // 如果 timeout 是 0，则如果无法获取锁，则立即返回而不阻塞。
  //
  // unlockToken 的行为与 lock 方法中的相同。
  static lockIfAvailable(mutex: Mutex,
                         timeout: Number,
                         unlockToken: UnlockToken|undefined = undefined)
                        : UnlockToken|null;
}

class Atomics.Mutex.UnlockToken {
  // 创建一个空的 UnlockToken。
  constructor();

  // 如果此令牌非空，则返回 true。
  get locked(): bool;

  // 如果此令牌非空，则解锁底层互斥锁并返回 true。
  // 否则返回 false。
  unlock(): bool;

  // 类似于 unlock，但返回 undefined 而不是 bool。
  [Symbol.dispose](): undefined;
}

shared struct MicrosoftSharePoint {
  x;
  y;
  mutex;
}

let point = new MicrosoftSharePoint();
point.mutex = new Atomics.Mutex();

let worker = new Worker('worker_mutex.js');
worker.postMessage({ point });

// 假设此代理可以阻塞
{
  using lock = Atomics.Mutex.lock(point.mutex);
  point.x = "main";
  point.y = "main";
}

{
  using lock = Atomics.Mutex.lock(point.mutex);
  console.log(point.x, point.y);
}

// worker_mutex.js
onmessage = function(e) {
  let point = e.data.point;
  {
    using lock = Atomics.Mutex.lock(point.mutex);
    point.x = "worker";
    point.y = "worker";
  }
};

shared struct Atomics.Condition {
  // 创建一个新的条件变量。
  constructor();

  // 原子地解锁 unlockToken 并阻塞当前代理，直到 cv 被通知。
  //
  // unlockToken 必须非空。
  //
  // 当代理被恢复时，重新获取 unlockToken 中互斥锁的底层锁，必要时阻塞。
  //
  // 返回 undefined。
  static wait(cv: Condition,
              unlockToken: UnlockToken): undefined

  // 原子地解锁 unlockToken 并阻塞当前代理，直到 cv 被通知或超时。
  //
  // unlockToken 必须非空。
  //
  // timeout 以毫秒为单位。
  //
  // 如果 predicate 不是 undefined，则此方法在 predicate 返回 true 后返回，或
  // 超时后返回。如果超时，则返回 predicate 的最终返回值。每当 predicate 执行时，
  // 会获取 unlockToken 底层互斥锁的锁。
  //
  // 如果 predicate 是 undefined，则如果等待被通知返回 true，超时返回 false。
  static waitFor(cv: Condition,
                 unlockToken: UnlockToken,
                 timeout: Number,
                 predicate: Callable|undefined): bool

  // 通知在条件变量 cv 上等待的 count 个等待者。
  //
  // 返回被通知的等待者数量。
  static notify(cv: Condition,
                count: Number = Infinity)
               : Number;
}