Specificatori e attributi

name() : type = codeblock
Copy full snippet

no_rollback: è l'effetto predefinito quando non viene specificato un effetto esclusivo. L'effetto no_rollback indica che qualsiasi azione eseguita dalla funzione non può essere annullata e quindi la funzione non può essere utilizzata in un contesto di errore. Questo effetto non può essere specificato manualmente.

name()<transacts> : type = codeblock
Copy full snippet

transacts: questo effetto indica che può essere eseguito il rollback di qualsiasi azione eseguita dalla funzione. L'effetto transacts è richiesto ogni volta che viene scritta una variabile modificabile (var). Se l'effetto transacts è stato aggiunto a una funzione di cui non può essere eseguito il rollback, riceverai una notifica quando compilerai il tuo codice. Tieni presente che questo controllo non viene effettuato per le funzioni con lo specificatore native.

name()<varies> : type = codeblock
Copy full snippet

varies: questo effetto indica che lo stesso input della funzione potrebbe non generare sempre lo stesso output. L'effetto varies indica anche che non c'è alcuna garanzia che il comportamento della funzione rimanga invariato con le nuove versioni del pacchetto che la contiene.

name()<computes> : type = codeblock
Copy full snippet

computes: questo effetto richiede che la funzione non abbia effetti collaterali e non è garantito che venga completata. Esiste un requisito non controllato che la funzione, se fornita con gli stessi argomenti, generi lo stesso risultato. Qualsiasi funzione che non disponga dello specificatore native e che altrimenti avrebbe l'effetto converge è un buon esempio di utilizzo dell'effetto compute.

name()<converges> : type = codeblock
Copy full snippet

converges: questo effetto garantisce non solo che non ci siano effetti collaterali dall'esecuzione della funzione correlata, ma anche che la funzione si completi definitivamente (non sia ricorsiva all'infinito). Questo effetto può essere visualizzato solo nelle funzioni che hanno lo specificatore native, ma ciò non viene controllato dal compilatore. Il codice utilizzato per fornire valori predefiniti di classi o valori per variabili globali deve avere questo effetto. Le funzioni sin(), cos() e tan() sono esempi di funzioni che hanno l'effetto converges.

name()<transacts><decides> : type = codeblock
Copy full snippet

decides: indica che la funzione può non riuscire e che la chiamata a questa funzione è un'espressione fallibile. Le definizioni di funzioni con l'effetto decides devono avere anche l'effetto transacts, il che significa che è possibile eseguire il rollback delle azioni eseguite da questa funzione (come se non fossero mai state effettuate), se si verifica un errore in qualche punto della funzione.

name()<suspends> : type = codeblock
Copy full snippet

suspends: indica che la funzione è asincrona. Crea un contesto asincrono per il corpo della funzione.

name<public> : type = value
Copy full snippet

Pubblico: l'identificatore è universalmente accessibile. Puoi utilizzare questo specificatore su:

• un modulo
• una classe
• un'interfaccia
• una struttura
• un'enumerazione
• un metodo
• dei dati

name<protected> : type = value
Copy full snippet

Protetto: l'identificatore può essere consultato solo alla classe corrente e agli eventuali sottotipi. Puoi utilizzare questo specificatore su:

• una classe
• un'interfaccia
• una struttura
• un'enumerazione
• un metodo non modulo
• dei dati

name<private> : type = value
Copy full snippet

Privato: l'identificatore può essere consultato solo nell'ambito corrente, di inclusione immediata (sia esso un modulo, una classe, una struttura, ecc.). Puoi utilizzare questo specificatore su:

• una classe
• un'interfaccia
• una struttura
• un'enumerazione
• un metodo non modulo
• dei dati

name<internal> : type = value
Copy full snippet

Interno: l'identificatore può essere consultato solo nel modulo corrente di inclusione immediata. È il livello di accesso predefinito. Puoi utilizzare questo specificatore su:

• un modulo
• una classe
• un'interfaccia
• una struttura
• un'enumerazione
• un metodo
• dei dati

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

