1. Epic GamesDeveloper
  3. Spécificateurs et attributs

Spécificateurs et attributs

En savoir plus sur les spécificateurs et les attributs, et comment appliquer une sémantique et un comportement supplémentaires à votre code Verse.

Spécificateurs et attributs

Dans Verse, les spécificateurs décrivent le comportement lié à la sémantique, et peuvent ajouter des spécificateurs aux identificateurs et à certains mots-clés. La syntaxe du spécificateur utilise le mot-clé entre des chevrons (< et >). Par exemple, dans IsPuzzleSolved()<decides><transacts>:void, "decides" et "transacts" sont des spécificateurs.

Les attributs dans Verse décrivent un comportement utilisé en dehors du langage Verse (contrairement aux spécificateurs, qui décrivent la sémantique de Verse). La syntaxe d'attribut utilise l'arobase (@) suivie du mot-clé, par exemple @editable.

Dans les rubriques suivantes, nous vous décrivons tous les spécificateurs et les attributs disponibles dans Verse et vous expliquons quand vous pouvez les utiliser.

Spécificateurs d'effets

Dans Verse, les effets indiquent les catégories de comportement qu'une fonction est autorisée à présenter. Vous pouvez ajouter des spécificateurs d'effet :

  • Après les () dans une définition de fonction : name()<specifier>:type = codeblock.

  • Le mot-clé class : name := class<specifier>(){}.

Spécificateur Description Exemple

no_rollback

Il s'agit de l'effet par défaut lorsqu'aucun effet exclusif n'est spécifié. L'effet no_rollback indique qu'il est impossible d'annuler toute action exécutée par la fonction et qu'il est donc impossible d'utiliser la fonction dans un contexte d'échec. Il n'est pas possible de spécifier cet effet manuellement.

name():type = codeblock

transacts

L'effet <transacts> est une combinaison de <allocates>, <reads> et <writes>.  Il n'est pas possible de combiner l'effet <transacts> avec ces spécificateurs.

name()<transacts> : type = codeblock

# non autorisée, car transacts implique des lectures

name()<transacts><reads>: type = codeblock

# non autorisée, car transacts implique des écritures

name()<transacts><writes>: type = codeblock

allocates

Cet effet indique que la fonction peut instancier un objet en mémoire. Si la méthode est appelée dans un contexte d'échec qui échoue, les effets sont annulés.

name()<allocates> : type = codeblock

reads

Une méthode disposant de cet effet peut effectuer la lecture à partir d'un état mutable.

name()<reads> : type = codeblock

writes

Une méthode disposant de cet effet peut écrire sur un état mutable. Si la méthode est appelée dans un contexte d'échec qui échoue, les effets sont annulés.

name()<writes> : type = codeblock

computes

Une méthode <computes> garantit de renvoyer indéfiniment la même sortie pour toute entrée donnée. Une méthode <computes> ne peut pas être <transacts> <reads>, <writes> ou <allocates>.

name()<computes>

converges

Cet effet garantit non seulement qu'il n'y a pas d'effet secondaire lié à l'exécution de la fonction connexe, mais aussi que la fonction se termine définitivement (sans récursivité infinie). Cet effet peut apparaître uniquement dans les fonctions dotées du spécificateur native, bien que le compilateur n'effectue pas cette vérification. Le code qui fournit les valeurs par défaut des champs de classe ou les valeurs des variables globales doit avoir cet effet.

name()<converges> : type = codeblock

decides

Cet effet indique que la fonction peut échouer et que l'appel de cette fonction est une expression faillible. Étant donné qu'une fonction <decides> peut échouer, elle est mutuellement exclusive avec l'effet <suspends>. Il peut être utile de combiner <decides> avec l'effet <transacts> ou <computes>, ce qui permet d'annuler les actions effectuées par cette fonction (comme si les actions n'avaient jamais été effectuées) en cas d'échec n'importe où dans la fonction.

# autorisée

name()<decides><transacts> : type = codeblock

# autorisée

name()<decides><computes> : type = codeblock

# non autorisée, car decides et suspends s'excluent mutuellement

name()<decides><suspends> : type = codeblock

suspends

Cet effet indique que la fonction est asynchrone. Crée un contexte asynchrone pour le corps de la fonction. Il est mutuellement exclusif avec l'effet <decides>.

name()<suspends> : type = codeblock

# non autorisée, car decides et suspends s'excluent mutuellement

name()<decides><suspends> : type = codeblock

Dans tous les cas, l'appel d'une fonction qui a un effet spécifique exige que l'appelant dispose également de cet effet.

