Package adalid.core

Class Operation

    • Constructor Detail

      • Operation

        public Operation()

    • Method Detail

      • getSelectOperationKey

        public static String getSelectOperationKey()

      • getInsertOperationKey

        public static String getInsertOperationKey()

      • getUpdateOperationKey

        public static String getUpdateOperationKey()

      • getDeleteOperationKey

        public static String getDeleteOperationKey()

      • getCrudOperationKeys

        public static String[] getCrudOperationKeys()

      • and

        protected static BooleanOrderedPairX and​(BooleanExpression operand1,
                                         BooleanExpression operand2)
        La conjunción (AND) es un operador lógico que resulta en verdadero si ambos operandos son verdadero.
        Parameters:
        operand1 - X
        operand2 - Y
        Returns:
        verdadero si ambos operandos son verdadero; de lo contrario, falso.

      • nand

        protected static BooleanOrderedPairX nand​(BooleanExpression operand1,
                                          BooleanExpression operand2)
        La negación alternativa (NAND) es un operador lógico que resulta en verdadero si uno de los operandos es falso. Es equivalente a la negación (NOT) de la conjunción (AND).
        Parameters:
        operand1 - X
        operand2 - Y
        Returns:
        verdadero si uno de los operandos es falso; de lo contrario, falso.

      • or

        protected static BooleanOrderedPairX or​(BooleanExpression operand1,
                                        BooleanExpression operand2)
        La disyunción (OR) es un operador lógico que resulta en verdadero si uno de los operandos es verdadero.
        Parameters:
        operand1 - X
        operand2 - Y
        Returns:
        verdadero si uno de los operandos es verdadero; de lo contrario, falso.

      • nor

        protected static BooleanOrderedPairX nor​(BooleanExpression operand1,
                                         BooleanExpression operand2)
        La negación conjunta (NOR) es un operador lógico que resulta en verdadero si ambos operandos son falso. Es equivalente a la negación (NOT) de la disyunción (OR).
        Parameters:
        operand1 - X
        operand2 - Y
        Returns:
        verdadero si ambos operandos son falso; de lo contrario, falso.

      • xor

        protected static BooleanOrderedPairX xor​(BooleanExpression operand1,
                                         BooleanExpression operand2)
        La disyunción exclusiva (XOR) es un operador lógico que resulta en verdadero si uno y solo uno de los operandos es verdadero.
        Parameters:
        operand1 - X
        operand2 - Y
        Returns:
        verdadero si uno y solo uno de los operandos es verdadero; de lo contrario, falso.

      • xnor

        protected static BooleanOrderedPairX xnor​(BooleanExpression operand1,
                                          BooleanExpression operand2)
        La equivalencia (XNOR) es un operador lógico que resulta en verdadero si ambos operandos son verdadero ó si ambos son falso. Es equivalente a la negación (NOT) de la disyunción exclusiva (XOR).
        Parameters:
        operand1 - X
        operand2 - Y
        Returns:
        verdadero si ambos operandos son verdadero ó si ambos son falso; de lo contrario, falso.

      • xImpliesY

        protected static BooleanOrderedPairX xImpliesY​(BooleanExpression operandX,
                                               BooleanExpression operandY)
        La condicional material (X_IMPLIES_Y) es un operador lógico que resulta en falso solo si X es verdadero y Y es falso. Es equivalente a la disyunción (OR) de la negación (NOT) de X con Y (NOT X OR Y).
        Parameters:
        operandX - X
        operandY - Y
        Returns:
        falso solo si X es verdadero y Y es falso; de lo contrario, verdadero.

      • and

        protected static BooleanDataAggregateX and​(BooleanExpression operand1,
                                           BooleanExpression operand2,
                                           BooleanExpression... extraOperands)
        La conjunción (AND) es un operador lógico que resulta en verdadero si todos los operandos son verdadero.
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si todos los operandos son verdadero; de lo contrario, falso.

      • nand

        protected static BooleanDataAggregateX nand​(BooleanExpression operand1,
                                            BooleanExpression operand2,
                                            BooleanExpression... extraOperands)
        La negación alternativa (NAND) es un operador lógico que resulta en verdadero si al menos uno de los operandos es falso. Es equivalente a la negación (NOT) de la conjunción (AND).
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si al menos uno de los operandos es falso; de lo contrario, falso.

      • or

        protected static BooleanDataAggregateX or​(BooleanExpression operand1,
                                          BooleanExpression operand2,
                                          BooleanExpression... extraOperands)
        La disyunción (OR) es un operador lógico que resulta en verdadero si al menos uno de los operandos es verdadero.
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si al menos uno de los operandos es verdadero; de lo contrario, falso.

      • nor

        protected static BooleanDataAggregateX nor​(BooleanExpression operand1,
                                           BooleanExpression operand2,
                                           BooleanExpression... extraOperands)
        La negación conjunta (NOR) es un operador lógico que resulta en verdadero si todos los operandos son falso. Es equivalente a la negación (NOT) de la disyunción (OR).
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si todos los operandos son falso; de lo contrario, falso.

      • naxor

        protected static BooleanDataAggregateX naxor​(BooleanExpression operand1,
                                             BooleanExpression operand2,
                                             BooleanExpression... extraOperands)
        La disyunción exclusiva no-asociativa (NAXOR) es un operador lógico que resulta en verdadero si uno y solo uno de los operandos es verdadero.
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si uno y solo uno de los operandos es verdadero; de lo contrario, falso.

      • naxnor

        protected static BooleanDataAggregateX naxnor​(BooleanExpression operand1,
                                              BooleanExpression operand2,
                                              BooleanExpression... extraOperands)
        La equivalencia no-asociativa (NAXNOR) es un operador lógico que resulta en verdadero si todos los operandos son verdadero ó si todos son falso. Es equivalente a la negación (NOT) de la disyunción exclusiva no-asociativa (NAXOR).
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si todos los operandos son verdadero ó si todos son falso; de lo contrario, falso.

      • norOrNaxor

        protected static BooleanDataAggregateX norOrNaxor​(BooleanExpression operand1,
                                                  BooleanExpression operand2,
                                                  BooleanExpression... extraOperands)
        NOR_OR_NAXOR es un operador lógico compuesto que resulta en verdadero si uno y solo uno de los operandos es verdadero ó si todos son falso. Es equivalente a la disyunción (OR) de la negación conjunta (NOR) y la disyunción exclusiva no-asociativa (NAXOR). Con solo dos operandos también es equivalente a la negación alternativa (NAND).
        Parameters:
        operand1 - X
        operand2 - Y
        extraOperands - operandos adicionales
        Returns:
        verdadero si uno y solo uno de los operandos es verdadero ó si todos son falso; de lo contrario, falso.

      • not

        protected static BooleanScalarX not​(BooleanExpression x)
        La negación (NOT), también llamada complemento lógico, es un operador lógico que resulta en verdadero si el operando es falso, y viceversa.
        Parameters:
        x - operando X
        Returns:
        verdadero si el operando es falso, y viceversa.

      • isInitialised

        public boolean isInitialised()
        Returns:
        the initialised indicator

      • isSettled

        public boolean isSettled()
        Returns:
        the settled indicator

      • isFinished

        public boolean isFinished()
        Returns:
        the finished indicator

      • isAnnotatedWithOperationClass

        public boolean isAnnotatedWithOperationClass()
        Returns:
        the OperationClass annotation indicator

      • isAnnotatedWithOperationDocGen

        public boolean isAnnotatedWithOperationDocGen()
        Returns:
        the OperationDocGen annotation indicator

      • getProperName

        public String getProperName()
        Returns:
        the proper name

      • getParametersList

        public List<Parameter> getParametersList()
        Returns:
        the parameters list

      • getInstanceParameter

        public Parameter getInstanceParameter()
        Returns:
        the instance parameter (if any)

      • getExpressionsList

        public List<Expression> getExpressionsList()
        Returns:
        the expressions

      • getInitialStatesList

        public List<State> getInitialStatesList()

      • getFinalStatesList

        public List<State> getFinalStatesList()

      • getChecksList

        public List<Check> getChecksList()

      • getDatabaseTriggerChecksList

        public List<Check> getDatabaseTriggerChecksList()

      • getUserInterfaceChecksList

        public List<Check> getUserInterfaceChecksList()

      • getInstanceParameterChecksList

        public List<Check> getInstanceParameterChecksList()

      • getTransitionsList

        public List<Transition> getTransitionsList()
        Returns:
        the transitions

      • getCheckReferencedColumnsList

        public List<Property> getCheckReferencedColumnsList()

      • getDatabaseTriggerCheckReferencedColumnsList

        public List<Property> getDatabaseTriggerCheckReferencedColumnsList()

      • getUserInterfaceCheckReferencedColumnsList

        public List<Property> getUserInterfaceCheckReferencedColumnsList()

      • getParametersMap

        public Map<String,​Parameter> getParametersMap()
        Returns:
        the parameters map

      • getExpressionsMap

        public Map<String,​Expression> getExpressionsMap()
        Returns:
        the expressions

      • getTransitionsMap

        public Map<String,​Transition> getTransitionsMap()
        Returns:
        the transitions

      • getTriggersMap

        public Map<String,​Trigger> getTriggersMap()
        Returns:
        the triggers

      • getOperationType

        public OperationType getOperationType()
        Returns:
        the operation type

      • getOperationKind

        public OperationKind getOperationKind()
        Returns:
        the kind of operation

      • getOperationAccess

        public OperationAccess getOperationAccess()
        Returns:
        the access type

      • isAsynchronous

        public boolean isAsynchronous()
        Returns:
        the asynchronous execution indicator

      • isConfirmationRequired

        public boolean isConfirmationRequired()
        Returns:
        the confirmation required indicator

      • isComplex

        public boolean isComplex()
        Returns:
        the complex operation indicator

      • isSimple

        public boolean isSimple()
        Returns:
        the simple operation indicator

      • isConstructor

        public boolean isConstructor()
        Returns:
        the constructor operation indicator

      • isSelfConstructor

        public boolean isSelfConstructor()
        Returns:
        the self-constructor operation indicator

      • getOperationLogging

        public OperationLogging getOperationLogging()
        Returns:
        the operation logging mode

      • isOperationActivityDiagramGenEnabled

        public boolean isOperationActivityDiagramGenEnabled()
        Returns:
        the operation activity diagram generation indicator

      • getDefaultConfirmationMessage

        public String getDefaultConfirmationMessage()
        Returns:
        the default confirmation message

      • setDefaultConfirmationMessage

        public void setDefaultConfirmationMessage​(String message)
        El método setDefaultConfirmationMessage se utiliza para establecer el mensaje de confirmación de la operación que se almacena en el archivo de recursos por defecto. En caso de que el archivo de recursos para el idioma seleccionado por el usuario no esté disponible, la interfaz de la aplicación utiliza el archivo de recursos por defecto para obtener el mensaje.
        Parameters:
        message - mensaje que se muestra en el diálogo de confirmación

      • getLocalizedConfirmationMessage

        public String getLocalizedConfirmationMessage​(Locale locale)
        Parameters:
        locale - the locale for the confirmation message
        Returns:
        the localized confirmation message

      • setLocalizedConfirmationMessage

        public void setLocalizedConfirmationMessage​(Locale locale,
                                            String message)
        El método setLocalizedConfirmationMessage se utiliza para establecer el mensaje de confirmación de la operación que se almacena en el archivo de recursos de configuración regional. En caso de que el archivo de recursos para el idioma seleccionado por el usuario no esté disponible, la interfaz de la aplicación utiliza el archivo de recursos por defecto para obtener el mensaje.
        Parameters:
        locale - configuración regional
        message - mensaje que se muestra en el diálogo de confirmación

      • isLocalizedConfirmationMessageDefined

        public boolean isLocalizedConfirmationMessageDefined()

      • addAllocationStrings

        protected void addAllocationStrings()

      • addAllocationStrings

        protected void addAllocationStrings​(String... strings)
        El método addAllocationStrings de la meta-operación se utiliza para establecer sus cadenas de asignación (allocation strings). Las cadenas de asignación permiten especificar meta-entidades referenciadas por expresiones de la meta-operación, y que, por lo tanto, deben ser construidas (instanciadas) al generar la aplicación.
        Parameters:
        strings - una o más cadenas de asignación (allocation strings). Cada cadena de asignación es una lista de referencias (meta-parámetros que hacen referencia a otras meta-entidades) separadas por puntos (siguiendo la notación de puntos de Java), comenzando por uno de los meta parámetros definidos en la meta-operación.

      • settleAttributes

        protected void settleAttributes()

      • settleParameters

        protected void settleParameters()

      • settleExpressions

        protected void settleExpressions()

      • settleFilters

        protected void settleFilters()

      • finalise

        public boolean finalise()
        Description copied from interface: Artifact
        dot the i's and cross the t's
        Specified by:
        finalise in interface Artifact
        Overrides:
        finalise in class AbstractArtifact
        Returns:
        true if this artifact was successfully finalised; otherwise false

      • signature

        public String signature()