cat := class(pet):
    Speak() : void = {}
Copy full snippet

abstract: quando una classe o un metodo di classe ha lo specificatore abstract, non è possibile creare un'istanza della classe. Le classi astratte sono destinate a essere utilizzate come superclassi con implementazione parziale o come interfaccia comune. È utile quando non ha senso avere istanze di una superclasse, ma non si vogliono duplicare proprietà e comportamenti di classi simili.

cat := class<concrete>():
     # il campo deve essere inizializzato perché la classe è concreta
    Name : string = "Gatto"
Copy full snippet

concrete: quando una classe ha lo specificatore concrete, deve essere possibile costruirla con un archetipo vuoto, il che significa che ogni campo della classe deve avere un valore predefinito. Ogni sottoclasse di una classe concreta è implicitamente concreta. Una classe concreta può ereditare direttamente da una classe astratta, solo se entrambe le classi sono definite nello stesso modulo.

unique_class := class<unique>:
    Field : int

Main()<decides> : void =
    X := unique_class{Field := 1}
    X = X # X è uguale a se stesso
    Y := unique_class{Field := 1}
    X <> Y # X e Y sono univoci e quindi non sono uguali
Copy full snippet

unique: lo specificatore unique può essere applicato a una classe per renderla univoca. Per costruire un'istanza di una classe univoca, Verse alloca un'identità univoca per l'istanza risultante. Ciò consente di confrontare le istanze di classi univoche per l'uguaglianza confrontando le loro identità. Le classi prive dello specificatore univoco non hanno tale identità e quindi si possono confrontare solo per l'uguaglianza in base ai valori dei loro campi. Ciò significa che le classi univoche si possono confrontare con gli operatori = e <> e sono sottotipi del tipo confrontabile.

cat := class<final>():
Copy full snippet

final: lo specificatore finale può essere utilizzato soltanto su queste classi e campi di classi:

• Quando una classe ha uno specificatore finale, non è possibile creare una sottoclasse della classe.
• Quando un campo ha lo specificatore finale, non è possibile eseguire l'override del campo in una sottoclasse.
• Quando un metodo ha uno specificatore finale, non è possibile eseguire l'override del metodo in una sottoclasse.

GetDevicesWithTag<native><public>(Tag : tag) : []creative_device_base
Copy full snippet

native: indica che i dettagli di definizione dell'elemento sono implementati in C++. Le definizioni di Verse con lo specificatore native generano automaticamente definizioni C++ che lo sviluppatore può successivamente compilare con la sua implementazione. Puoi vedere questo specificatore utilizzato su:

• una classe
• un'interfaccia
• un'enumerazione
• un metodo
• dei dati

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

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

native_callable: indica che un metodo di istanza è nativo (implementato in C++) e può essere richiamato da altro codice C++. Puoi vedere questo specificatore utilizzato su un metodo di istanza. Questo specificatore non si propaga alle sottoclassi e quindi non è necessario aggiungerlo a una definizione, quando esegui l'override di un metodo che include lo specificatore stesso

@editable
Platform : color_changing_tiles_device = color_changing_tiles_device{}
Copy full snippet

editable: indica che questo campo è una proprietà esposta che può essere modificata direttamente tramite UEFN, quindi non è necessario modificare il codice Verse per cambiarne il valore. Per maggiori dettagli, vedi Personalizzare le proprietà del dispositivo.

@doc("Data una distanza lungo la lunghezza di questa spline, restituisce i valori dei dati associati a quel punto")
QueryAtDistanceAlongSpline<native><public>(DistanceAlongSpline : float, bIsWorldSpace : logic)<transacts><decides> : spline_query_result
Copy full snippet

doc: un campo della nota generico che si trova nelle classi e nelle funzioni (ma non nei parametri delle funzioni). Deve contenere informazioni utili sulle operazioni che esegue l'elemento che descrive o su come utilizzarlo, e viene usato per popolare la pagina di quell'elemento nella guida API di Verse.