Spécificateurs d'accès

Les spécificateurs d'accès définissent les éléments qui peuvent interagir avec un membre et leur mode d'interaction. Vous pouvez appliquer des spécificateurs d'accès aux éléments suivants :

  • L'identificateur d'un membre : name<specifier> : type = value

  • Le mot clé var d'un membre : var<specifier> name : type = value

Vous pouvez avoir un spécificateur d'accès à la fois sur l'identificateur et sur le mot-clé var pour une variable, pour différencier qui a accès à la lecture et à l'écriture de la variable. Par exemple, la variable suivante MyInteger a le spécificateur public sur l'identificateur afin que n'importe qui puisse lire la valeur, mais le mot-clé var a le spécificateur protégé afin que seuls la classe actuelle et les sous-types puissent écrire dans la variable.

Verse 
var<protected> MyInteger<public>:int = 2
Spécificateur Description Utilisation Exemple

public

L'identificateur est universellement accessible.

Vous pouvez utiliser ce spécificateur sur :

  • module

  • classe

  • interface

  • struct

  • enum

  • method (méthode)

  • données

Verse 
name<public> : type = value

protégé

L'identificateur n'est accessible qu'à la classe actuelle et à ses sous-types.

Vous pouvez utiliser ce spécificateur sur :

  • classe

  • interface

  • struct

  • fonctions au sein d'une classe

  • enum

  • méthode sans module

  • données

Verse 
name<protected> : type = value

privé

Il est possible d'accéder à l'identificateur uniquement dans l'étendue actuelle, immédiatement englobante (que ce soit un module, une classe, une structure, etc.).

Vous pouvez utiliser ce spécificateur sur :

  • classe

  • interface

  • struct

  • fonctions au sein d'une classe

  • enum

  • méthode sans module

  • données

Verse 
name<private> : type = value

interne

Il est possible d'accéder à l'identificateur uniquement dans le module actuel, immédiatement englobant. Il s'agit du niveau d'accès par défaut.

Vous pouvez utiliser ce spécificateur sur :

  • module

  • classe

  • interface

  • struct

  • enum

  • method (méthode)

  • données

Verse 
name<internal> : type = value

À portée

L'identificateur n'est accessible que dans la portée actuelle et dans toutes les étendues englobantes. Toute ressource que vous exposez à Verse apparaissant dans le fichier Assets.digest.Verse a le spécificateur <scoped>.

Vous pouvez utiliser ce spécificateur sur :

  • module

  • classe

  • interface

  • fonctions

  • struct

  • enum

  • méthode sans module

  • données

Verse 
# Enclosing scope for ModuleB and ModuleC.
ModuleA<public> := module:
    
    ModuleB<public> := module:

        # Internal to ModuleB.
        class_b1 := class{}

        # Allows access from anywhere inside ModuleA.
        class_b2<scoped{ModuleA}> := class {}

Spécificateurs de classe

Les spécificateurs de classe définissent certaines caractéristiques des classes ou de leurs membres ; ils indiquent par exemple si vous pouvez créer une sous-classe d'une classe.

Spécificateur Description Exemple

abstract

Lorsqu'une classe ou une méthode de classe possède le spécificateur abstract, vous ne pouvez pas créer une instance de la classe. Les classes abstraites sont destinées à être utilisées comme une superclasse avec une mise en œuvre partielle, ou comme une interface commune. Elles sont utiles lorsque vous n'avez pas besoin des instances d'une super-classe, mais que vous ne souhaitez pas dupliquer les propriétés et les comportements de classes semblables.

Verse 
pet := class<abstract>():
    Speak() : void

cat := class(pet):
    Speak() : void = {}

castable

Indique que ce type peut être dynamiquement converti. Le spécificateur <castable> est concernée par une restriction de compatibilité descendante. Une fois qu'une classe ou une interface est publiée, l'attribut <castable> ne peut être ni ajouté ni supprimé. Cela n'est pas autorisé en raison de comportements de conversion dangereux.

Le type castable_subtype fonctionne de manière très similaire à subtype, mais nécessite que tous les types utilisés avec lui soient également marqués <castable>. Cela augmente la sécurité du code aux endroits où des conversions dynamiques sont utilisées.

Verse 
my_base := class {}

my_castable_type := class<castable>(my_base) {}

my_child_type := class(my_castable_type) {}

MySubtypeFunction(t:castable_subtype(my_base)):void=
    return

Main()<decides>:void =

concrete

