Liste de déclaration constante tapée

Question

Je souhaite créer une liste "en énumération" de constantes avec les propriétés suivantes:

1. Les valeurs de chaque identifiant sont séquentielles, avec quelques lacunes. (Je crois que l'Iota et l'identifiant vierge aident à cet égard).
2. Les identifiants sont privés du module.
3. Les constantes ne peuvent être comparées qu'avec d'autres constantes du même type.

L'énumération est basée sur le enum fuse_opcode de FUSIBLE. Voici un code pour ce que j'essaie d'accomplir (et aussi très mal):

const Opcode (
    _ = iota // skip 0
    lookupOp
    forgetOp
    getattrOp
    setattrOp
    readlinkOp
    symlinkOp // 6
    _ // skip 7
    mknodOp // 8
    // et cetera ad nauseam
)

Answer 1

Voici le code Go pour les OPCodes Fuse. Il a été créé à partir de enum fusible_opcode. En règle générale, vous écririez un script pour ce faire; J'ai utilisé un éditeur de texte. Étant donné que les valeurs constantes correspondent aux valeurs d'énumération C, des valeurs explicites sont utilisées.

package fuse

type opCode int32

const (
    opLookup      = 1
    opForget      = 2
    opGetattr     = 3
    opSetattr     = 4
    opReadlink    = 5
    opSymlink     = 6
    opMknod       = 8
    opMkdir       = 9
    opUnlink      = 10
    opRmdir       = 11
    opRename      = 12
    opLink        = 13
    opOpen        = 14
    opRead        = 15
    opWrite       = 16
    opStatfs      = 17
    opRelease     = 18
    opFsync       = 20
    opSetxattr    = 21
    opGetxattr    = 22
    opListxattr   = 23
    opRemovexattr = 24
    opFlush       = 25
    opInit        = 26
    opOpendir     = 27
    opReaddir     = 28
    opReleasedir  = 29
    opFsyncdir    = 30
    opGetlk       = 31
    opSetlk       = 32
    opSetlkw      = 33
    opAccess      = 34
    opCreate      = 35
    opInterrupt   = 36
    opBmap        = 37
    opDestroy     = 38
    opIoctl       = 39
    opPoll        = 40
    opNotifyReply = 41
)

Answer 2

Vous voulez quelque chose comme ça. Vous pouvez toujours comparer ces constantes avec des entiers littéraux (il n'y a aucun moyen d'empêcher cela), mais toute comparaison ou affectation à d'autres valeurs entières obtiendra une erreur de compilateur.

type opCode int

const (
    lookupOp opCode = iota+1
    forgetOp
    getattrOp
    setattrOp
    readlinkOp
    symlinkOp // 6
    _         // skip 7
    mknodOp   // 8
    // et cetera ad nauseam
)

Si vous voulez vraiment empêcher les forfaits externes de voir le fait que ce sont des constantes entières, mais vous voulez toujours cela comparable, vous pourriez envisager de faire quelque chose comme ça,

type OpCode struct {
    code opCode
}

et exposant uniquement Opcode dans votre API. Je suggère également de documenter explicitement que c'est comparable.

Answer 3

package fuse

type opCode int32

const (
    opLookup  opCode    = 1
    opForget  opCode    = 2
    opGetattr opCode    = 3
    opSetattr  opCode   = 4
    opReadlink opCode   = 5
    opSymlink  opCode   = 6
    opMknod   opCode    = 8
    opMkdir   opCode    = 9
    opUnlink   opCode   = 10
)