// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// This file contains the definition of Link as well as the structure
// of the data it holds.

library fuchsia.modular;

using fuchsia.mem;

// This interface is implemented by the story runner. The ModuleContext service
// acts as a factory for it.
//
// An instance of Link holds one of two types of values:
//
// (1) A JSON string that can be modified incrementally or completely
//     overwritten, depending on the use of Set() and Update(). The JSON string
//     is set to "null" when the Link is created.
//
// (2) An entity reference that can be set or retrieved with SetEntity() and
//     GetEntity().
//
// Each Module instance receives one Link instance for each parameter of its
// action template in its ModuleContext. It receives its ModuleContext in
// Module.Initialize() or in its service namespace. The Module can access its
// Links by calling ModuleContext.GetLink() with the intent parameter name as
// the link name. These instances are shared with the parent Module if there is
// any, or with the StoryController client if the Module is a top level Module
// of a Story. A Module can create additional Link instances by calling
// ModuleContext.GetLink() with any other link name. Why would it do that? To
// share the new Link instance with Modules it requests to start in turn, or to
// record its own state in the story record, so that it is transferred to other
// devices that run the same story, or to persist it for later resumption of the
// story.
//
// A client may obtain another handle to the same Link instance by calling
// GetLink() with the same name again.
//
// A client of Link can set the JSON string stored in the instance and register
// a handler (an implementation of the LinkWatcher interface) to be notified of
// changes to the JSON string in the Link. A client may or may not be notified
// of changes it itself makes to the Link value, depending on whether it
// registers with WatchAll() or Watch(), respectively. If the client registers
// with Watch(), then it will not be notified of changes made through the same
// Link connection.
//
// No service name: returned from ModuleContext.GetLink().
interface Link {
    // Gets the value at the given |path|, which is represented using the JSON
    // Pointer specification (https://tools.ietf.org/html/rfc6901).
    //
    // |json_data| is a UTF8 encoded string representing valid JSON.
    //
    // Returns null if |path| does not exist. Returns the entire JSON object
    // if |path| is either null or an empty array. Returns the string "null" if
    // the link is empty.
    2: Get(vector<string>? path) -> (fuchsia.mem.Buffer? json_data);

    // Set() overwrites the value/object/array at the given |path|. Set also
    // overwrites any values or arrays as necessary to ensure that |path| exists.
    // The |json_data| parameter must be a UTF8 encoded JSON string.
    // Either pass "null" to set the value to null, or use Erase to
    // completely remove a member of an object. To replace the root, pass null for
    // |path|.
    //
    // This call notifies Watchers, although this may be skipped if nothing
    // changed.
    3: Set(vector<string>? path, fuchsia.mem.Buffer json_data);

    // Erases the object member at the given |path|. If the path is not found or
    // does not match the current structure of the JSON, the path will not be
    // created and the call is ignored. The |path| parameter cannot be null or
    // zero length because the root is a value, not a key. This call notifies
    // Watchers, although this may be skipped if nothing changed.
    5: Erase(vector<string> path);

    // Returns the entity reference in this link. If no entity reference is
    // present, returns a null fidl string.
    9: GetEntity() -> (string? entity_reference);

    // Sets this to be an Entity Link with the given |entity_reference|. The
    // existing value of the link is overwritten. If |entity_reference| is null,
    // then any existing value in the link is overwritten with the JSON string
    // "null".
    10: SetEntity(string? entity_reference);

    // Registers a watcher, which is notified whenever the document changes. This
    // watcher will not be invoked for changes caused by calls made on this
    // handle. The Notify() callback method will be immediately invoked with the
    // value in the Link, even if it's empty.
    //
    // The LinkWatcher connection will be closed if the owning Link handle closed.

    // All connections to a Link and LinkWatcher are closed once the story the
    // link belongs to is stopped.
    6: Watch(LinkWatcher watcher);

    // Like Watch(), but the watcher is notified also of changes made through the
    // same handle as the watcher is registered on.
    7: WatchAll(LinkWatcher watcher);

    // Waits for the completion of methods previously invoked on the same
    // connection. Allows to create sequentiality across service instances without
    // giving every method an empty return value. Nb. this makes no guarantees
    // about sequentiality with methods invoked on different connections, even to
    // the same Link instance.
    8: Sync() -> ();
};

// This interface is implemented by a client of Link.
//
// The Notify() method is invoked whenever the Link changes. The entire JSON
// string in the Link will be sent. In other words, this isn't an incremental
// notification. |json| cannot be null because an empty Link is the valid JSON
// document "null".
//
// No service name: created by Module.
interface LinkWatcher {
    1: Notify(fuchsia.mem.Buffer json);
};