Lorsqu'une classe possède le spécificateur concrete, il est possible de construire une instance de la classe avec un archétype vide, ce qui signifie que chaque champ de la classe doit avoir une valeur par défaut. Toute sous-classe d'une classe concrète est implicitement concrète. Une classe `concrete` ne peut hériter directement d'une classe `abstract` que si les deux classes sont définies dans le même module.

Verse 
cat := class<concrete>():
     # field must be initialized because the class is concrete
    Name : string = "Cat"

unique

À chaque classe unique dans Verse est attribuée une identité unique pour chaque instance. Cela signifie que, même si deux instances de la même classe unique ont les mêmes valeurs de champ, elles ne sont pas égales, car ce sont des instances distinctes. Cela permet aux instances de classes uniques d'être comparées en matière d'égalité selon leurs identités. Les classes sans spécificateur unique n'ont pas d'identité de ce type ; il est donc uniquement possible de comparer leur égalité sur la base des valeurs de leurs champs. Cela signifie que les classes `unique` peuvent être comparées avec les opérateurs = et <>, et sont des sous-types du type `comparable`.

Verse 
unique_class := class<unique>:
    Field : int

Main()<decides> : void =
    X := unique_class{Field := 1}
    X = X # X is equal to itself
    Y := unique_class{Field := 1}
    X <> Y # X and Y are unique and therefore not equal

final

Vous ne pouvez utiliser le spécificateur final que sur les classes et les membres des classes, avec les restrictions suivantes :

  • Lorsqu'une classe possède le spécificateur final, vous ne pouvez pas créer de sous-classe de cette classe.

  • Lorsqu'un champ possède le spécificateur final, vous ne pouvez pas remplacer le champ dans une sous-classe.

  • Lorsqu'une méthode possède le spécificateur `final`, vous ne pouvez pas remplacer la méthode dans une sous-classe.

Verse 
cat := class<final>():

final_super

Le spécificateur final_super s'applique uniquement aux définitions de classe et nécessite que la définition de classe dérive d'une classe ou d'une interface parente. Ce spécificateur impose une contrainte de compatibilité future selon laquelle la classe donnée dérivera toujours directement de son parent, pour cette version et toutes les futures versions publiées de cette définition de classe.

Cela est nécessaire dans Scene Graph pour que les sous-types immédiats de component limitent le nombre d'instances à exactement zéro ou une par entité Scene Graph. Cette limite s'étend également aux sous-types de ces types.

Verse 
component := class {}
my_final_class := class<final_super>(component) {}

# Not allowed since my_final_class has the final_super specifier.
my_subclass_type := class(my_final_class) {}

Spécificateur de persistance

Lorsqu'un type personnalisé, tel qu'une classe, possède le spécificateur <persistable>, vous pouvez l'utiliser dans vos variables weak_map à étendue de module et faire persister ses valeurs d'une session de jeu à une autre. Pour en savoir plus sur la persistance dans Verse, consultez la page Utiliser des données persistantes dans Verse.

Le spécificateur persistable est utilisable avec les types suivants. Suivez les liens pour en savoir plus.

Spécificateurs Open et Closed

Actuellement disponibles uniquement avec les énumérations. Les spécificateurs <open> et <closed> déterminent la façon dont vous pouvez modifier la définition de l'énumération une fois votre île publiée.

Vous pouvez utiliser les spécificateurs open et closed avec les types suivants. Suivez les liens pour en savoir plus.

Spécificateur Description Exemple

Open

Spécificateur qui s'applique actuellement uniquement aux énumérations.

Vous pouvez ajouter ou réorganiser les valeurs d'énumération dans une énumération ouverte, ou la convertir en énumération <closed>.

Les énumérations ouvertes sont principalement utilisées lorsque vous prévoyez que le nombre de valeurs dans votre énumération peut augmenter à l'avenir. Par exemple, une énumération de types d'armes.

Verse 
# Enums are <closed> by default so you must explicitly define the enum as an open enum with the <open> specifier
my_enum := enum<open>{Value1, Value2, Value3}

Closed

Spécificateur qui s'applique actuellement uniquement aux énumérations.

Les énumérations sont fermées par défaut.

Les énumérations fermées conviennent mieux dans les cas où vos valeurs sont censées rester les mêmes, par exemple les jours de la semaine.

Verse 
# Enums are <closed> by default so the specifier is not required.
my_enum := enum{Value1, Value2, Value3}

# You can also explicitly define the enum as closed by adding the <closed> specifier
my_enum := enum<closed>{Value1, Value2, Value3}

Spécificateurs d'implémentation

Il n'est pas possible d'utiliser les spécificateurs d'implémentation lors de l'écriture du code ; vous verrez ultérieurement comment les utiliser dans les API de l'UEFN.

