All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.babyfish.lang.Arguments_zh_CN.properties Maven / Gradle / Ivy

The newest version!
# Please see the native2ascii maven plugin in the pom.xml of babyfish-parent.
mustBeNullMessage                                  = 参数或表达式{0}必须为null
mustNotBeNullMessage                               = 参数或表达式{0}不能为null
mustNotBeEmptyMessage                              = 参数或表达式{0}长度不能为0
mustNotContainNullElementsMessage                  = 参数或表达式{0}不能包含null元素
mustNotContainEmptyElementsMessage                 = 参数或表达式{0}不能包含长度为0的元素
mustNotContainSpecialElementsMessage               = 参数或表达式{0}不能包含类型为{1}的元素
mustNotContainNullKeysMessage                      = 参数或表达式{0}不能包含null键
mustNotContainEmptyKeysMessage                     = 参数或表达式{0}不能包含长度为0的键
mustNotContainSpecialKeysMessage                   = 参数或表达式{0}不能包含类型为{1}的键
mustNotContainNullValuesMessage                    = 参数或表达式{0}不能包含null值
mustNotContainEmptyValuesMessage                   = 参数或表达式{0}不能包含长度为0的值
mustNotContainSpecialValuesMessage                 = 参数或表达式{0}不能包含类型为{1}的值
mustBeClassMessage                                 = 参数或表达式{0}必须是类类型
mustNotBeClassMessage                              = 参数或表达式{0}不能是类类型
mustBeInterfaceMessage                             = 参数或表达式{0}必须是接口类型
mustNotBeInterfaceMessage                          = 参数或表达式{0}不能是接口类型
mustBeEnumMessage                                  = 参数或表达式{0}必须是枚举类型
mustNotBeEnumMessage                               = 参数或表达式{0}不能是枚举类型
mustBeAnnotationMessage                            = 参数或表达式{0}必须是注解类型
mustNotBeAnnotationMessage                         = 参数或表达式{0}不能是注解类型
mustBeArrayMessage                                 = 参数或表达式{0}必须是数组类型
mustNotBeArrayMessage                              = 参数或表达式{0}不能是数组类型
mustBePrimitiveMessage                             = 参数或表达式{0}必须是基本类型
mustNotBePrimitiveMessage                          = 参数或表达式{0}不能是基本类型
mustBeAbstractMessage                              = 参数或表达式{0}必须是抽象类型
mustNotBeAbstractMessage                           = 参数或表达式{0}不能是抽象类型
mustBeFinalMessage                                 = 参数或表达式{0}必须是最终类型
mustNotBeFinalMessage                              = 参数或表达式{0}不能是最终类型
mustBeEqualToValueMessage                          = 参数或表达式{0}必须等于值{1}
mustNotBeEqualToValueMessage                       = 参数或表达式{0}不能等于值{1}
mustBeGreaterThanValueMessage                      = 参数或表达式{0}必须大于值{1}
mustBeGreaterThanOrEqualToValueMessage             = 参数或表达式{0}必须大于或等于值{1}
mustBeLessThanValueMessage                         = 参数或表达式{0}必须小于值{1}
mustBeLessThanOrEqualToValueMessage                = 参数或表达式{0}必须小于或等于值{1}
mustBetweenValueMessage                            = 参数或表达式{0}必须{1}值{2}且{3}值{4}
mustBeInstanceOfValueMessage                       = 参数或表达式{0}所指对象类型必须兼容{1}类型
mustBeInstanceOfAllOfValueMessage                  = 参数或表达式{0}所指对象类型必须兼容{1}中所有类型
mustBeInstanceOfAnyOfValueMessage                  = 参数或表达式{0}所指对象类型必须兼容{1}中任意一个类型
mustNotBeInstanceOfValueMessage                    = 参数或表达式{0}所指对象类型不能兼容{1}类型
mustNotBeInstanceOfAnyOfValueMessage               = 参数或表达式{0}所指对象类型不能兼容{1}中任意类型
mustBeCompatibleWithValueMessage                   = 表示类型的参数或表达式{0}必须兼容{1}类型
mustBeCompatibleWithAllOfValueMessage              = 表示类型的参数或表达式{0}必须兼容{1}中所有类型
mustBeCompatibleWithAnyOfValueMessage              = 表示类型的参数或表达式{0}必须兼容{1}任意类型
mustNotBeCompatibleWithValueMessage                = 表示类型的参数或表达式{0}不能兼容{1}类型
mustNotBeCompatibleWithAnyOfValueMessage           = 表示类型的参数或表达式{0}不能兼容{1}中任意类型
mustBeAnyOfValueMessage                            = 参数或表达式{0}必须是{1}中任意一个值
mustNotBeAnyOfValueMessage                         = 参数或表达式{0}不能是{1}中任意一个值
mustBeEqualToOtherMessage                          = 参数或表达式{0}必须等于参数或表达式{1}
mustNotBeEqualToOtherMessage                       = 参数或表达式{0}不能等于参数或表达式{1}
mustBeGreaterThanOtherMessage                      = 参数或表达式{0}必须大于参数{1}
mustBeGreaterThanOrEqualToOtherMessage             = 参数或表达式{0}必须大于或等于参数或表达式{1}
mustBeLessThanOtherMessage                         = 参数或表达式{0}必须小于另外一个参数或表达式{1}
mustBeLessThanOrEqualToOtherMessage                = 参数或表达式{0}必须小于或等于参数或表达式{1}
mustBetweenOtherMessage                            = 参数或表达式{0}必须{1}参数或表达式{2}且{3}参数或表达式{4}
mustBeInstanceOfOtherMessage                       = 参数或表达式{0}所指对象的类型必须兼容参数或表达式{1}
mustBeInstanceOfAllOfOtherMessage                  = 参数或表达式{0}所指对象的类型必须兼容参数或表达式{1}中所有类型
mustBeInstanceOfAnyOfOtherMessage                  = 参数或表达式{0}所指对象的类型必须兼容参数或表达式{1}中任意一个类型
mustNotBeInstanceOfOtherMessage                    = 参数或表达式{0}所指对象的类型不能兼容参数或表达式{1}
mustNotBeInstanceOfAnyOfOtherMessage               = 参数或表达式{0}所指对象的类型不能兼容参数或表达式{1}中所有类型
mustBeCompatibleWithOtherMessage                   = 表示类型的参数或表达式{0}必须兼容参数或表达式{1}
mustBeCompatibleWithAllOfOtherMessage              = 表示类型的参数或表达式{0}必须兼容参数或表达式{1}中所有类型
mustBeCompatibleWithAnyOfOtherMessage              = 表示类型的参数或表达式{0}必须兼容参数或表达式{1}中任意一个类型
mustNotBeCompatibleWithOtherMessage                = 表示类型的参数或表达式{0}不能兼容参数或表达式{1}
mustNotBeCompatibleWithAnyOfOtherMessage           = 表示类型的参数或表达式{0}不能兼容参数或表达式{1}中任意类型
mustBeAnyOfOtherMessage                            = 参数或表达式{0}必须是参数或表达式{1}中任意一个值
mustNotBeAnyOfOtherMessage                         = 参数或表达式{0}不能是参数或表达式{1}中任意一个值
mustBeNullWhenMessage                              = {0},参数或表达式{1}必须为null
mustNotBeNullWhenMessage                           = {0},参数或表达式{1}不能为null
mustBeEmptyWhenMessage                             = {0},参数或表达式{1}长度必须为0
mustNotBeEmptyWhenMessage                          = {0},参数或表达式{1}长度不能为0
mustNotContainNullElementsWhenMessage              = {0},参数或表达式{1}不能包含null元素
mustNotContainEmptyElementsWhenMessage             = {0},参数或表达式{1}不能包含长度为0的元素
mustNotContainSpecialElementsWhenMessage           = {0},参数或表达式{1}不能包含类型为{2}的元素
mustNotContainNullKeysWhenMessage                  = {0},参数或表达式{1}不能包含null键
mustNotContainEmptyKeysWhenMessage                 = {0},参数或表达式{1}不能包含长度为0的键
mustNotContainSpecialKeysWhenMessage               = {0},参数或表达式{1}不能包含类型为{2}的键
mustNotContainNullValuesWhenMessage                = {0},参数或表达式{1}不能包含null值
mustNotContainEmptyValuesWhenMessage               = {0},参数或表达式{1}不能包含长度为0的值
mustNotContainSpecialValuesWhenMessage             = {0},参数或表达式{1}不能包含类型为{2}的值
mustBeClassWhenMessage                             = {0},参数或表达式{1}必须是类类型
mustNotBeClassWhenMessage                          = {0},参数或表达式{1}不能是类类型
mustBeInterfaceWhenMessage                         = {0},参数或表达式{1}必须是接口类型
mustNotBeInterfaceWhenMessage                      = {0},参数或表达式{1}不能是接口类型
mustBeEnumWhenMessage                              = {0},参数或表达式{1}必须是枚举类型
mustNotBeEnumWhenMessage                           = {0},参数或表达式{1}不能是枚举类型
mustBeAnnotationWhenMessage                        = {0},参数或表达式{1}必须是注解类型
mustNotBeAnnotationWhenMessage                     = {0},参数或表达式{1}不能是注解类型
mustBeArrayWhenMessage                             = {0},参数或表达式{1}必须是数组类型
mustNotBeArrayWhenMessage                          = {0},参数或表达式{1}不能是数组类型
mustBePrimitiveWhenMessage                         = {0},参数或表达式{1}必须是基本类型
mustNotBePrimitiveWhenMessage                      = {0},参数或表达式{1}不能是基本类型
mustBeAbstractWhenMessage                          = {0},参数或表达式{1}必须是抽象类型
mustNotBeAbstractWhenMessage                       = {0},参数或表达式{1}不能是抽象类型
mustBeFinalWhenMessage                             = {0},参数或表达式{1}必须是最终类型
mustNotBeFinalWhenMessage                          = {0},参数或表达式{1}不能是最终类型
mustNotBeEqualToValueWhenMessage                   = {0},参数或表达式{1}不能等于值{2}
mustBeGreaterThanValueWhenMessage                  = {0},参数或表达式{1}必须大于值{2}
mustBeGreaterThanOrEqualToValueWhenMessage         = {0},参数或表达式{1}必须大于或等于值{2}
mustBeLessThanValueWhenMessage                     = {0},参数或表达式{1}必须小于值{2}
mustBeLessThanOrEqualToValueWhenMessage            = {0},参数或表达式{1}必须小于或等于值{2}
mustBetweenValueWhenMessage                        = {0},参数或表达式{1}必须{2}值{3}且{4}值{5}
mustBeInstanceOfValueWhenMessage                   = {0},参数或表达式{1}所指对象类型必须兼容{2}类型
mustBeInstanceOfAllOfValueWhenMessage              = {0},参数或表达式{1}所指对象类型必须兼容{2}中所有类型
mustBeInstanceOfAnyOfValueWhenMessage              = {0},参数或表达式{1}所指对象类型必须兼容{2}中任意一个类型
mustNotBeInstanceOfValueWhenMessage                = {0},参数或表达式{1}所指对象类型不能兼容{2}类型
mustNotBeInstanceOfAnyOfValueWhenMessage           = {0},参数或表达式{1}所指对象类型不能兼容{2}中任意类型
mustBeCompatibleWithValueWhenMessage               = {0},表示类型的参数或表达式{1}必须兼容{2}类型
mustBeCompatibleWithAllOfValueWhenMessage          = {0},表示类型的参数或表达式{1}必须兼容{2}中所有类型
mustBeCompatibleWithAnyOfValueWhenMessage          = {0},表示类型的参数或表达式{1}必须兼容{2}任意类型
mustNotBeCompatibleWithValueWhenMessage            = {0},表示类型的参数或表达式{1}不能兼容{2}类型
mustNotBeCompatibleWithAnyOfValueWhenMessage       = {0},表示类型的参数或表达式{1}不能兼容{2}中任意类型
mustBeAnyOfValueWhenMessage                        = {0},参数或表达式{1}必须是{2}中任意一个值
mustNotBeAnyOfValueWhenMessage                     = {0},参数或表达式{1}不能是{2}中任意一个值
mustBeEqualToOtherWhenMessage                      = {0},参数或表达式{1}必须等于参数或表达式{2}
mustNotBeEqualToOtherWhenMessage                   = {0},参数或表达式{1}不能等于参数或表达式{2}
mustBeGreaterThanOtherWhenMessage                  = {0},参数或表达式{1}必须大于参数{2}
mustBeGreaterThanOrEqualToOtherWhenMessage         = {0},参数或表达式{1}必须大于或等于参数或表达式{2}
mustBeLessThanOtherWhenMessage                     = {0},参数或表达式{1}必须小于另外一个参数或表达式{2}
mustBeLessThanOrEqualToOtherWhenMessage            = {0},参数或表达式{1}必须小于或等于参数或表达式{2}
mustBetweenOtherWhenMessage                        = {0},参数或表达式{1}必须{2}参数或表达式{3}且{4}参数或表达式{5}
mustBeInstanceOfOtherWhenMessage                   = {0},参数或表达式{1}所指对象的类型必须兼容参数或表达式{2}
mustBeInstanceOfAllOfOtherWhenMessage              = {0},参数或表达式{1}所指对象的类型必须兼容参数或表达式{2}中所有类型
mustBeInstanceOfAnyOfOtherWhenMessage              = {0},参数或表达式{1}所指对象的类型必须兼容参数或表达式{2}中任意一个类型
mustNotBeInstanceOfOtherWhenMessage                = {0},参数或表达式{1}所指对象的类型不能兼容参数或表达式{2}
mustNotBeInstanceOfAnyOfOtherWhenMessage           = {0},参数或表达式{1}所指对象的类型不能兼容参数或表达式{2}中所有类型
mustBeCompatibleWithOtherWhenMessage               = {0},表示类型的参数或表达式{1}必须兼容参数或表达式{2}
mustBeCompatibleWithAllOfOtherWhenMessage          = {0},表示类型的参数或表达式{1}必须兼容参数或表达式{2}中所有类型
mustBeCompatibleWithAnyOfOtherWhenMessage          = {0},表示类型的参数或表达式{1}必须兼容参数或表达式{2}中任意一个类型
mustNotBeCompatibleWithOtherWhenMessage            = {0},表示类型的参数或表达式{1}不能兼容参数或表达式{2}
mustNotBeCompatibleWithAnyOfOtherWhenMessage       = {0},表示类型的参数或表达式{1}不能兼容参数或表达式{2}中任意类型
mustBeAnyOfOtherWhenMessage                        = {0},参数或表达式{1}必须是参数或表达式{2}中任意一个值
mustNotBeAnyOfOtherWhenMessage                     = {0},参数或表达式{1}不能是参数或表达式{2}中任意一个值




© 2015 - 2025 Weber Informatics LLC | Privacy Policy