Assert.java
/*
** Module : Assert.java
** Abstract : Implementation of the OpenEdge.Core.Assert builtin class.
**
** Copyright (c) 2019-2023, Golden Code Development Corporation.
**
** -#- -I- --Date-- -------------------------------Description--------------------------------
** 001 CA 20190423 Created the first version, by converting the legacy skeleton .cls file and
** using that output.
** 002 CA 20190508 Fixed the converted package.
** 002 CA 20190710 Added LegacyResource annotation. Implemented Equals, NotEquals, IsFalse,
** IsTrue.
** 003 IAS 20190923 Added implementation of additional methods
** 004 CA 20191024 Added method support levels and updated the class support level.
** 005 ME 20201023 Added implementation for isType, notType.
** ME 20210916 Delegate to AssertObject as needed.
** ME 20210930 Remove use of Apache StringUtils.
** 006 VVT 20230318 The file re-designed completely, API is compatible with the latest
** OE releases. Javadocs added. All methods are now fully implemented.
** See #3827.
** 007 VVT 20230504 Assert:NonZero support added. See #3827-399.
** 008 CA 20231113 The 'execute' method must be annotated with LegacySignature Type.Execute, and also can be
** dropped if is a no-op.
*/
/*
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU Affero General Public License as
** published by the Free Software Foundation, either version 3 of the
** License, or (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU Affero General Public License for more details.
**
** You may find a copy of the GNU Affero GPL version 3 at the following
** location: https://www.gnu.org/licenses/agpl-3.0.en.html
**
** Additional terms under GNU Affero GPL version 3 section 7:
**
** Under Section 7 of the GNU Affero GPL version 3, the following additional
** terms apply to the works covered under the License. These additional terms
** are non-permissive additional terms allowed under Section 7 of the GNU
** Affero GPL version 3 and may not be removed by you.
**
** 0. Attribution Requirement.
**
** You must preserve all legal notices or author attributions in the covered
** work or Appropriate Legal Notices displayed by works containing the covered
** work. You may not remove from the covered work any author or developer
** credit already included within the covered work.
**
** 1. No License To Use Trademarks.
**
** This license does not grant any license or rights to use the trademarks
** Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
** of Golden Code Development Corporation. You are not authorized to use the
** name Golden Code, FWD, or the names of any author or contributor, for
** publicity purposes without written authorization.
**
** 2. No Misrepresentation of Affiliation.
**
** You may not represent yourself as Golden Code Development Corporation or FWD.
**
** You may not represent yourself for publicity purposes as associated with
** Golden Code Development Corporation, FWD, or any author or contributor to
** the covered work, without written authorization.
**
** 3. No Misrepresentation of Source or Origin.
**
** You may not represent the covered work as solely your work. All modified
** versions of the covered work must be marked in a reasonable way to make it
** clear that the modified work is not originating from Golden Code Development
** Corporation or FWD. All modified versions must contain the notices of
** attribution required in this license.
*/
package com.goldencode.p2j.oo.core;
import static com.goldencode.p2j.report.ReportConstants.*;
import static com.goldencode.p2j.util.BlockManager.*;
import static com.goldencode.p2j.util.ErrorManager.silent;
import static com.goldencode.p2j.util.TextOps.substitute;
import com.goldencode.p2j.oo.core.assertion.*;
import com.goldencode.p2j.oo.lang.*;
import com.goldencode.p2j.util.*;
import com.goldencode.p2j.util.InternalEntry.*;
import com.goldencode.util.*;
/**
* Business logic (initially converted to Java from the 4GL source code in
* OpenEdge/Core/Assert.cls).
*/
@LegacyResource(resource = "OpenEdge.Core.Assert")
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_PARTIAL)
public class Assert
extends AbstractAssert
{
/**
* The static constructor
*/
@LegacySignature(type = Type.CONSTRUCTOR)
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void __core_Assert_constructor__static__()
{
externalProcedure(Assert.class, new Block((Body) () -> {
onBlockLevel(Condition.ERROR, Action.THROW);
}));
}
/**
* Check that the buffer argument is available
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsAvailable", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isAvailable(final handle argument)
{
isAvailableImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the buffer argument is available
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsAvailable", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isAvailable(final handle argument, final character name)
{
isAvailableImpl(argument, name.toStringMessage());
}
/**
* Check that the character argument can be parsed to a decimal value
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsDecimal", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isDecimal(final character argument)
{
isDecimalImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the character argument can be parsed to a decimal value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsDecimal", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isDecimal(final character argument, final character name)
{
isDecimalImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final character argument)
{
isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final character argument, final character name)
{
isEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final handle argument)
{
isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final handle argument, final character name)
{
isEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final longchar argument)
{
isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final longchar argument, final character name)
{
isEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final memptr argument)
{
isEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsEmpty", parameters = {
@LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isEmpty(final memptr argument, final character name)
{
isEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the logical argument is false
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsFalse", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isFalse(final logical argument)
{
// Notice: failure message is created differently!
call("IsFalse", () -> {
if (argument.isUnknown() || argument.booleanValue())
{
raiseError("Expected: FALSE but was: &1", argument);
}
});
}
/**
* Check that the logical argument is false
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsFalse", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isFalse(final logical argument, final character name)
{
call("IsFalse", () -> {
if (argument.isUnknown() || argument.booleanValue())
{
raiseError("&1 is not false", name);
}
});
}
/**
* Check that a character value is in the list
*
* @param argument
* The argument to check
* @param list
* The list to look up
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsIn", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isIn(final character argument, final longchar list, final character name)
{
isInImpl(argument, list, new character(","), name);
}
/**
* Check that a character value is in the list
*
* @param argument
* The argument to check
* @param list
* The list to look up
* @param delimiter
* List delimiter
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsIn", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "delimiter", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isIn(final character argument, final longchar list,
final character delimiter, final character name)
{
isInImpl(argument, list, delimiter, name);
}
/**
* Check that the character argument can be parsed to an int64 value
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsInt64", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isInt64(final character argument)
{
isInt64Impl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the character argument can be parsed to an int64 value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsInt64", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isInt64(final character argument, final character name)
{
isInt64Impl(argument, name.toStringMessage());
}
/**
* Check that the character argument can be parsed to an integer value
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsInteger", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isInteger(final character argument)
{
isIntegerImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the character argument can be parsed to an integer value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsInteger", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isInteger(final character argument, final character name)
{
isIntegerImpl(argument, name.toStringMessage());
}
/**
* Check that the character argument can be parsed to a logical value
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsLogical", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isLogical(final character argument)
{
isLogicalImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the character argument can be parsed to a logical value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsLogical", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isLogical(final character argument, final character name)
{
isLogicalImpl(argument, name.toStringMessage());
}
/**
* Asserts value can be parsed to a logical value with mask
*
* @param argument
* The argument to check
* @param mask
* The mask
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsLogical", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "mask", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isLogical(final character argument, final character mask,
final character name)
{
isLogicalImpl(argument, mask, name.toStringMessage());
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNegative(final decimal argument)
{
isNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNegative(final decimal argument, final character name)
{
isNegativeImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNegative(final int64 argument)
{
isNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNegative(final int64 argument, final character name)
{
isNegativeImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNegative(final integer argument)
{
isNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNegative", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNegative(final integer argument, final character name)
{
isNegativeImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final character argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final character argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final character[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final character[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final date argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final date argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final date[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final date[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetime argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetime argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetime[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetime[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetimetz argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetimetz argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetimetz[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final datetimetz[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final decimal argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final decimal argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final decimal[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final decimal[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final handle argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final handle argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final handle[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final handle[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final int64 argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final int64 argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final int64[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final int64[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final integer argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final integer argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final integer[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final integer[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final logical argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final logical argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final logical[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final logical[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final longchar argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final longchar argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final longchar[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final longchar[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final raw argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final raw argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final raw[] argument)
{
isNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isNull(final raw[] argument, final character name)
{
isNullImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isPositive(final decimal argument)
{
isPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isPositive(final decimal argument, final character name)
{
isPositiveImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isPositive(final int64 argument)
{
isPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isPositive(final int64 argument, final character name)
{
isPositiveImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isPositive(final integer argument)
{
isPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsPositive", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isPositive(final integer argument, final character name)
{
isPositiveImpl(argument, name.toStringMessage());
}
/**
* Check that the logical argument is true
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsTrue", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isTrue(final logical argument)
{
call("IsTrue", () -> {
if (argument.isUnknown() || !argument.booleanValue())
{
raiseError("Expected: TRUE but was: &1", argument);
}
});
}
/**
* Check that the logical argument is true
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsTrue", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isTrue(final logical argument, final character name)
{
call("IsTrue", () -> {
if (argument.isUnknown() || !argument.booleanValue())
{
raiseError("&1 is not true", name.toStringMessage());
}
});
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final character argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final character argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final character[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final character[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final date argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final date argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final date[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final date[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetime argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetime argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetime[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetime[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetimetz argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetimetz argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetimetz[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final datetimetz[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final decimal argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final decimal argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final decimal[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final decimal[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final handle argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final handle argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final handle[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final handle[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final int64 argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final int64 argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final int64[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final int64[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final integer argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final integer argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final integer[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final integer[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final logical argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final logical argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final logical[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final logical[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final longchar argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final longchar argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final longchar[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final longchar[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final raw argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final raw argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final raw[] argument)
{
isUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isUnknown_(final raw[] argument, final character name)
{
isUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZero(final decimal argument)
{
isZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZero(final decimal argument, final character name)
{
isZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZero(final int64 argument)
{
isZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZero(final int64 argument, final character name)
{
isZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZero(final integer argument)
{
isZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZero(final integer argument, final character name)
{
isZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrNegative(final decimal argument)
{
isZeroOrNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrNegative(final decimal argument, final character name)
{
isZeroOrNegativeImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrNegative(final int64 argument)
{
isZeroOrNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrNegative(final int64 argument, final character name)
{
isZeroOrNegativeImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrNegative(final integer argument)
{
isZeroOrNegativeImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrNegative", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrNegative(final integer argument, final character name)
{
isZeroOrNegativeImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrPositive(final decimal argument)
{
isZeroOrPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrPositive(final decimal argument, final character name)
{
isZeroOrPositiveImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrPositive(final int64 argument)
{
isZeroOrPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrPositive(final int64 argument, final character name)
{
isZeroOrPositiveImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrPositive(final integer argument)
{
isZeroOrPositiveImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "IsZeroOrPositive", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void isZeroOrPositive(final integer argument, final character name)
{
isZeroOrPositiveImpl(argument, name.toStringMessage());
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final character expected, final character actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "DATE", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DATE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final date expected, final date actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "DATETIME", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final datetime expected, final datetime actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "DATETIMETZ", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final datetimetz expected, final datetimetz actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final decimal expected, final decimal actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final handle expected, final handle actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final int64 expected, final int64 actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final integer expected, final integer actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final logical expected, final logical actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final longchar expected, final longchar actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "MEMPTR", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final memptr expected, final memptr actual)
{
equalsImpl(expected.length(), actual.length());
call("Equals", () -> {
if (!SecurityOps.messageDigest("SHA-256", expected)
.equals(SecurityOps.messageDigest("SHA-256", actual)))
{
raiseError("Hashes of memptr values are not equal");
}
});
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "RAW", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "RAW", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final raw expected, final raw actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "RECID", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "RECID", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final recid expected, final recid actual)
{
equalsImpl(expected, actual);
}
/**
* Check that two arguments are equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "Equals", parameters = {
@LegacyParameter(name = "expected", type = "ROWID", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void legacyEquals(final rowid expected, final rowid actual)
{
equalsImpl(expected, actual);
}
/**
* Check that the buffer argument is not available
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotAvailable", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notAvailable(final handle argument)
{
notAvailableImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the buffer argument is not available
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotAvailable", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notAvailable(final handle argument, final character name)
{
notAvailableImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final character argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final character argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final character[] argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final character[] argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final handle argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final handle argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final handle[] argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final handle[] argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final longchar argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final longchar argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final longchar[] argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final longchar[] argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final memptr argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "MEMPTR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final memptr argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "MEMPTR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final memptr[] argument)
{
notEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotEmpty", parameters = {
@LegacyParameter(name = "argument", type = "MEMPTR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEmpty(final memptr[] argument, final character name)
{
notEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final character expected, final character actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "DATE", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DATE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final date expected, final date actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "DATETIME", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DATETIME", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final datetime expected, final datetime actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "DATETIMETZ", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DATETIMETZ", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final datetimetz expected, final datetimetz actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final decimal expected, final decimal actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final handle expected, final handle actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final int64 expected, final int64 actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final integer expected, final integer actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final logical expected, final logical actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final longchar expected, final longchar actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "MEMPTR", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "MEMPTR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final memptr expected, final memptr actual)
{
// FIXME probably needs special treatment.
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "RAW", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "RAW", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final raw expected, final raw actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "RECID", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "RECID", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final recid expected, final recid actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
@LegacySignature(type = Type.METHOD, name = "NotEqual", parameters = {
@LegacyParameter(name = "expected", type = "ROWID", mode = "INPUT"),
@LegacyParameter(name = "actual", type = "ROWID", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notEqual(final rowid expected, final rowid actual)
{
notEqualImpl(expected, actual);
}
/**
* Check that the logical argument is not false (is true or unknown)
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotFalse", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notFalse(final logical argument)
{
notFalseImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the logical argument is not false (is true or unknown)
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotFalse", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notFalse(final logical argument, final character name)
{
notFalseImpl(argument, name.toStringMessage());
}
/**
* Check that a character value is not in the list
*
* @param argument
* The argument to check
* @param list
* The list to look up
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotIn", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notIn(final character argument, final longchar list, final character name)
{
notInImpl(argument, list, new character(","), name);
}
/**
* Check that a character value is not in the list
*
* @param argument
* The argument to check
* @param list
* The list to look up
* @param delimiter
* List delimiter
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotIn", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "list", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "delimiter", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notIn(final character argument, final longchar list,
final character delimiter, final character name)
{
notInImpl(argument, list, delimiter, name);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final character argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final character argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final character[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final character[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final date argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final date argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final date[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final date[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetime argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetime argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetime[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetime[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetimetz argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetimetz argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetimetz[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final datetimetz[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final decimal argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final decimal argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final decimal[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final decimal[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final handle argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final handle argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final handle[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final handle[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final int64 argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final int64 argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final int64[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final int64[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final integer argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final integer argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final integer[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final integer[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final logical argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final logical argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final logical[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final logical[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final longchar argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final longchar argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final longchar[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final longchar[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final raw argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final raw argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final raw[] argument)
{
notNullImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNull", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNull(final raw[] argument, final character name)
{
notNullImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final character argument)
{
notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final character argument, final character name)
{
notNullOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final character[] argument)
{
notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final character[] argument, final character name)
{
notNullOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final longchar argument)
{
notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final longchar argument, final character name)
{
notNullOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final longchar[] argument)
{
notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmpty(final longchar[] argument, final character name)
{
notNullOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "OBJECT", qualified = "openedge.core.collections.icollection", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyCollection(
final object<? extends com.goldencode.p2j.oo.core.collections.Icollection> argument)
{
notNullOrEmptyCollection(argument, new character(DEFAULT_ARGUMENT_NAME));
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "openedge.core.collections.icollection", type = "OBJECT", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyCollection(
final object<? extends com.goldencode.p2j.oo.core.collections.Icollection> argument,
final character name)
{
AssertObject.notNullOrEmptyCollection(argument, name);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "openedge.core.collections.imap", type = "OBJECT", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyMap(
final object<? extends com.goldencode.p2j.oo.core.collections.Imap> argument)
{
notNullOrEmptyMap(argument, new character(DEFAULT_ARGUMENT_NAME));
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "openedge.core.collections.imap", type = "OBJECT", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyMap(
final object<? extends com.goldencode.p2j.oo.core.collections.Imap> argument,
final character name)
{
AssertObject.notNullOrEmptyMap(argument, name);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyObject(final object<? extends _BaseObject_> argument)
{
notNullOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyObject(final object<? extends _BaseObject_> argument,
final character name)
{
notNullOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "OBJECT", extent = -1, qualified = "progress.lang.object", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyObjectArray(final object<? extends _BaseObject_>[] argument)
{
notNullOrEmptyObjectArray(argument, new character(DEFAULT_ARGUMENT_NAME));
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "OBJECT", extent = -1, qualified = "progress.lang.object", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrEmptyObjectArray(final object<? extends _BaseObject_>[] argument,
final character name)
{
call("NotNullOrEmpty", () -> {
AssertObject.notNullOrEmptyObjectArray(argument, name);
});
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrZero(final decimal argument)
{
notNullOrZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrZero(final decimal argument, final character name)
{
notNullOrZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrZero(final int64 argument)
{
notNullOrZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrZero(final int64 argument, final character name)
{
notNullOrZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrZero(final integer argument)
{
notNullOrZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotNullOrZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notNullOrZero(final integer argument, final character name)
{
notNullOrZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the logical argument is not true (is false or unknown)
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotTrue", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notTrue(final logical argument)
{
notTrueImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the logical argument is not true (is false or unknown)
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotTrue", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notTrue(final logical argument, final character name)
{
notTrueImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final character argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final character argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final character[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final character[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final date argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final date argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final date[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final date[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetime argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetime argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetime[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIME", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetime[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetimetz argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetimetz argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetimetz[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DATETIMETZ", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final datetimetz[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final decimal argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final decimal argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final decimal[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final decimal[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final handle argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final handle argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final handle[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "HANDLE", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final handle[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final int64 argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final int64 argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final int64[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INT64", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final int64[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final integer argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final integer argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final integer[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final integer[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final logical argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final logical argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final logical[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LOGICAL", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final logical[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final longchar argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final longchar argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final longchar[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final longchar[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final raw argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final raw argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final raw[] argument)
{
notUnknownImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is not unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknown", parameters = {
@LegacyParameter(name = "argument", type = "RAW", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknown(final raw[] argument, final character name)
{
notUnknownImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final character argument)
{
notUnknownOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final character argument, final character name)
{
notUnknownOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final character[] argument)
{
notUnknownOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "CHARACTER", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final character[] argument, final character name)
{
notUnknownOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final longchar argument)
{
notUnknownOrEmptyImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", type = "LONGCHAR", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final longchar argument, final character name)
{
notUnknownOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", extent = -1, mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmpty(final object<? extends _BaseObject_>[] argument,
final character name)
{
notUnknownOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotUnknownOrEmpty", parameters = {
@LegacyParameter(name = "argument", qualified = "progress.lang.object", type = "OBJECT", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notUnknownOrEmptyObject(final object<? extends _BaseObject_> argument,
final character name)
{
notNullUnknownOrEmptyImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notZero(final decimal argument)
{
notZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notZero(final decimal argument, final character name)
{
notZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notZero(final int64 argument)
{
notZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notZero(final int64 argument, final character name)
{
notZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notZero(final integer argument)
{
notZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NotZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void notZero(final integer argument, final character name)
{
notZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void nonZero(final decimal argument)
{
nonZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
@LegacyParameter(name = "argument", type = "DECIMAL", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void nonZero(final decimal argument, final character name)
{
nonZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void nonZero(final int64 argument)
{
nonZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
@LegacyParameter(name = "argument", type = "INT64", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void nonZero(final int64 argument, final character name)
{
nonZeroImpl(argument, name.toStringMessage());
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
*/
@LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void nonZero(final integer argument)
{
nonZeroImpl(argument, DEFAULT_ARGUMENT_NAME);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
@LegacySignature(type = Type.METHOD, name = "NonZero", parameters = {
@LegacyParameter(name = "argument", type = "INTEGER", mode = "INPUT"),
@LegacyParameter(name = "name", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void nonZero(final integer argument, final character name)
{
nonZeroImpl(argument, name.toStringMessage());
}
/**
* Throw AssertionFailedError with the given message
*
* @param message The failure message
*/
@LegacySignature(type = Type.METHOD, name = "RaiseError", parameters = {
@LegacyParameter(name = "message", type = "CHARACTER", mode = "INPUT") })
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public static void raiseError(final character message)
{
raiseError(message.toStringMessage());
}
/**
* Implementation helper for all test methods in this very class.
*
* @param legacyName
* the legacy name of the method
* @param body
* the method body
*/
private static void call(final String legacyName, final Body body)
{
call(Assert.class, legacyName, body);
}
/**
* Check that the character argument can be parsed to a decimal value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isDecimalImpl(final character argument, final String name)
{
call("IsDecimal", () -> {
silent(() -> new decimal(argument.getValue()));
if (ErrorManager.isError().booleanValue())
{
raiseError("&1 is not a decimal value", name);
}
});
}
/**
* Check that a handle is empty (not available)
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isEmptyImpl(final handle argument, final String name)
{
call("IsEmpty", () -> {
notNullImpl(argument, name);
final handle _h = TypeFactory.initInput(argument);
silent(() -> _h.unwrapBuffer().findFirst());
notAvailableImpl(_h, name);
});
}
/**
* Check that the argument is empty (size is zero)
*
* @param argument
* the value to check
* @param name
* the argument name to use in the failure message
*/
private static void isEmptyImpl(final memptr argument, final String name)
{
call("IsEmpty", () -> {
if (argument.length().intValue() != 0)
{
raiseError("&1 must be empty", name);
}
});
}
/**
* Check that the argument is empty (contains no characters).
*
* @param argument
* the value to check
* @param name
* the argument name to use in the failure message
*/
private static void isEmptyImpl(final Text argument, final String name)
{
notNullImpl(argument, name);
call("IsEmpty", () -> {
if (!argument.getValue().isEmpty())
{
raiseError("&1 must be empty", name);
}
});
}
/**
* Check that a character value is in the list
*
* @param argument
* The argument to check
* @param list
* The list to look up
* @param delimiter
* List delimiter
* @param name
* The name of the argument
*/
private static void isInImpl(final character argument, final longchar list,
final character delimiter, final character name)
{
notEqualImpl(argument, delimiter);
call("IsIn", () -> {
// FIXME: test how OE handles unknown values
// FIXME: use the OE LOOKUP function here
if (!argument.isUnknown() && !list.isUnknown() && !delimiter.isUnknown())
{
final String val = StringHelper.safeTrimTrailingSpaces(argument.getValue());
for (final String entry : TextOps.entries(list.getValue(), delimiter.getValue()))
{
if (CompareOps._isEqual(val, StringHelper.safeTrimTrailingSpaces(entry)))
{
returnNormal();
}
}
}
raiseError("&1 (\"&2\") is not in the list: &3", name, argument, list);
});
}
/**
* Check that the character argument can be parsed to an int64 value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isInt64Impl(final character argument, final String name)
{
call("IsInt64", () -> {
silent(() -> new int64(argument.getValue()));
if (ErrorManager.isError().booleanValue())
{
raiseError("&1 is not an int64 value", name);
}
});
}
/**
* Check that the character argument can be parsed to an integer value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isIntegerImpl(final character argument, final String name)
{
call("IsInteger", () -> {
silent(() -> new integer(argument.getValue()));
if (ErrorManager.isError().booleanValue())
{
raiseError("&1 is not an integer value", name);
}
});
}
/**
* Check that the character argument can be parsed to a logical value
*
* @param argument
* The argument to check
* @param mask
* parse format, e.g. "yes/no", "da/net"
* @param name
* The name of the argument
*/
private static void isLogicalImpl(final character argument, final character mask,
final String name)
{
call("IsLogical", () -> {
if (!argument.isUnknown())
{
silent(() -> new logical(argument, mask));
if (ErrorManager.isError().booleanValue())
{
raiseError("&1 does not evaluate to a logical value with mask &2", name, mask);
}
}
});
}
/**
* Check that the character argument can be parsed to a logical value
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isLogicalImpl(final character argument, final String name)
{
call("IsLogical", () -> {
if (!argument.isUnknown())
{
silent(() -> new logical(argument.getValue()));
if (ErrorManager.isError().booleanValue())
{
raiseError("&1 does not evaluate to a logical value", name);
}
}
});
}
/**
* Check that the numeric argument is strictly negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isNegativeImpl(final NumberType argument, final String name)
{
call("IsNegative", () -> {
notNullImpl(argument, name);
if (argument.doubleValue() >= 0)
{
raiseNonNegative(name);
}
});
}
/**
* Check that the argument is unknown
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isNullImpl(final BaseDataType argument, final String name)
{
call("IsNull", () -> {
if (!argument.isUnknown())
{
raiseNotUnknown(name);
}
});
}
/**
* Check that the numeric argument is strictly positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
public static void isPositiveImpl(final NumberType argument, final String name)
{
notNullImpl(argument, name);
call("IsPositive", () -> {
if (argument.doubleValue() <= 0)
{
raiseNonPositive(name);
}
});
}
/**
* Check that the numeric argument is zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isZeroImpl(final NumberType argument, final String name)
{
call("IsZero", () -> {
if (argument.isUnknown() || argument.doubleValue() != 0)
{
raiseNonZero(name);
}
});
}
/**
* Check that the numeric argument is zero or negative
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void isZeroOrNegativeImpl(final NumberType argument, final String name)
{
call("IsZeroOrNegative", () -> {
notNullImpl(argument, name);
if (argument.doubleValue() > 0)
{
raiseNonZeroOrNegative(name);
}
});
}
/**
* Check that the numeric argument is zero or positive
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
public static void isZeroOrPositiveImpl(final NumberType argument, final String name)
{
call("IsZeroOrPositive", () -> {
notNullImpl(argument, name);
if (argument.doubleValue() < 0)
{
raiseNonZeroOrPositive(name);
}
});
}
/**
* Check that the buffer argument is not available
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notAvailableImpl(final handle argument, final String name)
{
call("NotAvailable", () -> {
if (argument.unwrapAvailable().available().booleanValue())
{
raiseError("record in buffer &1 is available", name);
}
});
}
/**
* Check that the argument is not empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notEmptyImpl(final BaseDataType[] argument, final String name)
{
// FIXME: why should not we test this for memptr?
notUnknownImpl(argument, name);
hasDeterminateExtentImpl(argument, name);
for (int i = 0; i < argument.length; i++)
{
final BaseDataType e = argument[i];
notEmptyImpl(e, substitute("Extent &2 of &1", name, i).toStringMessage());
}
}
/**
* Check that two arguments are not equal
*
* @param expected
* The expected value
* @param actual
* The actual value
*/
private static void notEqualImpl(final BaseDataType expected, final BaseDataType actual)
{
call("NotEqual", () -> {
if (CompareOps._isEqual(expected, actual))
{
raiseErrorForEquals("&1 and &2 are equal", expected, actual);
}
});
}
/**
* Check that the logical argument is not false (is true or unknown)
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notFalseImpl(final logical argument, final String name)
{
call("NotFalse", () -> {
if (!argument.isUnknown() && !argument.booleanValue())
raiseError("&1 is false", name);
});
}
/**
* Check that a character value is not in the list
*
* @param argument
* The argument to check
* @param list
* The list to look up
* @param delimiter
* List delimiter
* @param name
* The name of the argument
*/
private static void notInImpl(Text argument, longchar list, Text delimiter,
final character name)
{
if (list.isUnknown() || StringHelper.safeTrimTrailingSpaces(list.getValue()).isEmpty())
{
returnNormal();
}
call("NotIn", () -> {
notEqualImpl(argument, delimiter);
if (argument.isUnknown() || delimiter.isUnknown())
{
raiseError("&1 (\"&2\") is in the list: &3", name, argument, list);
}
// FIXME use LOOKUP function
final String val = StringHelper.safeTrimTrailingSpaces(argument.getValue());
for (final String entry : TextOps.entries(list.getValue(), delimiter.getValue()))
{
if (CompareOps._isEqual(val, StringHelper.safeTrimTrailingSpaces(entry)))
{
raiseError("&1 (\"&2\") is in the list: &3", name, argument, list);
}
}
});
}
/**
* Check that the argument is not unknown and valid
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notNullImpl(final handle argument, final String name)
{
call("NotNull", () -> {
if (argument == null || argument.isUnknown() || !argument._isValid())
{
raiseUnknown(name);
}
});
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
public static void notNullOrEmptyImpl(final BaseDataType argument, final String name)
{
call("NotNullOrEmpty", () -> {
notNullImpl(argument, name);
notEmptyImpl(argument, name);
});
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notNullOrEmptyImpl(final BaseDataType[] argument, final String name)
{
call("NotNullOrEmpty", () -> {
if (argument.length == 0)
{
raiseUnknown(name);
}
});
}
/**
* Check that the numeric argument is neither unknown nor zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notNullOrZeroImpl(final NumberType argument, final String name)
{
call("NotNullOrZero", () -> {
notNullImpl(argument, name);
notZeroImpl(argument, name);
});
}
/**
* Check that the logical argument is not true (is false or unknown)
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notTrueImpl(final logical argument, final String name)
{
call("NotTrue", () -> {
if (argument.booleanValue())
{
raiseError("&1 is true", name);
}
});
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notUnknownOrEmptyImpl(final BaseDataType[] argument, String name)
{
notUnknownImpl(argument, name);
notEmptyImpl(argument, name);
}
/**
* Check that the argument is neither unknown nor empty
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notUnknownOrEmptyImpl(final Text argument, final String name)
{
notUnknownImpl(argument, name);
notEmptyImpl(argument, name);
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void nonZeroImpl(final NumberType argument, final String name)
{
call("NonZero", () -> {
if (!argument.isUnknown() && argument.doubleValue() == 0)
{
raiseZero(name);
}
});
}
/**
* Check that the numeric argument is not zero
*
* @param argument
* The argument to check
* @param name
* The name of the argument
*/
private static void notZeroImpl(final NumberType argument, final String name)
{
call("NotZero", () -> {
if (!argument.isUnknown() && argument.doubleValue() == 0)
{
raiseZero(name);
}
});
}
/**
* Raise an ERROR condition as the value is not negative.
*
* @param name The name of the value.
*/
private static void raiseNonNegative(final String name)
{
raiseError("&1 must be negative", name);
}
/**
* Raise an ERROR condition as the value is not positive.
*
* @param name The name of the value.
*/
private static void raiseNonPositive(final String name)
{
raiseError("&1 must be positive", name);
}
/**
* Raise an ERROR condition as the value is not zero.
*
* @param name The name of the value.
*/
private static void raiseNonZero(final String name)
{
raiseError("&1 must be zero", name);
}
/**
* Raise an ERROR condition as the value is not zero or negative.
*
* @param name The name of the value.
*/
private static void raiseNonZeroOrNegative(final String name)
{
raiseError("&1 must be zero or negative", name);
}
/**
* Raise an ERROR condition as the value is not zero or positive.
*
* @param name The name of the value.
*/
private static void raiseNonZeroOrPositive(final String name)
{
raiseError("&1 must be zero or positive", name);
}
/**
* Raise an ERROR condition as the value is zero.
*
* @param name The name of the value.
*/
private static void raiseZero(final String name)
{
raiseError("&1 cannot be zero", name);
}
/**
* The "default" constructor.
*/
@LegacySignature(type = Type.CONSTRUCTOR)
@LegacyResourceSupport(supportLvl = CVT_LVL_FULL | RT_LVL_FULL)
public void __core_Assert_constructor__()
{
internalProcedure(this, "__core_Assert_constructor__", new Block((Body) () -> {
__core_AbstractAssert_constructor__();
}));
}
/**
* Initialize this procedure
*/
@LegacySignature(type = Type.EXECUTE)
public void __core_Assert_execute__()
{
onBlockLevel(Condition.ERROR, Action.THROW);
}
}