Spécificateur Description Exemple

native

Indique que les détails de la définition de l'élément sont implémentés en C++. Les définitions Verse avec le spécificateur native génèrent automatiquement des définitions C++. Un développeur Verse peut alors compléter sa mise en œuvre. Vous pouvez observer l'utilisation de ce spécificateur sur :

  • classe

  • interface

  • enum

  • method (méthode)

  • données

Verse 
GetCreativeObjectsWithTag<native><public>(Tags:tag)<transacts>:[]creative_object_interface

native_callable

Indique qu'une méthode d'instance est à la fois native (implémentée en C++) et peut être appelée par d'autres codes C++. Ce spécificateur est utilisé sur une méthode d'instance. Ce spécificateur ne se propage pas aux sous-classes, vous n'avez donc pas besoin de l'ajouter à une définition lorsque vous remplacez une méthode disposant de ce spécificateur.

Verse 
creative_device<native><public> := class<concrete>:
    OnBegin<public>()<suspends>:void = external {}

    OnEnd<native_callable><public>():void = external {}

Attributs

Les attributs dans Verse décrivent un comportement utilisé en dehors du langage Verse (contrairement aux spécificateurs, qui décrivent la sémantique de Verse). Il est possible d'ajouter des attributs sur la ligne de code précédant les définitions.

La syntaxe d'attribut utilise l'arobase (@) suivie du mot-clé.

Attribut Description Exemple

editable

Indique que ce champ est une propriété exposée qui peut être modifiée directement à partir de l'UEFN. Vous n'avez donc pas besoin de modifier le code Verse pour changer sa valeur. Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.

Verse 
@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}

editable_text_box

Une chaîne modifiable qui s'affiche sous forme de zone de texte dans l'éditeur. Les zones de texte modifiables ne prennent actuellement pas en charge les infobulles ni les catégories.  Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.  

Verse 
# An editable string that displays as a text box in the editor.
# Editable text boxes currently do not support tooltips or categories.
@editable_text_box:
    # Whether this text can span multiple lines.
    MultiLine := true

    # The maximum amount of characters this text block can display.
    MaxLength := 32
MessageBox:string = "This is a short message!"

editable_slider

Un curseur modifiable qui utilise le type float. Vous pouvez faire glisser le curseur dans l'éditeur pour augmenter ou diminuer la valeur. Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.  

Verse 
# An editable slider that uses the float type. You can drag the slider in the editor to increase
# or decrease the value.
@editable_slider(float):
    # The categories this editable belongs to.
    Categories := array{FloatsCategory}

    # The tool tip for this editable.
    ToolTip := SliderTip

    # The minimum value of each component. You cannot set an editable value for this number lower

editable_number

Nombre modifiable avec une valeur minimum et une valeur maximum.  Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.  

Verse 
# An editable number with minimum and maximum
@editable_number(int):

    # The tool tip for this editable.
    ToolTip := EditableIntTip

    # The category this editable belongs to.
    Categories := array{IntsCategory}

    # The minimum value of each component. You cannot set an editable value for this number lower

editable_vector_slider

Un curseur vectoriel modifiable. Vous pouvez le faire glisser pour modifier les valeurs de chacun des composants vectoriels.  Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.  

Verse 
# An editable vector slider. You can drag to change the values of each of the vector components.
@editable_vector_slider(float):
    # The tool tip for this editable.
    ToolTip := VectorSliderTip

    # The categories this editable belongs to.
    Categories := array{FloatsCategory}

    # Shows the option to preserve the ratio between vector values in the editor.
    ShowPreserveRatio := true

editable_vector_number

Numéro de vecteur modifiable, qui peut être vector2, vector2i ou vector3.  Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.  

Verse 
# An editable vector number, which can be a vector2, vector2i, or vector3.
@editable_vector_number(float):

    # The categories this editable belongs to.
    Categories := array{FloatsCategory}

    # The tool tip for this editable.
    ToolTip := VectorFloatTip

    # Shows the option to preserve the ratio between vector values in the editor.

editable_container

Un conteneur de valeurs modifiable. Il ne prend actuellement en charge que les matrices.  Pour en savoir plus, consultez la rubrique Personnaliser les propriétés de l'appareil.  

Verse 
An editable container of values. Currently, this only supports arrays.
@editable_container:

    # The category this editable belongs to.
    Categories := array{IntsCategory}

    # The tool tip for this editable.
    ToolTip := IntArrayTip

    # Whether dragging elements to reorder this container is allowed.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page