blob: 83e52024631eb0f33e8b11c4de679bc7450c58e8 [file] [log] [blame]
// Copyright 2018 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.
//
// Code generated by third_party/go/regen-fidl; DO NOT EDIT.
package io
import (
_strings "strings"
_zx "syscall/zx"
_bindings "syscall/zx/fidl"
fuchsiaunknown "syscall/zx/unknown"
)
const (
CloseAll InotifyWatchMask = 24
// Nodes which do not have ino values should return this value
// from Readdir and GetAttr.
InoUnknown uint64 = 18446744073709551615
// The maximal buffer size which can be transmitted for buffered operations.
// This capacity is currently set somewhat arbitrarily.
MaxBuf uint64 = 8192
// The maximum length, in bytes, of a single filesystem component.
MaxFilename uint64 = 255
MaxFsNameBuffer uint64 = 32
// The maximum length, in bytes, of a single filesystem component.
MaxNameLength uint64 = 255
// The maximum length, in bytes, of a filesystem string.
MaxPath uint64 = 4096
// The maximum length, in bytes, of a filesystem path.
MaxPathLength uint64 = 4095
// The maximum I/O size that is allowed for read/write operations using
// byte vectors.
MaxTransferSize uint64 = 8192
// Bits reserved for posix protections. Native fuchsia filesystems
// are not required to set bits contained within `MODE_PROTECTION_MASK`,
// but filesystems that wish to do so may refer to sys/stat.h for their
// definitions.
ModeProtectionMask uint32 = 4095
ModeTypeBlockDevice uint32 = 24576
ModeTypeDirectory uint32 = 16384
ModeTypeFile uint32 = 32768
// Bits indicating node type. The canonical mechanism to check
// for a node type is to take 'mode', bitwise AND it with the
// `MODE_TYPE_MASK`, and check exact equality against a mode type.
ModeTypeMask uint32 = 1044480
ModeTypeService uint32 = 65536
Move InotifyWatchMask = 192
// Flags used when opening a node reference must fall within this mask.
OpenFlagsAllowedWithNodeReference OpenFlags = 46661632
// All known rights.
OpenRights OpenFlags = 11
// Alias for directory permission alias rw*
RwStarDir Operations = 503
// Alias for directory permission alias rx*
RxStarDir Operations = 219
// Alias for directory permission alias r*
RStarDir Operations = 211
// Alias for directory permission alias w*
WStarDir Operations = 485
// Alias for directory permission alias x*
XStarDir Operations = 201
)
var _ _bindings.Enum = AdvisoryLockType(0)
type AdvisoryLockType uint32
const (
// Zero or more connections can hold read locks on a file simultaneously.
AdvisoryLockTypeRead AdvisoryLockType = 1
// At most one connection can hold a write lock on a file simultaneously.
// When a write lock is held on a file, no other types of locks can be held
// on that file.
AdvisoryLockTypeWrite AdvisoryLockType = 2
// The region specifies a region to be unlocked.
AdvisoryLockTypeUnlock AdvisoryLockType = 3
)
func (_ AdvisoryLockType) I_EnumValues() []AdvisoryLockType {
return []AdvisoryLockType{
AdvisoryLockTypeRead,
AdvisoryLockTypeWrite,
AdvisoryLockTypeUnlock,
}
}
func (_ AdvisoryLockType) I_EnumIsStrict() bool {
return true
}
func (x AdvisoryLockType) IsUnknown() bool {
switch x {
case 1:
return false
case 2:
return false
case 3:
return false
}
return true
}
func (x AdvisoryLockType) String() string {
switch x {
case 1:
return "Read"
case 2:
return "Write"
case 3:
return "Unlock"
}
return "Unknown"
}
var _ _bindings.Enum = DirentType(0)
type DirentType uint8
const (
// A dirent with an unknown type.
DirentTypeUnknown DirentType = 0
// A dirent representing a directory object.
DirentTypeDirectory DirentType = 4
// A dirent representing a block device object.
DirentTypeBlockDevice DirentType = 6
// A dirent representing a file object.
DirentTypeFile DirentType = 8
// A dirent representing a service object.
DirentTypeService DirentType = 16
)
func (_ DirentType) I_EnumValues() []DirentType {
return []DirentType{
DirentTypeUnknown,
DirentTypeDirectory,
DirentTypeBlockDevice,
DirentTypeFile,
DirentTypeService,
}
}
func (_ DirentType) I_EnumIsStrict() bool {
return true
}
func (x DirentType) IsUnknown() bool {
switch x {
case 0:
return false
case 4:
return false
case 6:
return false
case 8:
return false
case 16:
return false
}
return true
}
func (x DirentType) String() string {
switch x {
case 0:
return "Unknown"
case 4:
return "Directory"
case 6:
return "BlockDevice"
case 8:
return "File"
case 16:
return "Service"
}
return "Unknown"
}
var _ _bindings.Enum = OpenMode(0)
type OpenMode uint32
const (
// Only succeed if the object exists.
OpenModeOpenExisting OpenMode = 1
// Create the object if it does not exist, otherwise open
// existing. The check and the creation are performed in
// one atomic step.
OpenModeMaybeCreate OpenMode = 2
// Assert that the object does not exist, then create it.
// The assertion and creation are performed in one atomic
// step.
OpenModeAlwaysCreate OpenMode = 3
)
func (_ OpenMode) I_EnumValues() []OpenMode {
return []OpenMode{
OpenModeOpenExisting,
OpenModeMaybeCreate,
OpenModeAlwaysCreate,
}
}
func (_ OpenMode) I_EnumIsStrict() bool {
return true
}
func (x OpenMode) IsUnknown() bool {
switch x {
case 1:
return false
case 2:
return false
case 3:
return false
}
return true
}
func (x OpenMode) String() string {
switch x {
case 1:
return "OpenExisting"
case 2:
return "MaybeCreate"
case 3:
return "AlwaysCreate"
}
return "Unknown"
}
var _ _bindings.Enum = RightsResolution(0)
type RightsResolution uint32
const (
// The rights will be the intersection between [`RightsRequest.at_most`]
// and the connection where the `Open`/`Reopen` request was received,
// closing `object_request` with `ZX_ERR_ACCESS_DENIED` if it is empty.
RightsResolutionMaximize RightsResolution = 1
// The rights will be determined by the following rules:
//
// * If the negotiated protocol on the new connection is
// [`Directory`], the rules from the `MAXIMIZE` case applies.
// * Otherwise, the rights will be [`RightsRequest.at_least`] if it
// does not exceed rights on the current connection.
// * Otherwise, `object_request` should be closed with
// `ZX_ERR_ACCESS_DENIED`.
//
// The motivation for this enum is to facilitate implementing POSIX
// compatibility layers. The POSIX file permission model relies on ambient
// authority: access control on files are resolved based on the `mode` of
// the file, and the current user. There is no concept of hierarchical
// permissions. Fuchsia, on the other hand, restricts rights on file
// connections to never exceed that of its containing directory connection.
RightsResolutionPosix RightsResolution = 2
)
func (_ RightsResolution) I_EnumValues() []RightsResolution {
return []RightsResolution{
RightsResolutionMaximize,
RightsResolutionPosix,
}
}
func (_ RightsResolution) I_EnumIsStrict() bool {
return true
}
func (x RightsResolution) IsUnknown() bool {
switch x {
case 1:
return false
case 2:
return false
}
return true
}
func (x RightsResolution) String() string {
switch x {
case 1:
return "Maximize"
case 2:
return "Posix"
}
return "Unknown"
}
var _ _bindings.Enum = SeekOrigin(0)
// The reference point for updating the seek offset. See [`File.Seek`].
//
// This enum matches the `zx_stream_seek_origin_t` enum.
type SeekOrigin uint32
const (
// Seek from the start of the file.
// The seek offset will be set to `offset` bytes.
// The seek offset cannot be negative in this case.
SeekOriginStart SeekOrigin = 0
// Seek from the current position in the file.
// The seek offset will be the current seek offset plus `offset` bytes.
SeekOriginCurrent SeekOrigin = 1
// Seek from the end of the file.
// The seek offset will be the file size plus `offset` bytes.
SeekOriginEnd SeekOrigin = 2
)
func (_ SeekOrigin) I_EnumValues() []SeekOrigin {
return []SeekOrigin{
SeekOriginStart,
SeekOriginCurrent,
SeekOriginEnd,
}
}
func (_ SeekOrigin) I_EnumIsStrict() bool {
return true
}
func (x SeekOrigin) IsUnknown() bool {
switch x {
case 0:
return false
case 1:
return false
case 2:
return false
}
return true
}
func (x SeekOrigin) String() string {
switch x {
case 0:
return "Start"
case 1:
return "Current"
case 2:
return "End"
}
return "Unknown"
}
var _ _bindings.Enum = WatchEvent(0)
type WatchEvent uint8
const (
// Indicates the directory being watched has been deleted.
WatchEventDeleted WatchEvent = 0
// Indicates a node has been created (either new or moved) into a directory.
WatchEventAdded WatchEvent = 1
// Identifies a node has been removed (either deleted or moved) from the directory.
WatchEventRemoved WatchEvent = 2
// Identifies a node already existed in the directory when watching started.
WatchEventExisting WatchEvent = 3
// Identifies that no more `EXISTING` events will be sent.
WatchEventIdle WatchEvent = 4
)
func (_ WatchEvent) I_EnumValues() []WatchEvent {
return []WatchEvent{
WatchEventDeleted,
WatchEventAdded,
WatchEventRemoved,
WatchEventExisting,
WatchEventIdle,
}
}
func (_ WatchEvent) I_EnumIsStrict() bool {
return true
}
func (x WatchEvent) IsUnknown() bool {
switch x {
case 0:
return false
case 1:
return false
case 2:
return false
case 3:
return false
case 4:
return false
}
return true
}
func (x WatchEvent) String() string {
switch x {
case 0:
return "Deleted"
case 1:
return "Added"
case 2:
return "Removed"
case 3:
return "Existing"
case 4:
return "Idle"
}
return "Unknown"
}
var _ _bindings.Bits = ConnectorFlags(0)
type ConnectorFlags uint64
const (
ConnectorFlags_Mask ConnectorFlags = 0
)
func (_ ConnectorFlags) I_BitsMask() ConnectorFlags {
return ConnectorFlags_Mask
}
func (_ ConnectorFlags) I_BitsIsStrict() bool {
return false
}
func (x ConnectorFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x ConnectorFlags) GetUnknownBits() uint64 {
return uint64(^ConnectorFlags_Mask & x)
}
func (x ConnectorFlags) InvertBits() ConnectorFlags {
return ConnectorFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x ConnectorFlags) HasBits(mask ConnectorFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x ConnectorFlags) ClearBits(mask ConnectorFlags) ConnectorFlags {
return ^mask & x
}
func (x ConnectorFlags) String() string {
var buf _strings.Builder
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = FileProtocolFlags(0)
type FileProtocolFlags uint64
const (
FileProtocolFlagsAppend FileProtocolFlags = 1
FileProtocolFlagsTruncate FileProtocolFlags = 2
FileProtocolFlags_Mask FileProtocolFlags = 3
)
func (_ FileProtocolFlags) I_BitsMask() FileProtocolFlags {
return FileProtocolFlags_Mask
}
func (_ FileProtocolFlags) I_BitsIsStrict() bool {
return false
}
func (x FileProtocolFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x FileProtocolFlags) GetUnknownBits() uint64 {
return uint64(^FileProtocolFlags_Mask & x)
}
func (x FileProtocolFlags) InvertBits() FileProtocolFlags {
return FileProtocolFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x FileProtocolFlags) HasBits(mask FileProtocolFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x FileProtocolFlags) ClearBits(mask FileProtocolFlags) FileProtocolFlags {
return ^mask & x
}
func (x FileProtocolFlags) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Append")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Truncate")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = FileSignal(0)
type FileSignal uint32
const (
FileSignalReadable FileSignal = 16777216
FileSignalWritable FileSignal = 33554432
FileSignal_Mask FileSignal = 50331648
)
func (_ FileSignal) I_BitsMask() FileSignal {
return FileSignal_Mask
}
func (_ FileSignal) I_BitsIsStrict() bool {
return true
}
func (x FileSignal) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x FileSignal) GetUnknownBits() uint64 {
return uint64(^FileSignal_Mask & x)
}
func (x FileSignal) InvertBits() FileSignal {
return FileSignal_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x FileSignal) HasBits(mask FileSignal) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x FileSignal) ClearBits(mask FileSignal) FileSignal {
return ^mask & x
}
func (x FileSignal) String() string {
var buf _strings.Builder
if 16777216&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Readable")
}
if 33554432&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Writable")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = InotifyWatchMask(0)
// Used by InotifyAddWatch to indicate the server the events to be watched on.
// Also used by [`Node.Inotify`] to indicate the types of events
// that occurred on server side, to be notified to clients. See InotifyEvent.
type InotifyWatchMask uint32
const (
InotifyWatchMaskAccess InotifyWatchMask = 1
InotifyWatchMaskModify InotifyWatchMask = 2
InotifyWatchMaskAttrib InotifyWatchMask = 4
InotifyWatchMaskCloseWrite InotifyWatchMask = 8
InotifyWatchMaskCloseNowrite InotifyWatchMask = 16
InotifyWatchMaskOpen InotifyWatchMask = 32
InotifyWatchMaskMovedFrom InotifyWatchMask = 64
InotifyWatchMaskMovedTo InotifyWatchMask = 128
InotifyWatchMaskCreate InotifyWatchMask = 256
InotifyWatchMaskDelete InotifyWatchMask = 512
InotifyWatchMaskDeleteSelf InotifyWatchMask = 1024
InotifyWatchMaskMoveSelf InotifyWatchMask = 2048
InotifyWatchMaskUnmount InotifyWatchMask = 8192
InotifyWatchMaskQOverflow InotifyWatchMask = 16384
InotifyWatchMaskIgnored InotifyWatchMask = 32768
InotifyWatchMaskOnlydir InotifyWatchMask = 16777216
InotifyWatchMaskDontFollow InotifyWatchMask = 33554432
InotifyWatchMaskExclUnlink InotifyWatchMask = 67108864
InotifyWatchMaskMaskCreate InotifyWatchMask = 268435456
InotifyWatchMaskMaskAdd InotifyWatchMask = 536870912
InotifyWatchMaskIsdirectory InotifyWatchMask = 1073741824
InotifyWatchMaskOneshot InotifyWatchMask = 2147483648
InotifyWatchMask_Mask InotifyWatchMask = 4144033791
)
func (_ InotifyWatchMask) I_BitsMask() InotifyWatchMask {
return InotifyWatchMask_Mask
}
func (_ InotifyWatchMask) I_BitsIsStrict() bool {
return true
}
func (x InotifyWatchMask) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x InotifyWatchMask) GetUnknownBits() uint64 {
return uint64(^InotifyWatchMask_Mask & x)
}
func (x InotifyWatchMask) InvertBits() InotifyWatchMask {
return InotifyWatchMask_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x InotifyWatchMask) HasBits(mask InotifyWatchMask) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x InotifyWatchMask) ClearBits(mask InotifyWatchMask) InotifyWatchMask {
return ^mask & x
}
func (x InotifyWatchMask) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Access")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Modify")
}
if 4&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Attrib")
}
if 8&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("CloseWrite")
}
if 16&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("CloseNowrite")
}
if 32&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Open")
}
if 64&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("MovedFrom")
}
if 128&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("MovedTo")
}
if 256&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Create")
}
if 512&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Delete")
}
if 1024&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("DeleteSelf")
}
if 2048&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("MoveSelf")
}
if 8192&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Unmount")
}
if 16384&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("QOverflow")
}
if 32768&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Ignored")
}
if 16777216&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Onlydir")
}
if 33554432&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("DontFollow")
}
if 67108864&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("ExclUnlink")
}
if 268435456&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("MaskCreate")
}
if 536870912&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("MaskAdd")
}
if 1073741824&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Isdirectory")
}
if 2147483648&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Oneshot")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = NodeAttributeFlags(0)
// The fields of 'attributes' which are used to update the Node are indicated
// by the 'flags' argument.
type NodeAttributeFlags uint32
const (
NodeAttributeFlagsCreationTime NodeAttributeFlags = 1
NodeAttributeFlagsModificationTime NodeAttributeFlags = 2
NodeAttributeFlags_Mask NodeAttributeFlags = 3
)
func (_ NodeAttributeFlags) I_BitsMask() NodeAttributeFlags {
return NodeAttributeFlags_Mask
}
func (_ NodeAttributeFlags) I_BitsIsStrict() bool {
return true
}
func (x NodeAttributeFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x NodeAttributeFlags) GetUnknownBits() uint64 {
return uint64(^NodeAttributeFlags_Mask & x)
}
func (x NodeAttributeFlags) InvertBits() NodeAttributeFlags {
return NodeAttributeFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x NodeAttributeFlags) HasBits(mask NodeAttributeFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeAttributeFlags) ClearBits(mask NodeAttributeFlags) NodeAttributeFlags {
return ^mask & x
}
func (x NodeAttributeFlags) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("CreationTime")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("ModificationTime")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = NodeAttributesQuery(0)
type NodeAttributesQuery uint64
const (
NodeAttributesQueryProtocols NodeAttributesQuery = 1
NodeAttributesQueryAbilities NodeAttributesQuery = 2
NodeAttributesQueryContentSize NodeAttributesQuery = 4
NodeAttributesQueryStorageSize NodeAttributesQuery = 8
NodeAttributesQueryLinkCount NodeAttributesQuery = 16
NodeAttributesQueryId NodeAttributesQuery = 32
NodeAttributesQueryCreationTime NodeAttributesQuery = 64
NodeAttributesQueryModificationTime NodeAttributesQuery = 128
NodeAttributesQuery_Mask NodeAttributesQuery = 255
)
func (_ NodeAttributesQuery) I_BitsMask() NodeAttributesQuery {
return NodeAttributesQuery_Mask
}
func (_ NodeAttributesQuery) I_BitsIsStrict() bool {
return true
}
func (x NodeAttributesQuery) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x NodeAttributesQuery) GetUnknownBits() uint64 {
return uint64(^NodeAttributesQuery_Mask & x)
}
func (x NodeAttributesQuery) InvertBits() NodeAttributesQuery {
return NodeAttributesQuery_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x NodeAttributesQuery) HasBits(mask NodeAttributesQuery) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeAttributesQuery) ClearBits(mask NodeAttributesQuery) NodeAttributesQuery {
return ^mask & x
}
func (x NodeAttributesQuery) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Protocols")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Abilities")
}
if 4&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("ContentSize")
}
if 8&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("StorageSize")
}
if 16&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("LinkCount")
}
if 32&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Id")
}
if 64&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("CreationTime")
}
if 128&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("ModificationTime")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = NodeFlags(0)
type NodeFlags uint64
const (
NodeFlagsGetRepresentation NodeFlags = 1
NodeFlags_Mask NodeFlags = 1
)
func (_ NodeFlags) I_BitsMask() NodeFlags {
return NodeFlags_Mask
}
func (_ NodeFlags) I_BitsIsStrict() bool {
return false
}
func (x NodeFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x NodeFlags) GetUnknownBits() uint64 {
return uint64(^NodeFlags_Mask & x)
}
func (x NodeFlags) InvertBits() NodeFlags {
return NodeFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x NodeFlags) HasBits(mask NodeFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeFlags) ClearBits(mask NodeFlags) NodeFlags {
return ^mask & x
}
func (x NodeFlags) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("GetRepresentation")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = NodeProtocolKinds(0)
// A node may have multiple supported representations when opening, even though
// it may have a fixed underlying identity.
//
// Today, a file is accessed via the [`File`] protocol, and sends a
// [`Representation.FileInfo`] when opened with `GET_REPRESENTATION`. However,
// in the future we might introduce a more sophisticated `FileV2` protocol, or
// a more efficient `SuperFastFile` backed by a specialized kernel object. New
// clients can request the more advanced representations by specifying the
// corresponding bits in [`NodeProtocolKinds`], whereas existing clients would
// continue to talk to the node via the old representation.
//
// [`NodeProtocolKinds`] enables forward-compatibility through a form of protocol
// negotiation.
//
// The elements have one-to-one correspondence with the members of
// [`Representation`].
type NodeProtocolKinds uint64
const (
NodeProtocolKindsConnector NodeProtocolKinds = 1
NodeProtocolKindsDirectory NodeProtocolKinds = 2
NodeProtocolKindsFile NodeProtocolKinds = 4
NodeProtocolKinds_Mask NodeProtocolKinds = 7
)
func (_ NodeProtocolKinds) I_BitsMask() NodeProtocolKinds {
return NodeProtocolKinds_Mask
}
func (_ NodeProtocolKinds) I_BitsIsStrict() bool {
return false
}
func (x NodeProtocolKinds) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x NodeProtocolKinds) GetUnknownBits() uint64 {
return uint64(^NodeProtocolKinds_Mask & x)
}
func (x NodeProtocolKinds) InvertBits() NodeProtocolKinds {
return NodeProtocolKinds_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x NodeProtocolKinds) HasBits(mask NodeProtocolKinds) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x NodeProtocolKinds) ClearBits(mask NodeProtocolKinds) NodeProtocolKinds {
return ^mask & x
}
func (x NodeProtocolKinds) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Connector")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Directory")
}
if 4&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("File")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = OpenFlags(0)
type OpenFlags uint32
const (
OpenFlagsRightReadable OpenFlags = 1
OpenFlagsRightWritable OpenFlags = 2
OpenFlagsRightExecutable OpenFlags = 8
OpenFlagsCreate OpenFlags = 65536
OpenFlagsCreateIfAbsent OpenFlags = 131072
OpenFlagsTruncate OpenFlags = 262144
OpenFlagsDirectory OpenFlags = 524288
OpenFlagsAppend OpenFlags = 1048576
OpenFlagsNodeReference OpenFlags = 4194304
OpenFlagsDescribe OpenFlags = 8388608
OpenFlagsPosixWritable OpenFlags = 134217728
OpenFlagsPosixExecutable OpenFlags = 268435456
OpenFlagsNotDirectory OpenFlags = 33554432
OpenFlagsCloneSameRights OpenFlags = 67108864
OpenFlags_Mask OpenFlags = 517931019
)
func (_ OpenFlags) I_BitsMask() OpenFlags {
return OpenFlags_Mask
}
func (_ OpenFlags) I_BitsIsStrict() bool {
return true
}
func (x OpenFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x OpenFlags) GetUnknownBits() uint64 {
return uint64(^OpenFlags_Mask & x)
}
func (x OpenFlags) InvertBits() OpenFlags {
return OpenFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x OpenFlags) HasBits(mask OpenFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x OpenFlags) ClearBits(mask OpenFlags) OpenFlags {
return ^mask & x
}
func (x OpenFlags) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("RightReadable")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("RightWritable")
}
if 8&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("RightExecutable")
}
if 65536&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Create")
}
if 131072&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("CreateIfAbsent")
}
if 262144&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Truncate")
}
if 524288&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Directory")
}
if 1048576&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Append")
}
if 4194304&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("NodeReference")
}
if 8388608&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Describe")
}
if 134217728&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("PosixWritable")
}
if 268435456&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("PosixExecutable")
}
if 33554432&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("NotDirectory")
}
if 67108864&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("CloneSameRights")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = Operations(0)
// The common members definition behind [`Rights`] and [`Abilities`].
// Note that Directory operations are distinct from File operations, with the
// exception of some common operations (e.g. `GET_ATTRIBUTES`) defined on the
// underlying [`Node`].
type Operations uint64
const (
OperationsConnect Operations = 1
OperationsReadBytes Operations = 2
OperationsWriteBytes Operations = 4
OperationsExecute Operations = 8
OperationsGetAttributes Operations = 16
OperationsUpdateAttributes Operations = 32
OperationsEnumerate Operations = 64
OperationsTraverse Operations = 128
OperationsModifyDirectory Operations = 256
Operations_Mask Operations = 511
)
func (_ Operations) I_BitsMask() Operations {
return Operations_Mask
}
func (_ Operations) I_BitsIsStrict() bool {
return true
}
func (x Operations) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x Operations) GetUnknownBits() uint64 {
return uint64(^Operations_Mask & x)
}
func (x Operations) InvertBits() Operations {
return Operations_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x Operations) HasBits(mask Operations) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x Operations) ClearBits(mask Operations) Operations {
return ^mask & x
}
func (x Operations) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Connect")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("ReadBytes")
}
if 4&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("WriteBytes")
}
if 8&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Execute")
}
if 16&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("GetAttributes")
}
if 32&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("UpdateAttributes")
}
if 64&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Enumerate")
}
if 128&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Traverse")
}
if 256&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("ModifyDirectory")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = UnlinkFlags(0)
type UnlinkFlags uint64
const (
UnlinkFlagsMustBeDirectory UnlinkFlags = 1
UnlinkFlags_Mask UnlinkFlags = 1
)
func (_ UnlinkFlags) I_BitsMask() UnlinkFlags {
return UnlinkFlags_Mask
}
func (_ UnlinkFlags) I_BitsIsStrict() bool {
return true
}
func (x UnlinkFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x UnlinkFlags) GetUnknownBits() uint64 {
return uint64(^UnlinkFlags_Mask & x)
}
func (x UnlinkFlags) InvertBits() UnlinkFlags {
return UnlinkFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x UnlinkFlags) HasBits(mask UnlinkFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x UnlinkFlags) ClearBits(mask UnlinkFlags) UnlinkFlags {
return ^mask & x
}
func (x UnlinkFlags) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("MustBeDirectory")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = VmoFlags(0)
type VmoFlags uint32
const (
VmoFlagsRead VmoFlags = 1
VmoFlagsWrite VmoFlags = 2
VmoFlagsExecute VmoFlags = 4
VmoFlagsPrivateClone VmoFlags = 65536
VmoFlagsSharedBuffer VmoFlags = 131072
VmoFlags_Mask VmoFlags = 196615
)
func (_ VmoFlags) I_BitsMask() VmoFlags {
return VmoFlags_Mask
}
func (_ VmoFlags) I_BitsIsStrict() bool {
return true
}
func (x VmoFlags) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x VmoFlags) GetUnknownBits() uint64 {
return uint64(^VmoFlags_Mask & x)
}
func (x VmoFlags) InvertBits() VmoFlags {
return VmoFlags_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x VmoFlags) HasBits(mask VmoFlags) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x VmoFlags) ClearBits(mask VmoFlags) VmoFlags {
return ^mask & x
}
func (x VmoFlags) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Read")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Write")
}
if 4&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Execute")
}
if 65536&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("PrivateClone")
}
if 131072&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("SharedBuffer")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
var _ _bindings.Bits = WatchMask(0)
type WatchMask uint32
const (
WatchMaskDeleted WatchMask = 1
WatchMaskAdded WatchMask = 2
WatchMaskRemoved WatchMask = 4
WatchMaskExisting WatchMask = 8
WatchMaskIdle WatchMask = 16
WatchMask_Mask WatchMask = 31
)
func (_ WatchMask) I_BitsMask() WatchMask {
return WatchMask_Mask
}
func (_ WatchMask) I_BitsIsStrict() bool {
return true
}
func (x WatchMask) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x WatchMask) GetUnknownBits() uint64 {
return uint64(^WatchMask_Mask & x)
}
func (x WatchMask) InvertBits() WatchMask {
return WatchMask_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x WatchMask) HasBits(mask WatchMask) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x WatchMask) ClearBits(mask WatchMask) WatchMask {
return ^mask & x
}
func (x WatchMask) String() string {
var buf _strings.Builder
if 1&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Deleted")
}
if 2&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Added")
}
if 4&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Removed")
}
if 8&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Existing")
}
if 16&x != 0 {
if buf.Len() != 0 {
buf.WriteRune('|')
}
buf.WriteString("Idle")
}
if buf.Len() == 0 {
buf.WriteString("<empty bits>")
}
return buf.String()
}
type AdvisoryLockRange struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
// The location in the file from which [`offset`] is computed.
Origin SeekOrigin `fidl_offset_v2:"0"`
// The start of the byte range, expressed as an offset from [`origin`].
// Cannot be negative if [`origin`] is [`SeekOrigin.START`].
Offset int64 `fidl_offset_v2:"8"`
// The length of the byte range in bytes.
//
// If the length is zero, then the byte range extends until the end of the
// file, regardless of how large the file becomes.
//
// If the length is negative, the byte range includes the bytes `offset` +
// `length` up to, and including, `offset` - 1, provided this range does
// not extend beyond the beginning of the file.
Length int64 `fidl_offset_v2:"16"`
}
var _mAdvisoryLockRange = _bindings.CreateLazyMarshaler(AdvisoryLockRange{})
func (msg *AdvisoryLockRange) Marshaler() _bindings.Marshaler {
return _mAdvisoryLockRange
}
type AdvisoryLockingAdvisoryLockResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mAdvisoryLockingAdvisoryLockResponse = _bindings.CreateLazyMarshaler(AdvisoryLockingAdvisoryLockResponse{})
func (msg *AdvisoryLockingAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
return _mAdvisoryLockingAdvisoryLockResponse
}
type DatagramSocket struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
// See [`fuchsia.posix.socket.DatagramSocket`] for details.
Socket _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"49166" fidl_bounds:"0"`
// Size of the buffer used to receive Tx metadata.
TxMetaBufSize uint64 `fidl_offset_v2:"8"`
// Size of the buffer used to receive Rx metadata.
RxMetaBufSize uint64 `fidl_offset_v2:"16"`
}
var _mDatagramSocket = _bindings.CreateLazyMarshaler(DatagramSocket{})
func (msg *DatagramSocket) Marshaler() _bindings.Marshaler {
return _mDatagramSocket
}
type Directory2RenameResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mDirectory2RenameResponse = _bindings.CreateLazyMarshaler(Directory2RenameResponse{})
func (msg *Directory2RenameResponse) Marshaler() _bindings.Marshaler {
return _mDirectory2RenameResponse
}
type Directory2UnlinkResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mDirectory2UnlinkResponse = _bindings.CreateLazyMarshaler(Directory2UnlinkResponse{})
func (msg *Directory2UnlinkResponse) Marshaler() _bindings.Marshaler {
return _mDirectory2UnlinkResponse
}
type DirectoryIteratorGetNextResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Information about an immediate child node of a directory.
//
// If a particular attribute is not applicable or not supported,
// implementations should leave the corresponding field absent.
Entries []DirectoryEntry `fidl_offset_v2:"0" fidl_bounds:"8192"`
}
var _mDirectoryIteratorGetNextResponse = _bindings.CreateLazyMarshaler(DirectoryIteratorGetNextResponse{})
func (msg *DirectoryIteratorGetNextResponse) Marshaler() _bindings.Marshaler {
return _mDirectoryIteratorGetNextResponse
}
type DirectoryObject struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mDirectoryObject = _bindings.CreateLazyMarshaler(DirectoryObject{})
func (msg *DirectoryObject) Marshaler() _bindings.Marshaler {
return _mDirectoryObject
}
type DirectoryProtocol struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mDirectoryProtocol = _bindings.CreateLazyMarshaler(DirectoryProtocol{})
func (msg *DirectoryProtocol) Marshaler() _bindings.Marshaler {
return _mDirectoryProtocol
}
type File2GetBackingMemoryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Vmo _zx.VMO `fidl_offset_v2:"0" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mFile2GetBackingMemoryResponse = _bindings.CreateLazyMarshaler(File2GetBackingMemoryResponse{})
func (msg *File2GetBackingMemoryResponse) Marshaler() _bindings.Marshaler {
return _mFile2GetBackingMemoryResponse
}
type File2ReadAtResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Data []uint8 `fidl_offset_v2:"0" fidl_bounds:"8192"`
}
var _mFile2ReadAtResponse = _bindings.CreateLazyMarshaler(File2ReadAtResponse{})
func (msg *File2ReadAtResponse) Marshaler() _bindings.Marshaler {
return _mFile2ReadAtResponse
}
type File2ReadResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Data []uint8 `fidl_offset_v2:"0" fidl_bounds:"8192"`
}
var _mFile2ReadResponse = _bindings.CreateLazyMarshaler(File2ReadResponse{})
func (msg *File2ReadResponse) Marshaler() _bindings.Marshaler {
return _mFile2ReadResponse
}
type File2ResizeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mFile2ResizeResponse = _bindings.CreateLazyMarshaler(File2ResizeResponse{})
func (msg *File2ResizeResponse) Marshaler() _bindings.Marshaler {
return _mFile2ResizeResponse
}
type File2SeekResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
OffsetFromStart uint64 `fidl_offset_v2:"0"`
}
var _mFile2SeekResponse = _bindings.CreateLazyMarshaler(File2SeekResponse{})
func (msg *File2SeekResponse) Marshaler() _bindings.Marshaler {
return _mFile2SeekResponse
}
type File2WriteAtResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
ActualCount uint64 `fidl_offset_v2:"0"`
}
var _mFile2WriteAtResponse = _bindings.CreateLazyMarshaler(File2WriteAtResponse{})
func (msg *File2WriteAtResponse) Marshaler() _bindings.Marshaler {
return _mFile2WriteAtResponse
}
type File2WriteResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
ActualCount uint64 `fidl_offset_v2:"0"`
}
var _mFile2WriteResponse = _bindings.CreateLazyMarshaler(File2WriteResponse{})
func (msg *File2WriteResponse) Marshaler() _bindings.Marshaler {
return _mFile2WriteResponse
}
type FileObject struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
// An optional event which transmits information about an object's readability
// or writability. This event relays information about the underlying object, not
// the capability granted to client: this event may be signalled "readable" on a
// connection that does not have the capability to read.
//
// The "`FILE_SIGNAL_`" values may be observed on this event.
Event _zx.Event `fidl_offset_v2:"0" fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
// A placeholder for future stream support.
//
// Currently, servers are required not to send a handle in this field.
Stream _zx.Handle `fidl_offset_v2:"4" fidl_handle_subtype:"31" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}
var _mFileObject = _bindings.CreateLazyMarshaler(FileObject{})
func (msg *FileObject) Marshaler() _bindings.Marshaler {
return _mFileObject
}
type FilesystemInfo struct {
_ struct{} `fidl:"s" fidl_size_v2:"96" fidl_alignment_v2:"8"`
// The number of data bytes which may be stored in a filesystem. This does not count
// metadata or other filesystem overhead like block rounding.
TotalBytes uint64 `fidl_offset_v2:"0"`
// The number of data bytes which are in use by the filesystem. This does not count
// metadata or other filesystem overhead like block rounding.
UsedBytes uint64 `fidl_offset_v2:"8"`
// The number of nodes which may be stored in the filesystem.
TotalNodes uint64 `fidl_offset_v2:"16"`
// The number of nodes used by the filesystem.
UsedNodes uint64 `fidl_offset_v2:"24"`
// The amount of additional space which may be allocated from the underlying volume
// manager. If unsupported or there is no space for the filesystem to grow, this will
// be zero.
FreeSharedPoolBytes uint64 `fidl_offset_v2:"32"`
// A unique identifier for this filesystem instance. Will not be preserved across
// reboots.
//
// Implementors should create a kernel object (normally an event) and use its koid for
// the filesystem ID. This koid guarantees uniqueness in the system.
FsId uint64 `fidl_offset_v2:"40"`
// The size in bytes of a single filesystem block.
BlockSize uint32 `fidl_offset_v2:"48"`
// The maximum length of a filesystem name.
MaxFilenameSize uint32 `fidl_offset_v2:"52"`
// A unique identifier for the type of the underlying filesystem.
FsType uint32 `fidl_offset_v2:"56"`
Padding uint32 `fidl_offset_v2:"60"`
Name [32]int8 `fidl_offset_v2:"64"`
}
var _mFilesystemInfo = _bindings.CreateLazyMarshaler(FilesystemInfo{})
func (msg *FilesystemInfo) Marshaler() _bindings.Marshaler {
return _mFilesystemInfo
}
type InotifyEvent struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
WatchDescriptor uint32 `fidl_offset_v2:"0"`
Mask InotifyWatchMask `fidl_offset_v2:"4"`
Cookie uint32 `fidl_offset_v2:"8"`
Len uint32 `fidl_offset_v2:"12"`
Filename string `fidl_offset_v2:"16" fidl_bounds:"4095"`
}
var _mInotifyEvent = _bindings.CreateLazyMarshaler(InotifyEvent{})
func (msg *InotifyEvent) Marshaler() _bindings.Marshaler {
return _mInotifyEvent
}
type Node2SyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mNode2SyncResponse = _bindings.CreateLazyMarshaler(Node2SyncResponse{})
func (msg *Node2SyncResponse) Marshaler() _bindings.Marshaler {
return _mNode2SyncResponse
}
type Node2UpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mNode2UpdateAttributesResponse = _bindings.CreateLazyMarshaler(Node2UpdateAttributesResponse{})
func (msg *Node2UpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mNode2UpdateAttributesResponse
}
// NodeAttributes defines generic information about a filesystem node.
type NodeAttributes struct {
_ struct{} `fidl:"s" fidl_size_v2:"56" fidl_alignment_v2:"8"`
// Protection bits and node type information describe in 'mode'.
Mode uint32 `fidl_offset_v2:"0"`
// A filesystem-unique ID.
Id uint64 `fidl_offset_v2:"8"`
// Node size, in bytes.
ContentSize uint64 `fidl_offset_v2:"16"`
// Space needed to store node (possibly larger than size), in bytes.
StorageSize uint64 `fidl_offset_v2:"24"`
// Hard link count.
LinkCount uint64 `fidl_offset_v2:"32"`
// Time of creation (may be updated manually after creation) in ns since Unix epoch, UTC.
CreationTime uint64 `fidl_offset_v2:"40"`
// Time of last modification in ns since Unix epoch, UTC.
ModificationTime uint64 `fidl_offset_v2:"48"`
}
var _mNodeAttributes = _bindings.CreateLazyMarshaler(NodeAttributes{})
func (msg *NodeAttributes) Marshaler() _bindings.Marshaler {
return _mNodeAttributes
}
type NodeAttributes2 struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
MutableAttributes MutableNodeAttributes `fidl_offset_v2:"0"`
ImmutableAttributes ImmutableNodeAttributes `fidl_offset_v2:"16"`
}
var _mNodeAttributes2 = _bindings.CreateLazyMarshaler(NodeAttributes2{})
func (msg *NodeAttributes2) Marshaler() _bindings.Marshaler {
return _mNodeAttributes2
}
type PacketSocket struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
// See [`fuchsia.posix.socket.packet.Socket`] for details.
Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"16386" fidl_bounds:"0"`
}
var _mPacketSocket = _bindings.CreateLazyMarshaler(PacketSocket{})
func (msg *PacketSocket) Marshaler() _bindings.Marshaler {
return _mPacketSocket
}
type RawSocket struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
// See [`fuchsia.posix.socket.raw.Socket`] for details.
Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"16386" fidl_bounds:"0"`
}
var _mRawSocket = _bindings.CreateLazyMarshaler(RawSocket{})
func (msg *RawSocket) Marshaler() _bindings.Marshaler {
return _mRawSocket
}
// Options for requesting rights on the new connection.
//
// ## Rights Hierarchy
//
// Respecting principles of least privileges, rights in general must meet
// the following restrictions:
//
// * A connection must have nonzero rights.
// * From the perspective of a client, rights must never increase in a
// derived connection.
// * From the perspective of a directory proxy, it must ensure that
// new connections opened through it cannot have more rights than
// the connection where the proxy received the `Open`/`Reopen` call.
//
// The proper enforcement of the rights hierarchy is a powerful refinement
// over the existing access control facilities offered by directory
// sandboxing.
//
// ## Rights vs Abilities
//
// The rights on a connection limits the set of operations allowed on that
// connection, but does not guarantee their availability, because the
// object may not support it.
//
// See [`Rights`] and [`Abilities`].
//
// ## Implementation Notes
//
// When a directory proxy encounters an absent `rights` field, let `r` be
// the rights on the connection where it received this request, the proxy
// should fill in this field with the following:
//
// ```
// RightsRequest {
// at_most: r,
// at_least: 0,
// resolution: RightsResolution.MAXIMIZE,
// }
// ```
//
// before forwarding the request to the remote party.
//
// Because opening a new connection may involve multiple hops through
// directory proxies, we require the client to set an upper bound and lower
// bound on the rights request, and intermediate proxies to refine these
// bounds.
//
// The rights manipulation should be implemented mechanically
// without knowledge of any specific rights, and servers should propagate
// unknown bits members, to gracefully handle future rights extensions.
//
// ## Implementation Notes
//
// It could be common for a client to request an exact set of rights.
// We recommend client libraries to define a helper function like follows:
//
// ```
// fn Exact(exact_rights: Rights) -> RightsRequest {
// RightsRequest {
// at_most: exact_rights,
// at_least: exact_rights,
// resolution: RightsResolution.MAXIMIZE,
// }
// }
// ```
type RightsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
// Sets an upper bound on the resulting rights. The exact rights will
// depend on `resolution`.
//
// ## Implementation Notes
//
// When a directory proxy encounters this variant, it should compute the
// intersection between this and the rights on the connection where it
// received the request, to shrink the rights.
//
// * If the intersection is empty, or not a superset of `at_least`,
// the proxy should close `object_request` with the
// `ZX_ERR_ACCESS_DENIED` epitaph.
// * Otherwise, the proxy should forward the `Open` call as usual,
// but update `at_most` with the shrunk rights.
AtMost Operations `fidl_offset_v2:"0"`
// Sets a lower bound on the resulting rights. The exact rights will
// depend on `resolution`.
//
// + During [`Directory.Open`], you may only specify the same rights as
// what the directory connection already has, or a subset of those.
// + During [`Node.Reopen`], similarly, you may only specify the same or
// a subset of rights possessed by the original connection.
// + Exceeding those rights causes `object_request` to be closed with a
// `ZX_ERR_ACCESS_DENIED` epitaph.
//
// Therefore there are these invariants which should be maintained:
//
// ```
// at_most ⊋ {}
// at_most ⊃ at_least
// rights_on_connection_where_open_is_received ⊋ {}
// rights_on_connection_where_open_is_received ⊃ at_least
// ```
//
// using the superset (`⊃`), proper superset (`⊋`),
// and empty set (`{}`) notations.
AtLeast Operations `fidl_offset_v2:"8"`
// When an `Open`/`Reopen` request reaches its final remote server, it should
// assign rights on the new connection based on one of these modes.
Resolution RightsResolution `fidl_offset_v2:"16"`
}
var _mRightsRequest = _bindings.CreateLazyMarshaler(RightsRequest{})
func (msg *RightsRequest) Marshaler() _bindings.Marshaler {
return _mRightsRequest
}
type Service struct {
_ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mService = _bindings.CreateLazyMarshaler(Service{})
func (msg *Service) Marshaler() _bindings.Marshaler {
return _mService
}
type StreamSocket struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Socket _zx.Socket `fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"49166" fidl_bounds:"0"`
}
var _mStreamSocket = _bindings.CreateLazyMarshaler(StreamSocket{})
func (msg *StreamSocket) Marshaler() _bindings.Marshaler {
return _mStreamSocket
}
type SynchronousDatagramSocket struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
// See [`fuchsia.posix.socket.SynchronousDatagramSocket`] for details.
Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"16386" fidl_bounds:"0"`
}
var _mSynchronousDatagramSocket = _bindings.CreateLazyMarshaler(SynchronousDatagramSocket{})
func (msg *SynchronousDatagramSocket) Marshaler() _bindings.Marshaler {
return _mSynchronousDatagramSocket
}
type Tty struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Event _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"16" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}
var _mTty = _bindings.CreateLazyMarshaler(Tty{})
func (msg *Tty) Marshaler() _bindings.Marshaler {
return _mTty
}
type VmofileDeprecated struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
// The VMO which backs this file.
Vmo _zx.VMO `fidl_offset_v2:"0" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
// The index into `vmo` which represents the first byte of the file.
Offset uint64 `fidl_offset_v2:"8"`
// The number of bytes, starting at `offset`, which may be used to represent this file.
Length uint64 `fidl_offset_v2:"16"`
}
var _mVmofileDeprecated = _bindings.CreateLazyMarshaler(VmofileDeprecated{})
func (msg *VmofileDeprecated) Marshaler() _bindings.Marshaler {
return _mVmofileDeprecated
}
type advisoryLockingWithCtxAdvisoryLockRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}
var _madvisoryLockingWithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(advisoryLockingWithCtxAdvisoryLockRequest{})
func (msg *advisoryLockingWithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
return _madvisoryLockingWithCtxAdvisoryLockRequest
}
type advisoryLockingWithCtxAdvisoryLockResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}
var _madvisoryLockingWithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(advisoryLockingWithCtxAdvisoryLockResponse{})
func (msg *advisoryLockingWithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
return _madvisoryLockingWithCtxAdvisoryLockResponse
}
type directoryWithCtxCloneRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectoryWithCtxCloneRequest = _bindings.CreateLazyMarshaler(directoryWithCtxCloneRequest{})
func (msg *directoryWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxCloneRequest
}
type directoryWithCtxDescribeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Info NodeInfo `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(directoryWithCtxDescribeResponse{})
func (msg *directoryWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxDescribeResponse
}
type directoryWithCtxOnOpenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *NodeInfo `fidl_offset_v2:"8"`
}
var _mdirectoryWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(directoryWithCtxOnOpenResponse{})
func (msg *directoryWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxOnOpenResponse
}
type directoryWithCtxGetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mdirectoryWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetAttrResponse{})
func (msg *directoryWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxGetAttrResponse
}
type directoryWithCtxSetAttrRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
Flags NodeAttributeFlags `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mdirectoryWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(directoryWithCtxSetAttrRequest{})
func (msg *directoryWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxSetAttrRequest
}
type directoryWithCtxSetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(directoryWithCtxSetAttrResponse{})
func (msg *directoryWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxSetAttrResponse
}
type directoryWithCtxGetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Flags OpenFlags `fidl_offset_v2:"4"`
}
var _mdirectoryWithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetFlagsResponse{})
func (msg *directoryWithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxGetFlagsResponse
}
type directoryWithCtxSetFlagsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(directoryWithCtxSetFlagsRequest{})
func (msg *directoryWithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxSetFlagsRequest
}
type directoryWithCtxSetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(directoryWithCtxSetFlagsResponse{})
func (msg *directoryWithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxSetFlagsResponse
}
type directoryWithCtxQueryFilesystemResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *FilesystemInfo `fidl_offset_v2:"8"`
}
var _mdirectoryWithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(directoryWithCtxQueryFilesystemResponse{})
func (msg *directoryWithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxQueryFilesystemResponse
}
type directoryWithCtxOpenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
Flags OpenFlags `fidl_offset_v2:"0"`
Mode uint32 `fidl_offset_v2:"4"`
Path string `fidl_offset_v2:"8" fidl_bounds:"4096"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"24" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectoryWithCtxOpenRequest = _bindings.CreateLazyMarshaler(directoryWithCtxOpenRequest{})
func (msg *directoryWithCtxOpenRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxOpenRequest
}
type directoryWithCtxReadDirentsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
MaxBytes uint64 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxReadDirentsRequest = _bindings.CreateLazyMarshaler(directoryWithCtxReadDirentsRequest{})
func (msg *directoryWithCtxReadDirentsRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxReadDirentsRequest
}
type directoryWithCtxReadDirentsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Dirents []uint8 `fidl_offset_v2:"8" fidl_bounds:"8192"`
}
var _mdirectoryWithCtxReadDirentsResponse = _bindings.CreateLazyMarshaler(directoryWithCtxReadDirentsResponse{})
func (msg *directoryWithCtxReadDirentsResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxReadDirentsResponse
}
type directoryWithCtxRewindResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxRewindResponse = _bindings.CreateLazyMarshaler(directoryWithCtxRewindResponse{})
func (msg *directoryWithCtxRewindResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxRewindResponse
}
type directoryWithCtxGetTokenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Token _zx.Handle `fidl_offset_v2:"4" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}
var _mdirectoryWithCtxGetTokenResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetTokenResponse{})
func (msg *directoryWithCtxGetTokenResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxGetTokenResponse
}
type directoryWithCtxLinkRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
Src string `fidl_offset_v2:"0" fidl_bounds:"255"`
DstParentToken _zx.Handle `fidl_offset_v2:"16" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
Dst string `fidl_offset_v2:"24" fidl_bounds:"255"`
}
var _mdirectoryWithCtxLinkRequest = _bindings.CreateLazyMarshaler(directoryWithCtxLinkRequest{})
func (msg *directoryWithCtxLinkRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxLinkRequest
}
type directoryWithCtxLinkResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxLinkResponse = _bindings.CreateLazyMarshaler(directoryWithCtxLinkResponse{})
func (msg *directoryWithCtxLinkResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxLinkResponse
}
type directoryWithCtxWatchRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"12" fidl_alignment_v2:"4"`
Mask WatchMask `fidl_offset_v2:"0"`
Options uint32 `fidl_offset_v2:"4"`
Watcher DirectoryWatcherWithCtxInterfaceRequest `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectoryWithCtxWatchRequest = _bindings.CreateLazyMarshaler(directoryWithCtxWatchRequest{})
func (msg *directoryWithCtxWatchRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxWatchRequest
}
type directoryWithCtxWatchResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxWatchResponse = _bindings.CreateLazyMarshaler(directoryWithCtxWatchResponse{})
func (msg *directoryWithCtxWatchResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxWatchResponse
}
type directoryWithCtxCloseResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxCloseResponse = _bindings.CreateLazyMarshaler(directoryWithCtxCloseResponse{})
func (msg *directoryWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxCloseResponse
}
type directoryWithCtxQueryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Identifies the underlying protocol.
Protocol uint64 `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxQueryResponse = _bindings.CreateLazyMarshaler(directoryWithCtxQueryResponse{})
func (msg *directoryWithCtxQueryResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxQueryResponse
}
type directoryWithCtxReopenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Requests rights on the new connection according to the specified rules.
//
// If absent, inherits the rights from the connection where the call
// is made.
RightsRequest *RightsRequest `fidl_offset_v2:"0"`
ObjectRequest _zx.Channel `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mdirectoryWithCtxReopenRequest = _bindings.CreateLazyMarshaler(directoryWithCtxReopenRequest{})
func (msg *directoryWithCtxReopenRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxReopenRequest
}
type directoryWithCtxOnRepresentationResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Payload Representation `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(directoryWithCtxOnRepresentationResponse{})
func (msg *directoryWithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxOnRepresentationResponse
}
type directoryWithCtxGetAttributesRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Set the corresponding bit to one to query that particular attribute.
//
// The elements here correspond one-to-one with [`NodeAttributes`].
Query NodeAttributesQuery `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(directoryWithCtxGetAttributesRequest{})
func (msg *directoryWithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxGetAttributesRequest
}
type directoryWithCtxGetAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(directoryWithCtxGetAttributesResponse{})
func (msg *directoryWithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxGetAttributesResponse
}
type directoryWithCtxUpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(directoryWithCtxUpdateAttributesResponse{})
func (msg *directoryWithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxUpdateAttributesResponse
}
type directoryWithCtxSyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2SyncResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxSyncResponse = _bindings.CreateLazyMarshaler(directoryWithCtxSyncResponse{})
func (msg *directoryWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxSyncResponse
}
type directoryWithCtxAdvisoryLockRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(directoryWithCtxAdvisoryLockRequest{})
func (msg *directoryWithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxAdvisoryLockRequest
}
type directoryWithCtxAdvisoryLockResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(directoryWithCtxAdvisoryLockResponse{})
func (msg *directoryWithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxAdvisoryLockResponse
}
type directoryWithCtxOpen2Request struct {
_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
// Identifies the node to open.
//
// If it contains multiple segments, then the directory is traversed,
// one segment at a time, relative to the directory represented by this
// connection.
Path string `fidl_offset_v2:"0" fidl_bounds:"4095"`
// The representations accepted by the caller to support a form of
// protocol negotiation on the node being opened.
Protocols ConnectionProtocols `fidl_offset_v2:"16"`
// The server end of a channel created for the new connection. The
// caller may proceed to send messages on the corresponding client end
// right away.
ObjectRequest _zx.Channel `fidl_offset_v2:"32" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mdirectoryWithCtxOpen2Request = _bindings.CreateLazyMarshaler(directoryWithCtxOpen2Request{})
func (msg *directoryWithCtxOpen2Request) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxOpen2Request
}
type directoryWithCtxAddInotifyFilterRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
Path string `fidl_offset_v2:"0" fidl_bounds:"4095"`
Filter InotifyWatchMask `fidl_offset_v2:"16"`
WatchDescriptor uint32 `fidl_offset_v2:"20"`
Socket _zx.Socket `fidl_offset_v2:"24" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mdirectoryWithCtxAddInotifyFilterRequest = _bindings.CreateLazyMarshaler(directoryWithCtxAddInotifyFilterRequest{})
func (msg *directoryWithCtxAddInotifyFilterRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxAddInotifyFilterRequest
}
type directoryWithCtxUnlinkRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
Name string `fidl_offset_v2:"0" fidl_bounds:"255"`
Options UnlinkOptions `fidl_offset_v2:"16"`
}
var _mdirectoryWithCtxUnlinkRequest = _bindings.CreateLazyMarshaler(directoryWithCtxUnlinkRequest{})
func (msg *directoryWithCtxUnlinkRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxUnlinkRequest
}
type directoryWithCtxUnlinkResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Directory2UnlinkResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxUnlinkResponse = _bindings.CreateLazyMarshaler(directoryWithCtxUnlinkResponse{})
func (msg *directoryWithCtxUnlinkResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxUnlinkResponse
}
type directoryWithCtxEnumerateRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
Options DirectoryEnumerateOptions `fidl_offset_v2:"0"`
Iterator DirectoryIteratorWithCtxInterfaceRequest `fidl_offset_v2:"16" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectoryWithCtxEnumerateRequest = _bindings.CreateLazyMarshaler(directoryWithCtxEnumerateRequest{})
func (msg *directoryWithCtxEnumerateRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxEnumerateRequest
}
type directoryWithCtxRenameRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
Src string `fidl_offset_v2:"0" fidl_bounds:"255"`
DstParentToken _zx.Event `fidl_offset_v2:"16" fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
Dst string `fidl_offset_v2:"24" fidl_bounds:"255"`
}
var _mdirectoryWithCtxRenameRequest = _bindings.CreateLazyMarshaler(directoryWithCtxRenameRequest{})
func (msg *directoryWithCtxRenameRequest) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxRenameRequest
}
type directoryWithCtxRenameResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Directory2RenameResult `fidl_offset_v2:"0"`
}
var _mdirectoryWithCtxRenameResponse = _bindings.CreateLazyMarshaler(directoryWithCtxRenameResponse{})
func (msg *directoryWithCtxRenameResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryWithCtxRenameResponse
}
type directory1WithCtxCloneRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectory1WithCtxCloneRequest = _bindings.CreateLazyMarshaler(directory1WithCtxCloneRequest{})
func (msg *directory1WithCtxCloneRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxCloneRequest
}
type directory1WithCtxDescribeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Info NodeInfo `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxDescribeResponse = _bindings.CreateLazyMarshaler(directory1WithCtxDescribeResponse{})
func (msg *directory1WithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxDescribeResponse
}
type directory1WithCtxOnOpenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *NodeInfo `fidl_offset_v2:"8"`
}
var _mdirectory1WithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(directory1WithCtxOnOpenResponse{})
func (msg *directory1WithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxOnOpenResponse
}
type directory1WithCtxGetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mdirectory1WithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(directory1WithCtxGetAttrResponse{})
func (msg *directory1WithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxGetAttrResponse
}
type directory1WithCtxSetAttrRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
Flags NodeAttributeFlags `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mdirectory1WithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(directory1WithCtxSetAttrRequest{})
func (msg *directory1WithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxSetAttrRequest
}
type directory1WithCtxSetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(directory1WithCtxSetAttrResponse{})
func (msg *directory1WithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxSetAttrResponse
}
type directory1WithCtxGetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Flags OpenFlags `fidl_offset_v2:"4"`
}
var _mdirectory1WithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(directory1WithCtxGetFlagsResponse{})
func (msg *directory1WithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxGetFlagsResponse
}
type directory1WithCtxSetFlagsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(directory1WithCtxSetFlagsRequest{})
func (msg *directory1WithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxSetFlagsRequest
}
type directory1WithCtxSetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(directory1WithCtxSetFlagsResponse{})
func (msg *directory1WithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxSetFlagsResponse
}
type directory1WithCtxQueryFilesystemResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *FilesystemInfo `fidl_offset_v2:"8"`
}
var _mdirectory1WithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(directory1WithCtxQueryFilesystemResponse{})
func (msg *directory1WithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxQueryFilesystemResponse
}
type directory1WithCtxOpenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
Flags OpenFlags `fidl_offset_v2:"0"`
Mode uint32 `fidl_offset_v2:"4"`
Path string `fidl_offset_v2:"8" fidl_bounds:"4096"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"24" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectory1WithCtxOpenRequest = _bindings.CreateLazyMarshaler(directory1WithCtxOpenRequest{})
func (msg *directory1WithCtxOpenRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxOpenRequest
}
type directory1WithCtxReadDirentsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
MaxBytes uint64 `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxReadDirentsRequest = _bindings.CreateLazyMarshaler(directory1WithCtxReadDirentsRequest{})
func (msg *directory1WithCtxReadDirentsRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxReadDirentsRequest
}
type directory1WithCtxReadDirentsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Dirents []uint8 `fidl_offset_v2:"8" fidl_bounds:"8192"`
}
var _mdirectory1WithCtxReadDirentsResponse = _bindings.CreateLazyMarshaler(directory1WithCtxReadDirentsResponse{})
func (msg *directory1WithCtxReadDirentsResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxReadDirentsResponse
}
type directory1WithCtxRewindResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxRewindResponse = _bindings.CreateLazyMarshaler(directory1WithCtxRewindResponse{})
func (msg *directory1WithCtxRewindResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxRewindResponse
}
type directory1WithCtxGetTokenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Token _zx.Handle `fidl_offset_v2:"4" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1"`
}
var _mdirectory1WithCtxGetTokenResponse = _bindings.CreateLazyMarshaler(directory1WithCtxGetTokenResponse{})
func (msg *directory1WithCtxGetTokenResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxGetTokenResponse
}
type directory1WithCtxLinkRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
Src string `fidl_offset_v2:"0" fidl_bounds:"255"`
DstParentToken _zx.Handle `fidl_offset_v2:"16" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
Dst string `fidl_offset_v2:"24" fidl_bounds:"255"`
}
var _mdirectory1WithCtxLinkRequest = _bindings.CreateLazyMarshaler(directory1WithCtxLinkRequest{})
func (msg *directory1WithCtxLinkRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxLinkRequest
}
type directory1WithCtxLinkResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxLinkResponse = _bindings.CreateLazyMarshaler(directory1WithCtxLinkResponse{})
func (msg *directory1WithCtxLinkResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxLinkResponse
}
type directory1WithCtxWatchRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"12" fidl_alignment_v2:"4"`
Mask WatchMask `fidl_offset_v2:"0"`
Options uint32 `fidl_offset_v2:"4"`
Watcher DirectoryWatcherWithCtxInterfaceRequest `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectory1WithCtxWatchRequest = _bindings.CreateLazyMarshaler(directory1WithCtxWatchRequest{})
func (msg *directory1WithCtxWatchRequest) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxWatchRequest
}
type directory1WithCtxWatchResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mdirectory1WithCtxWatchResponse = _bindings.CreateLazyMarshaler(directory1WithCtxWatchResponse{})
func (msg *directory1WithCtxWatchResponse) Marshaler() _bindings.Marshaler {
return _mdirectory1WithCtxWatchResponse
}
type directory2WithCtxCloseResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxCloseResponse = _bindings.CreateLazyMarshaler(directory2WithCtxCloseResponse{})
func (msg *directory2WithCtxCloseResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxCloseResponse
}
type directory2WithCtxQueryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Identifies the underlying protocol.
Protocol uint64 `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxQueryResponse = _bindings.CreateLazyMarshaler(directory2WithCtxQueryResponse{})
func (msg *directory2WithCtxQueryResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxQueryResponse
}
type directory2WithCtxReopenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Requests rights on the new connection according to the specified rules.
//
// If absent, inherits the rights from the connection where the call
// is made.
RightsRequest *RightsRequest `fidl_offset_v2:"0"`
ObjectRequest _zx.Channel `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mdirectory2WithCtxReopenRequest = _bindings.CreateLazyMarshaler(directory2WithCtxReopenRequest{})
func (msg *directory2WithCtxReopenRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxReopenRequest
}
type directory2WithCtxOnRepresentationResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Payload Representation `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(directory2WithCtxOnRepresentationResponse{})
func (msg *directory2WithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxOnRepresentationResponse
}
type directory2WithCtxGetAttributesRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Set the corresponding bit to one to query that particular attribute.
//
// The elements here correspond one-to-one with [`NodeAttributes`].
Query NodeAttributesQuery `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(directory2WithCtxGetAttributesRequest{})
func (msg *directory2WithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxGetAttributesRequest
}
type directory2WithCtxGetAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(directory2WithCtxGetAttributesResponse{})
func (msg *directory2WithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxGetAttributesResponse
}
type directory2WithCtxUpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(directory2WithCtxUpdateAttributesResponse{})
func (msg *directory2WithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxUpdateAttributesResponse
}
type directory2WithCtxSyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2SyncResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxSyncResponse = _bindings.CreateLazyMarshaler(directory2WithCtxSyncResponse{})
func (msg *directory2WithCtxSyncResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxSyncResponse
}
type directory2WithCtxAdvisoryLockRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(directory2WithCtxAdvisoryLockRequest{})
func (msg *directory2WithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxAdvisoryLockRequest
}
type directory2WithCtxAdvisoryLockResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(directory2WithCtxAdvisoryLockResponse{})
func (msg *directory2WithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxAdvisoryLockResponse
}
type directory2WithCtxOpen2Request struct {
_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
// Identifies the node to open.
//
// If it contains multiple segments, then the directory is traversed,
// one segment at a time, relative to the directory represented by this
// connection.
Path string `fidl_offset_v2:"0" fidl_bounds:"4095"`
// The representations accepted by the caller to support a form of
// protocol negotiation on the node being opened.
Protocols ConnectionProtocols `fidl_offset_v2:"16"`
// The server end of a channel created for the new connection. The
// caller may proceed to send messages on the corresponding client end
// right away.
ObjectRequest _zx.Channel `fidl_offset_v2:"32" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mdirectory2WithCtxOpen2Request = _bindings.CreateLazyMarshaler(directory2WithCtxOpen2Request{})
func (msg *directory2WithCtxOpen2Request) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxOpen2Request
}
type directory2WithCtxAddInotifyFilterRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
Path string `fidl_offset_v2:"0" fidl_bounds:"4095"`
Filter InotifyWatchMask `fidl_offset_v2:"16"`
WatchDescriptor uint32 `fidl_offset_v2:"20"`
Socket _zx.Socket `fidl_offset_v2:"24" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mdirectory2WithCtxAddInotifyFilterRequest = _bindings.CreateLazyMarshaler(directory2WithCtxAddInotifyFilterRequest{})
func (msg *directory2WithCtxAddInotifyFilterRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxAddInotifyFilterRequest
}
type directory2WithCtxUnlinkRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"32" fidl_alignment_v2:"8"`
Name string `fidl_offset_v2:"0" fidl_bounds:"255"`
Options UnlinkOptions `fidl_offset_v2:"16"`
}
var _mdirectory2WithCtxUnlinkRequest = _bindings.CreateLazyMarshaler(directory2WithCtxUnlinkRequest{})
func (msg *directory2WithCtxUnlinkRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxUnlinkRequest
}
type directory2WithCtxUnlinkResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Directory2UnlinkResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxUnlinkResponse = _bindings.CreateLazyMarshaler(directory2WithCtxUnlinkResponse{})
func (msg *directory2WithCtxUnlinkResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxUnlinkResponse
}
type directory2WithCtxEnumerateRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
Options DirectoryEnumerateOptions `fidl_offset_v2:"0"`
Iterator DirectoryIteratorWithCtxInterfaceRequest `fidl_offset_v2:"16" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mdirectory2WithCtxEnumerateRequest = _bindings.CreateLazyMarshaler(directory2WithCtxEnumerateRequest{})
func (msg *directory2WithCtxEnumerateRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxEnumerateRequest
}
type directory2WithCtxRenameRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"40" fidl_alignment_v2:"8"`
Src string `fidl_offset_v2:"0" fidl_bounds:"255"`
DstParentToken _zx.Event `fidl_offset_v2:"16" fidl_handle_subtype:"5" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
Dst string `fidl_offset_v2:"24" fidl_bounds:"255"`
}
var _mdirectory2WithCtxRenameRequest = _bindings.CreateLazyMarshaler(directory2WithCtxRenameRequest{})
func (msg *directory2WithCtxRenameRequest) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxRenameRequest
}
type directory2WithCtxRenameResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Directory2RenameResult `fidl_offset_v2:"0"`
}
var _mdirectory2WithCtxRenameResponse = _bindings.CreateLazyMarshaler(directory2WithCtxRenameResponse{})
func (msg *directory2WithCtxRenameResponse) Marshaler() _bindings.Marshaler {
return _mdirectory2WithCtxRenameResponse
}
type directoryIteratorWithCtxGetNextResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result DirectoryIteratorGetNextResult `fidl_offset_v2:"0"`
}
var _mdirectoryIteratorWithCtxGetNextResponse = _bindings.CreateLazyMarshaler(directoryIteratorWithCtxGetNextResponse{})
func (msg *directoryIteratorWithCtxGetNextResponse) Marshaler() _bindings.Marshaler {
return _mdirectoryIteratorWithCtxGetNextResponse
}
type fileWithCtxAdvisoryLockRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Request AdvisoryLockRequest `fidl_offset_v2:"0"`
}
var _mfileWithCtxAdvisoryLockRequest = _bindings.CreateLazyMarshaler(fileWithCtxAdvisoryLockRequest{})
func (msg *fileWithCtxAdvisoryLockRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxAdvisoryLockRequest
}
type fileWithCtxAdvisoryLockResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result AdvisoryLockingAdvisoryLockResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxAdvisoryLockResponse = _bindings.CreateLazyMarshaler(fileWithCtxAdvisoryLockResponse{})
func (msg *fileWithCtxAdvisoryLockResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxAdvisoryLockResponse
}
type fileWithCtxCloneRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mfileWithCtxCloneRequest = _bindings.CreateLazyMarshaler(fileWithCtxCloneRequest{})
func (msg *fileWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxCloneRequest
}
type fileWithCtxDescribeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Info NodeInfo `fidl_offset_v2:"0"`
}
var _mfileWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(fileWithCtxDescribeResponse{})
func (msg *fileWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxDescribeResponse
}
type fileWithCtxOnOpenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *NodeInfo `fidl_offset_v2:"8"`
}
var _mfileWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(fileWithCtxOnOpenResponse{})
func (msg *fileWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxOnOpenResponse
}
type fileWithCtxGetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mfileWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetAttrResponse{})
func (msg *fileWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxGetAttrResponse
}
type fileWithCtxSetAttrRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
Flags NodeAttributeFlags `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mfileWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(fileWithCtxSetAttrRequest{})
func (msg *fileWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSetAttrRequest
}
type fileWithCtxSetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mfileWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(fileWithCtxSetAttrResponse{})
func (msg *fileWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSetAttrResponse
}
type fileWithCtxGetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Flags OpenFlags `fidl_offset_v2:"4"`
}
var _mfileWithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetFlagsResponse{})
func (msg *fileWithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxGetFlagsResponse
}
type fileWithCtxSetFlagsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
}
var _mfileWithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(fileWithCtxSetFlagsRequest{})
func (msg *fileWithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSetFlagsRequest
}
type fileWithCtxSetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mfileWithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(fileWithCtxSetFlagsResponse{})
func (msg *fileWithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSetFlagsResponse
}
type fileWithCtxQueryFilesystemResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *FilesystemInfo `fidl_offset_v2:"8"`
}
var _mfileWithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(fileWithCtxQueryFilesystemResponse{})
func (msg *fileWithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxQueryFilesystemResponse
}
type fileWithCtxCloseResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxCloseResponse = _bindings.CreateLazyMarshaler(fileWithCtxCloseResponse{})
func (msg *fileWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxCloseResponse
}
type fileWithCtxQueryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Identifies the underlying protocol.
Protocol uint64 `fidl_offset_v2:"0"`
}
var _mfileWithCtxQueryResponse = _bindings.CreateLazyMarshaler(fileWithCtxQueryResponse{})
func (msg *fileWithCtxQueryResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxQueryResponse
}
type fileWithCtxReopenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Requests rights on the new connection according to the specified rules.
//
// If absent, inherits the rights from the connection where the call
// is made.
RightsRequest *RightsRequest `fidl_offset_v2:"0"`
ObjectRequest _zx.Channel `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mfileWithCtxReopenRequest = _bindings.CreateLazyMarshaler(fileWithCtxReopenRequest{})
func (msg *fileWithCtxReopenRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxReopenRequest
}
type fileWithCtxOnRepresentationResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Payload Representation `fidl_offset_v2:"0"`
}
var _mfileWithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(fileWithCtxOnRepresentationResponse{})
func (msg *fileWithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxOnRepresentationResponse
}
type fileWithCtxGetAttributesRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Set the corresponding bit to one to query that particular attribute.
//
// The elements here correspond one-to-one with [`NodeAttributes`].
Query NodeAttributesQuery `fidl_offset_v2:"0"`
}
var _mfileWithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(fileWithCtxGetAttributesRequest{})
func (msg *fileWithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxGetAttributesRequest
}
type fileWithCtxGetAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetAttributesResponse{})
func (msg *fileWithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxGetAttributesResponse
}
type fileWithCtxUpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(fileWithCtxUpdateAttributesResponse{})
func (msg *fileWithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxUpdateAttributesResponse
}
type fileWithCtxSyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2SyncResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxSyncResponse = _bindings.CreateLazyMarshaler(fileWithCtxSyncResponse{})
func (msg *fileWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSyncResponse
}
type fileWithCtxSeekRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Origin SeekOrigin `fidl_offset_v2:"0"`
Offset int64 `fidl_offset_v2:"8"`
}
var _mfileWithCtxSeekRequest = _bindings.CreateLazyMarshaler(fileWithCtxSeekRequest{})
func (msg *fileWithCtxSeekRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSeekRequest
}
type fileWithCtxSeekResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2SeekResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxSeekResponse = _bindings.CreateLazyMarshaler(fileWithCtxSeekResponse{})
func (msg *fileWithCtxSeekResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxSeekResponse
}
type fileWithCtxReadRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Count uint64 `fidl_offset_v2:"0"`
}
var _mfileWithCtxReadRequest = _bindings.CreateLazyMarshaler(fileWithCtxReadRequest{})
func (msg *fileWithCtxReadRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxReadRequest
}
type fileWithCtxReadResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2ReadResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxReadResponse = _bindings.CreateLazyMarshaler(fileWithCtxReadResponse{})
func (msg *fileWithCtxReadResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxReadResponse
}
type fileWithCtxWriteRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Data []uint8 `fidl_offset_v2:"0" fidl_bounds:"8192"`
}
var _mfileWithCtxWriteRequest = _bindings.CreateLazyMarshaler(fileWithCtxWriteRequest{})
func (msg *fileWithCtxWriteRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxWriteRequest
}
type fileWithCtxWriteResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2WriteResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxWriteResponse = _bindings.CreateLazyMarshaler(fileWithCtxWriteResponse{})
func (msg *fileWithCtxWriteResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxWriteResponse
}
type fileWithCtxReadAtRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Count uint64 `fidl_offset_v2:"0"`
Offset uint64 `fidl_offset_v2:"8"`
}
var _mfileWithCtxReadAtRequest = _bindings.CreateLazyMarshaler(fileWithCtxReadAtRequest{})
func (msg *fileWithCtxReadAtRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxReadAtRequest
}
type fileWithCtxReadAtResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2ReadAtResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxReadAtResponse = _bindings.CreateLazyMarshaler(fileWithCtxReadAtResponse{})
func (msg *fileWithCtxReadAtResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxReadAtResponse
}
type fileWithCtxWriteAtRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
Data []uint8 `fidl_offset_v2:"0" fidl_bounds:"8192"`
Offset uint64 `fidl_offset_v2:"16"`
}
var _mfileWithCtxWriteAtRequest = _bindings.CreateLazyMarshaler(fileWithCtxWriteAtRequest{})
func (msg *fileWithCtxWriteAtRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxWriteAtRequest
}
type fileWithCtxWriteAtResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2WriteAtResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxWriteAtResponse = _bindings.CreateLazyMarshaler(fileWithCtxWriteAtResponse{})
func (msg *fileWithCtxWriteAtResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxWriteAtResponse
}
type fileWithCtxResizeRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Length uint64 `fidl_offset_v2:"0"`
}
var _mfileWithCtxResizeRequest = _bindings.CreateLazyMarshaler(fileWithCtxResizeRequest{})
func (msg *fileWithCtxResizeRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxResizeRequest
}
type fileWithCtxResizeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2ResizeResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxResizeResponse = _bindings.CreateLazyMarshaler(fileWithCtxResizeResponse{})
func (msg *fileWithCtxResizeResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxResizeResponse
}
type fileWithCtxGetBackingMemoryRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags VmoFlags `fidl_offset_v2:"0"`
}
var _mfileWithCtxGetBackingMemoryRequest = _bindings.CreateLazyMarshaler(fileWithCtxGetBackingMemoryRequest{})
func (msg *fileWithCtxGetBackingMemoryRequest) Marshaler() _bindings.Marshaler {
return _mfileWithCtxGetBackingMemoryRequest
}
type fileWithCtxGetBackingMemoryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2GetBackingMemoryResult `fidl_offset_v2:"0"`
}
var _mfileWithCtxGetBackingMemoryResponse = _bindings.CreateLazyMarshaler(fileWithCtxGetBackingMemoryResponse{})
func (msg *fileWithCtxGetBackingMemoryResponse) Marshaler() _bindings.Marshaler {
return _mfileWithCtxGetBackingMemoryResponse
}
type file2WithCtxCloseResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxCloseResponse = _bindings.CreateLazyMarshaler(file2WithCtxCloseResponse{})
func (msg *file2WithCtxCloseResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxCloseResponse
}
type file2WithCtxQueryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Identifies the underlying protocol.
Protocol uint64 `fidl_offset_v2:"0"`
}
var _mfile2WithCtxQueryResponse = _bindings.CreateLazyMarshaler(file2WithCtxQueryResponse{})
func (msg *file2WithCtxQueryResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxQueryResponse
}
type file2WithCtxReopenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Requests rights on the new connection according to the specified rules.
//
// If absent, inherits the rights from the connection where the call
// is made.
RightsRequest *RightsRequest `fidl_offset_v2:"0"`
ObjectRequest _zx.Channel `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mfile2WithCtxReopenRequest = _bindings.CreateLazyMarshaler(file2WithCtxReopenRequest{})
func (msg *file2WithCtxReopenRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxReopenRequest
}
type file2WithCtxOnRepresentationResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Payload Representation `fidl_offset_v2:"0"`
}
var _mfile2WithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(file2WithCtxOnRepresentationResponse{})
func (msg *file2WithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxOnRepresentationResponse
}
type file2WithCtxGetAttributesRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Set the corresponding bit to one to query that particular attribute.
//
// The elements here correspond one-to-one with [`NodeAttributes`].
Query NodeAttributesQuery `fidl_offset_v2:"0"`
}
var _mfile2WithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(file2WithCtxGetAttributesRequest{})
func (msg *file2WithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxGetAttributesRequest
}
type file2WithCtxGetAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(file2WithCtxGetAttributesResponse{})
func (msg *file2WithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxGetAttributesResponse
}
type file2WithCtxUpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(file2WithCtxUpdateAttributesResponse{})
func (msg *file2WithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxUpdateAttributesResponse
}
type file2WithCtxSyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2SyncResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxSyncResponse = _bindings.CreateLazyMarshaler(file2WithCtxSyncResponse{})
func (msg *file2WithCtxSyncResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxSyncResponse
}
type file2WithCtxSeekRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Origin SeekOrigin `fidl_offset_v2:"0"`
Offset int64 `fidl_offset_v2:"8"`
}
var _mfile2WithCtxSeekRequest = _bindings.CreateLazyMarshaler(file2WithCtxSeekRequest{})
func (msg *file2WithCtxSeekRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxSeekRequest
}
type file2WithCtxSeekResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2SeekResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxSeekResponse = _bindings.CreateLazyMarshaler(file2WithCtxSeekResponse{})
func (msg *file2WithCtxSeekResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxSeekResponse
}
type file2WithCtxReadRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Count uint64 `fidl_offset_v2:"0"`
}
var _mfile2WithCtxReadRequest = _bindings.CreateLazyMarshaler(file2WithCtxReadRequest{})
func (msg *file2WithCtxReadRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxReadRequest
}
type file2WithCtxReadResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2ReadResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxReadResponse = _bindings.CreateLazyMarshaler(file2WithCtxReadResponse{})
func (msg *file2WithCtxReadResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxReadResponse
}
type file2WithCtxWriteRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Data []uint8 `fidl_offset_v2:"0" fidl_bounds:"8192"`
}
var _mfile2WithCtxWriteRequest = _bindings.CreateLazyMarshaler(file2WithCtxWriteRequest{})
func (msg *file2WithCtxWriteRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxWriteRequest
}
type file2WithCtxWriteResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2WriteResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxWriteResponse = _bindings.CreateLazyMarshaler(file2WithCtxWriteResponse{})
func (msg *file2WithCtxWriteResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxWriteResponse
}
type file2WithCtxReadAtRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Count uint64 `fidl_offset_v2:"0"`
Offset uint64 `fidl_offset_v2:"8"`
}
var _mfile2WithCtxReadAtRequest = _bindings.CreateLazyMarshaler(file2WithCtxReadAtRequest{})
func (msg *file2WithCtxReadAtRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxReadAtRequest
}
type file2WithCtxReadAtResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2ReadAtResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxReadAtResponse = _bindings.CreateLazyMarshaler(file2WithCtxReadAtResponse{})
func (msg *file2WithCtxReadAtResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxReadAtResponse
}
type file2WithCtxWriteAtRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
Data []uint8 `fidl_offset_v2:"0" fidl_bounds:"8192"`
Offset uint64 `fidl_offset_v2:"16"`
}
var _mfile2WithCtxWriteAtRequest = _bindings.CreateLazyMarshaler(file2WithCtxWriteAtRequest{})
func (msg *file2WithCtxWriteAtRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxWriteAtRequest
}
type file2WithCtxWriteAtResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2WriteAtResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxWriteAtResponse = _bindings.CreateLazyMarshaler(file2WithCtxWriteAtResponse{})
func (msg *file2WithCtxWriteAtResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxWriteAtResponse
}
type file2WithCtxResizeRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Length uint64 `fidl_offset_v2:"0"`
}
var _mfile2WithCtxResizeRequest = _bindings.CreateLazyMarshaler(file2WithCtxResizeRequest{})
func (msg *file2WithCtxResizeRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxResizeRequest
}
type file2WithCtxResizeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2ResizeResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxResizeResponse = _bindings.CreateLazyMarshaler(file2WithCtxResizeResponse{})
func (msg *file2WithCtxResizeResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxResizeResponse
}
type file2WithCtxGetBackingMemoryRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags VmoFlags `fidl_offset_v2:"0"`
}
var _mfile2WithCtxGetBackingMemoryRequest = _bindings.CreateLazyMarshaler(file2WithCtxGetBackingMemoryRequest{})
func (msg *file2WithCtxGetBackingMemoryRequest) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxGetBackingMemoryRequest
}
type file2WithCtxGetBackingMemoryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result File2GetBackingMemoryResult `fidl_offset_v2:"0"`
}
var _mfile2WithCtxGetBackingMemoryResponse = _bindings.CreateLazyMarshaler(file2WithCtxGetBackingMemoryResponse{})
func (msg *file2WithCtxGetBackingMemoryResponse) Marshaler() _bindings.Marshaler {
return _mfile2WithCtxGetBackingMemoryResponse
}
type nodeWithCtxCloneRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mnodeWithCtxCloneRequest = _bindings.CreateLazyMarshaler(nodeWithCtxCloneRequest{})
func (msg *nodeWithCtxCloneRequest) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxCloneRequest
}
type nodeWithCtxDescribeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Info NodeInfo `fidl_offset_v2:"0"`
}
var _mnodeWithCtxDescribeResponse = _bindings.CreateLazyMarshaler(nodeWithCtxDescribeResponse{})
func (msg *nodeWithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxDescribeResponse
}
type nodeWithCtxOnOpenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *NodeInfo `fidl_offset_v2:"8"`
}
var _mnodeWithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(nodeWithCtxOnOpenResponse{})
func (msg *nodeWithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxOnOpenResponse
}
type nodeWithCtxGetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mnodeWithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(nodeWithCtxGetAttrResponse{})
func (msg *nodeWithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxGetAttrResponse
}
type nodeWithCtxSetAttrRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
Flags NodeAttributeFlags `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mnodeWithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(nodeWithCtxSetAttrRequest{})
func (msg *nodeWithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxSetAttrRequest
}
type nodeWithCtxSetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mnodeWithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(nodeWithCtxSetAttrResponse{})
func (msg *nodeWithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxSetAttrResponse
}
type nodeWithCtxGetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Flags OpenFlags `fidl_offset_v2:"4"`
}
var _mnodeWithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(nodeWithCtxGetFlagsResponse{})
func (msg *nodeWithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxGetFlagsResponse
}
type nodeWithCtxSetFlagsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
}
var _mnodeWithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(nodeWithCtxSetFlagsRequest{})
func (msg *nodeWithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxSetFlagsRequest
}
type nodeWithCtxSetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mnodeWithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(nodeWithCtxSetFlagsResponse{})
func (msg *nodeWithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxSetFlagsResponse
}
type nodeWithCtxQueryFilesystemResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *FilesystemInfo `fidl_offset_v2:"8"`
}
var _mnodeWithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(nodeWithCtxQueryFilesystemResponse{})
func (msg *nodeWithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxQueryFilesystemResponse
}
type nodeWithCtxCloseResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}
var _mnodeWithCtxCloseResponse = _bindings.CreateLazyMarshaler(nodeWithCtxCloseResponse{})
func (msg *nodeWithCtxCloseResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxCloseResponse
}
type nodeWithCtxQueryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Identifies the underlying protocol.
Protocol uint64 `fidl_offset_v2:"0"`
}
var _mnodeWithCtxQueryResponse = _bindings.CreateLazyMarshaler(nodeWithCtxQueryResponse{})
func (msg *nodeWithCtxQueryResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxQueryResponse
}
type nodeWithCtxReopenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Requests rights on the new connection according to the specified rules.
//
// If absent, inherits the rights from the connection where the call
// is made.
RightsRequest *RightsRequest `fidl_offset_v2:"0"`
ObjectRequest _zx.Channel `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mnodeWithCtxReopenRequest = _bindings.CreateLazyMarshaler(nodeWithCtxReopenRequest{})
func (msg *nodeWithCtxReopenRequest) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxReopenRequest
}
type nodeWithCtxOnRepresentationResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Payload Representation `fidl_offset_v2:"0"`
}
var _mnodeWithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(nodeWithCtxOnRepresentationResponse{})
func (msg *nodeWithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxOnRepresentationResponse
}
type nodeWithCtxGetAttributesRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Set the corresponding bit to one to query that particular attribute.
//
// The elements here correspond one-to-one with [`NodeAttributes`].
Query NodeAttributesQuery `fidl_offset_v2:"0"`
}
var _mnodeWithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(nodeWithCtxGetAttributesRequest{})
func (msg *nodeWithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxGetAttributesRequest
}
type nodeWithCtxGetAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}
var _mnodeWithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(nodeWithCtxGetAttributesResponse{})
func (msg *nodeWithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxGetAttributesResponse
}
type nodeWithCtxUpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}
var _mnodeWithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(nodeWithCtxUpdateAttributesResponse{})
func (msg *nodeWithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxUpdateAttributesResponse
}
type nodeWithCtxSyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2SyncResult `fidl_offset_v2:"0"`
}
var _mnodeWithCtxSyncResponse = _bindings.CreateLazyMarshaler(nodeWithCtxSyncResponse{})
func (msg *nodeWithCtxSyncResponse) Marshaler() _bindings.Marshaler {
return _mnodeWithCtxSyncResponse
}
type node1WithCtxCloneRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
Object NodeWithCtxInterfaceRequest `fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mnode1WithCtxCloneRequest = _bindings.CreateLazyMarshaler(node1WithCtxCloneRequest{})
func (msg *node1WithCtxCloneRequest) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxCloneRequest
}
type node1WithCtxDescribeResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Info NodeInfo `fidl_offset_v2:"0"`
}
var _mnode1WithCtxDescribeResponse = _bindings.CreateLazyMarshaler(node1WithCtxDescribeResponse{})
func (msg *node1WithCtxDescribeResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxDescribeResponse
}
type node1WithCtxOnOpenResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"24" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *NodeInfo `fidl_offset_v2:"8"`
}
var _mnode1WithCtxOnOpenResponse = _bindings.CreateLazyMarshaler(node1WithCtxOnOpenResponse{})
func (msg *node1WithCtxOnOpenResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxOnOpenResponse
}
type node1WithCtxGetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mnode1WithCtxGetAttrResponse = _bindings.CreateLazyMarshaler(node1WithCtxGetAttrResponse{})
func (msg *node1WithCtxGetAttrResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxGetAttrResponse
}
type node1WithCtxSetAttrRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"`
Flags NodeAttributeFlags `fidl_offset_v2:"0"`
Attributes NodeAttributes `fidl_offset_v2:"8"`
}
var _mnode1WithCtxSetAttrRequest = _bindings.CreateLazyMarshaler(node1WithCtxSetAttrRequest{})
func (msg *node1WithCtxSetAttrRequest) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxSetAttrRequest
}
type node1WithCtxSetAttrResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mnode1WithCtxSetAttrResponse = _bindings.CreateLazyMarshaler(node1WithCtxSetAttrResponse{})
func (msg *node1WithCtxSetAttrResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxSetAttrResponse
}
type node1WithCtxGetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
Flags OpenFlags `fidl_offset_v2:"4"`
}
var _mnode1WithCtxGetFlagsResponse = _bindings.CreateLazyMarshaler(node1WithCtxGetFlagsResponse{})
func (msg *node1WithCtxGetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxGetFlagsResponse
}
type node1WithCtxSetFlagsRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
Flags OpenFlags `fidl_offset_v2:"0"`
}
var _mnode1WithCtxSetFlagsRequest = _bindings.CreateLazyMarshaler(node1WithCtxSetFlagsRequest{})
func (msg *node1WithCtxSetFlagsRequest) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxSetFlagsRequest
}
type node1WithCtxSetFlagsResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"4" fidl_alignment_v2:"4"`
S int32 `fidl_offset_v2:"0"`
}
var _mnode1WithCtxSetFlagsResponse = _bindings.CreateLazyMarshaler(node1WithCtxSetFlagsResponse{})
func (msg *node1WithCtxSetFlagsResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxSetFlagsResponse
}
type node1WithCtxQueryFilesystemResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
S int32 `fidl_offset_v2:"0"`
Info *FilesystemInfo `fidl_offset_v2:"8"`
}
var _mnode1WithCtxQueryFilesystemResponse = _bindings.CreateLazyMarshaler(node1WithCtxQueryFilesystemResponse{})
func (msg *node1WithCtxQueryFilesystemResponse) Marshaler() _bindings.Marshaler {
return _mnode1WithCtxQueryFilesystemResponse
}
type node2WithCtxCloseResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result fuchsiaunknown.CloseableCloseResult `fidl_offset_v2:"0"`
}
var _mnode2WithCtxCloseResponse = _bindings.CreateLazyMarshaler(node2WithCtxCloseResponse{})
func (msg *node2WithCtxCloseResponse) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxCloseResponse
}
type node2WithCtxQueryResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Identifies the underlying protocol.
Protocol uint64 `fidl_offset_v2:"0"`
}
var _mnode2WithCtxQueryResponse = _bindings.CreateLazyMarshaler(node2WithCtxQueryResponse{})
func (msg *node2WithCtxQueryResponse) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxQueryResponse
}
type node2WithCtxReopenRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
// Requests rights on the new connection according to the specified rules.
//
// If absent, inherits the rights from the connection where the call
// is made.
RightsRequest *RightsRequest `fidl_offset_v2:"0"`
ObjectRequest _zx.Channel `fidl_offset_v2:"8" fidl_handle_subtype:"4" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mnode2WithCtxReopenRequest = _bindings.CreateLazyMarshaler(node2WithCtxReopenRequest{})
func (msg *node2WithCtxReopenRequest) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxReopenRequest
}
type node2WithCtxOnRepresentationResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Payload Representation `fidl_offset_v2:"0"`
}
var _mnode2WithCtxOnRepresentationResponse = _bindings.CreateLazyMarshaler(node2WithCtxOnRepresentationResponse{})
func (msg *node2WithCtxOnRepresentationResponse) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxOnRepresentationResponse
}
type node2WithCtxGetAttributesRequest struct {
_ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"8"`
// Set the corresponding bit to one to query that particular attribute.
//
// The elements here correspond one-to-one with [`NodeAttributes`].
Query NodeAttributesQuery `fidl_offset_v2:"0"`
}
var _mnode2WithCtxGetAttributesRequest = _bindings.CreateLazyMarshaler(node2WithCtxGetAttributesRequest{})
func (msg *node2WithCtxGetAttributesRequest) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxGetAttributesRequest
}
type node2WithCtxGetAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2GetAttributesResult `fidl_offset_v2:"0"`
}
var _mnode2WithCtxGetAttributesResponse = _bindings.CreateLazyMarshaler(node2WithCtxGetAttributesResponse{})
func (msg *node2WithCtxGetAttributesResponse) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxGetAttributesResponse
}
type node2WithCtxUpdateAttributesResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2UpdateAttributesResult `fidl_offset_v2:"0"`
}
var _mnode2WithCtxUpdateAttributesResponse = _bindings.CreateLazyMarshaler(node2WithCtxUpdateAttributesResponse{})
func (msg *node2WithCtxUpdateAttributesResponse) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxUpdateAttributesResponse
}
type node2WithCtxSyncResponse struct {
_ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result Node2SyncResult `fidl_offset_v2:"0"`
}
var _mnode2WithCtxSyncResponse = _bindings.CreateLazyMarshaler(node2WithCtxSyncResponse{})
func (msg *node2WithCtxSyncResponse) Marshaler() _bindings.Marshaler {
return _mnode2WithCtxSyncResponse
}
type I_advisoryLockingAdvisoryLockResultTag uint64
const (
AdvisoryLockingAdvisoryLockResultResponse = 1 // 0x00000001
AdvisoryLockingAdvisoryLockResultErr = 2 // 0x00000002
)
type AdvisoryLockingAdvisoryLockResult struct {
I_advisoryLockingAdvisoryLockResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
Response AdvisoryLockingAdvisoryLockResponse `fidl_ordinal:"1"`
Err int32 `fidl_ordinal:"2"`
}
var _mAdvisoryLockingAdvisoryLockResult = _bindings.CreateLazyMarshaler(AdvisoryLockingAdvisoryLockResult{})
func (msg *AdvisoryLockingAdvisoryLockResult) Marshaler() _bindings.Marshaler {
return _mAdvisoryLockingAdvisoryLockResult
}
func (_m *AdvisoryLockingAdvisoryLockResult) reset() {
switch _m.I_advisoryLockingAdvisoryLockResultTag {
case 1:
var _zeroed AdvisoryLockingAdvisoryLockResponse
_m.Response = _zeroed
case 2:
var _zeroed int32
_m.Err = _zeroed
}
}
func (_m *AdvisoryLockingAdvisoryLockResult) Which() I_advisoryLockingAdvisoryLockResultTag {
return _m.I_advisoryLockingAdvisoryLockResultTag
}
func (_m *AdvisoryLockingAdvisoryLockResult) Ordinal() uint64 {
return uint64(_m.I_advisoryLockingAdvisoryLockResultTag)
}
func (_m *AdvisoryLockingAdvisoryLockResult) SetResponse(response AdvisoryLockingAdvisoryLockResponse) {
_m.reset()
_m.I_advisoryLockingAdvisoryLockResultTag = AdvisoryLockingAdvisoryLockResultResponse
_m.Response = response
}
func AdvisoryLockingAdvisoryLockResultWithResponse(response AdvisoryLockingAdvisoryLockResponse) AdvisoryLockingAdvisoryLockResult {
var _u AdvisoryLockingAdvisoryLockResult
_u.SetResponse(response)
return _u
}
func (_m *AdvisoryLockingAdvisoryLockResult) SetErr(err int32) {
_m.reset()
_m.I_advisoryLockingAdvisoryLockResultTag = AdvisoryLockingAdvisoryLockResultErr
_m.Err = err
}
func AdvisoryLockingAdvisoryLockResultWithErr(err int32) AdvisoryLockingAdvisoryLockResult {
var _u AdvisoryLockingAdvisoryLockResult
_u.SetErr(err)
return _u
}
type I_connectionProtocolsTag uint64
const (
ConnectionProtocols_unknownData = 0 // 0x00000000
ConnectionProtocolsConnector = 1 // 0x00000001
ConnectionProtocolsNode = 2 // 0x00000002
)
type ConnectionProtocols struct {
I_connectionProtocolsTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
I_unknownData interface{}
// Requests that the node's underlying protocol be served on the
// connection.
Connector ConnectorFlags `fidl_ordinal:"1"`
// Requests that the underlying [`Node`] protocol be served on the
// connection.
Node NodeOptions `fidl_ordinal:"2"`
}
var _mConnectionProtocols = _bindings.CreateLazyMarshaler(ConnectionProtocols{})
func (msg *ConnectionProtocols) Marshaler() _bindings.Marshaler {
return _mConnectionProtocols
}
func (_m *ConnectionProtocols) reset() {
switch _m.I_connectionProtocolsTag {
case 1:
var _zeroed ConnectorFlags
_m.Connector = _zeroed
case 2:
var _zeroed NodeOptions
_m.Node = _zeroed
default:
var _zeroed interface{}
_m.I_unknownData = _zeroed
}
}
func (_m *ConnectionProtocols) Which() I_connectionProtocolsTag {
switch _m.I_connectionProtocolsTag {
case 1:
return ConnectionProtocolsConnector
case 2:
return ConnectionProtocolsNode
default:
return ConnectionProtocols_unknownData
}
}
func (_m *ConnectionProtocols) Ordinal() uint64 {
return uint64(_m.I_connectionProtocolsTag)
}
func (_m *ConnectionProtocols) SetConnector(connector ConnectorFlags) {
_m.reset()
_m.I_connectionProtocolsTag = ConnectionProtocolsConnector
_m.Connector = connector
}
func ConnectionProtocolsWithConnector(connector ConnectorFlags) ConnectionProtocols {
var _u ConnectionProtocols
_u.SetConnector(connector)
return _u
}
func (_m *ConnectionProtocols) SetNode(node NodeOptions) {
_m.reset()
_m.I_connectionProtocolsTag = ConnectionProtocolsNode
_m.Node = node
}
func ConnectionProtocolsWithNode(node NodeOptions) ConnectionProtocols {
var _u ConnectionProtocols
_u.SetNode(node)
return _u
}
func (_m *ConnectionProtocols) GetUnknownData() _bindings.UnknownData {
return _m.I_unknownData.(_bindings.UnknownData)
}
type I_directory2RenameResultTag uint64
const (
Directory2RenameResultResponse = 1 // 0x00000001
Directory2RenameResultErr = 2 // 0x00000002
)
type Directory2RenameResult struct {
I_directory2RenameResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
Response Directory2RenameResponse `fidl_ordinal:"1"`
Err int32 `fidl_ordinal:"2"`
}
var _mDirectory2RenameResult = _bindings.CreateLazyMarshaler(Directory2RenameResult{})
func (msg *Directory2RenameResult) Marshaler() _bindings.Marshaler {
return _mDirectory2RenameResult
}
func (_m *Directory2RenameResult) reset() {
switch _m.I_directory2RenameResultTag {
case 1:
var _zeroed Directory2RenameResponse
_m.Response = _zeroed
case 2:
var _zeroed int32
_m.Err = _zeroed
}
}
func (_m *Directory2RenameResult) Which() I_directory2RenameResultTag {
return _m.I_directory2RenameResultTag
}
func (_m *Directory2RenameResult) Ordinal() uint64 {
return uint64(_m.I_directory2RenameResultTag)
}
func (_m *Directory2RenameResult) SetResponse(response Directory2RenameResponse) {
_m.reset()
_m.I_directory2RenameResultTag = Directory2RenameResultResponse
_m.Response = response
}
func Directory2RenameResultWithResponse(response Directory2RenameResponse) Directory2RenameResult {
var _u Directory2RenameResult
_u.SetResponse(response)
return _u
}
func (_m *Directory2RenameResult) SetErr(err int32) {
_m.reset()
_m.I_directory2RenameResultTag = Directory2RenameResultErr
_m.Err = err
}
func Directory2RenameResultWithErr(err int32) Directory2RenameResult {
var _u Directory2RenameResult
_u.SetErr(err)
return _u
}
type I_directory2UnlinkResultTag uint64
const (
Directory2UnlinkResultResponse = 1 // 0x00000001
Directory2UnlinkResultErr = 2 // 0x00000002
)
type Directory2UnlinkResult struct {
I_directory2UnlinkResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
Response Directory2UnlinkResponse `fidl_ordinal:"1"`
Err int32 `fidl_ordinal:"2"`
}
var _mDirectory2UnlinkResult = _bindings.CreateLazyMarshaler(Directory2UnlinkResult{})
func (msg *Directory2UnlinkResult) Marshaler() _bindings.Marshaler {
return _mDirectory2UnlinkResult
}
func (_m *Directory2UnlinkResult) reset() {
switch _m.I_directory2UnlinkResultTag {
case 1:
var _zeroed Directory2UnlinkResponse
_m.Response = _zeroed
case 2:
var _zeroed int32
_m.Err = _zeroed
}
}
func (_m *Directory2UnlinkResult) Which() I_directory2UnlinkResultTag {
return _m.I_directory2UnlinkResultTag
}
func (_m *Directory2UnlinkResult) Ordinal() uint64 {
return uint64(_m.I_directory2UnlinkResultTag)
}
func (_m *Directory2UnlinkResult) SetResponse(response Directory2UnlinkResponse) {
_m.reset()
_m.I_directory2UnlinkResultTag = Directory2UnlinkResultResponse
_m.Response = response
}
func Directory2UnlinkResultWithResponse(response Directory2UnlinkResponse) Directory2UnlinkResult {
var _u Directory2UnlinkResult
_u.SetResponse(response)
return _u
}
func (_m *Directory2UnlinkResult) SetErr(err int32) {
_m.reset()
_m.I_directory2UnlinkResultTag = Directory2UnlinkResultErr
_m.Err = err
}
func Directory2UnlinkResultWithErr(err int32) Directory2UnlinkResult {