# doc_class

class_name: kd.bos.algo.CustomAggFunction
simple_name: CustomAggFunction
package_name: kd.bos.algo
title: CustomAggFunction
class_comment:
自定义聚合函数,在对DataSet分组后使用，对分组后的值进行处理得到一个聚合值，譬如sum,min等， 可以自定义一个聚合函数，譬如对分组后的字符串字段进行拼接处理。 参考:GroupbyDataSet.agg


class_name: kd.bos.base.AbstractMobBasePlugIn
simple_name: AbstractMobBasePlugIn
package_name: kd.bos.base
title: AbstractMobBasePlugIn
class_comment:
移动端基础资料视图层插件抽象基类 从移动端单据视图层插件抽象基类派生，共同继承动态表单插件基类 kd.bos.form.plugin.AbstractFormPlugin，实现了移动端插件接口 kd.bos.form.plugin.IMobFormPlugin


class_name: kd.bos.base.BaseShowParameter
simple_name: BaseShowParameter
package_name: kd.bos.base
title: BaseShowParameter
class_comment:
基础资料界面显示参数 插件代码 ` this.getView().showForm(showParameter)` 的参数，用来打开基础资料界面。 从单据界面显示参数类派生，均继承自动态表单界面显示参数类 kd.bos.form.FormShowParameter


class_name: kd.bos.base.IBasedataController
simple_name: IBasedataController
package_name: kd.bos.base
title: IBasedataController
class_comment:
基础资料个性化逻辑控制功能接口 具体的基础资料类型， 可以通过派生实现该接口的抽象类， 定义内置核心过滤条件等; 基础资料实现的类需要绑定到基础资料属性中才能起作用; 如果基础资料不派生， 则采用抽象类本身标准的功能实现;


class_name: kd.bos.base.MobileBaseShowParameter
simple_name: MobileBaseShowParameter
package_name: kd.bos.base
title: MobileBaseShowParameter
class_comment:
移动端基础资料界面显示参数 插件代码` this.getView.showForm(showParameter) ` 的参数，用来打开移动端基础资料界面。 从移动端单据界面显示参数类派生，均继承自动态表单界面显示参数类 kd.bos.form.FormShowParameter


class_name: kd.bos.bill.BillShowParameter
simple_name: BillShowParameter
package_name: kd.bos.bill
title: BillShowParameter
class_comment:
单据界面显示参数 插件代码 ` this.getView().showForm(showParameter)` 的参数，用来打开单据界面。 特别说明：打开单据界面，不能使用` new FormShowParameter()`作为参数，必须使用` new BillShowParameter`作为参数，否则会报实体类型转换异常。


class_name: kd.bos.bill.IMobileBillView
simple_name: IMobileBillView
package_name: kd.bos.bill
title: IMobileBillView
class_comment:
移动端单据运行时视图层控制接口 继承单据、移动端运行时视图层控制接口，增加移动端单据运行时视图层特别的控制方法 移动端单据视图层插件，可以通过` (IMobileBillView)this.getView()` 获取本接口实例


class_name: kd.bos.context.RequestContext
simple_name: RequestContext
package_name: kd.bos.context
title: RequestContext
class_comment:
Request Context，非SessionContext 包括： 请求相关:RequestInfo 会话相关:SessionInfo, UserInfo 追踪线索相关: RequestContext在各个节点/服务间传递，追踪经过的节点/服务，以及性能数据，以实现基于请求的性能跟踪审计 本对象只存活于请求生命周期，请求结束即被回收 在web节点中，requestId可根据HttpServletRequest的id生成


class_name: kd.bos.dataentity.Consumer
simple_name: Consumer
package_name: kd.bos.dataentity
title: Consumer
class_comment:
Represents an operation that accepts a single input argument and returns no result. Unlike most other functional interfaces, ` Consumer` is expected to operate via side-effects.


class_name: kd.bos.dataentity.entity.DbIgnoreAttribute
simple_name: DbIgnoreAttribute
package_name: kd.bos.dataentity.entity
title: DbIgnoreAttribute
class_comment:
标注属性是否不入库,是否在数据库的所有操作中，忽略此属性。 默认的：如果实体的字段不是简单、复杂和集合中的任何一种，都不会参与数据库操作。 但如果有字段需要支持这些结构，但又不希望参与数据库操作，那么可以设置此属性


class_name: kd.bos.dataentity.message.PushMessageRange
simple_name: PushMessageRange
package_name: kd.bos.dataentity.message
title: PushMessageRange
class_comment:
推送消息的范围枚举类（页面，会话，租户，帐套） 应用于以下方法中 PushMessage#setRangePushMessage#getRange()PushMessageBuilder#range(PushMessageRange)


class_name: kd.bos.dataentity.message.PushMessageType
simple_name: PushMessageType
package_name: kd.bos.dataentity.message
title: PushMessageType
class_comment:
推送消息类型枚举类（更新标记、表单指令） 应用于以下方法中 PushMessage#setTypePushMessage#getType()PushMessageBuilder#type(PushMessageType)


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicCollectionProperty
simple_name: DynamicCollectionProperty
package_name: kd.bos.dataentity.metadata.dynamicobject
title: DynamicCollectionProperty
class_comment:
动态实体的集合属性 集合属性指向另外一个实体类型的引用，所不同的是集合属性表达主表与明细表的关系时候使用。 在数据库中，集合属性会保存在明细表中，为一对多的关系。主实体与集合属性的关联主键使用主实体的主键，即要求明细表的外键名字和主表主键名字相同。 如系统中的订单主表及明细表分录即使用集合属性来表示


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicComplexProperty
simple_name: DynamicComplexProperty
package_name: kd.bos.dataentity.metadata.dynamicobject
title: DynamicComplexProperty
class_comment:
动态实体复杂属性 复杂属性指向另外一个实体类型的引用，以一个字段保存一个整体段信息。 如系统中常用的中繁英文三个字段则可整体定义为复杂属性，整个系统可共用这个类型。 注意的是数据库中复杂属性字段与主字段在同一个表中，对于保存到另一表中的情况，使用引用属性ReferenceAttribute.


class_name: kd.bos.dataentity.serialization.DynamicObjectSerializationBinder
simple_name: DynamicObjectSerializationBinder
package_name: kd.bos.dataentity.serialization
title: DynamicObjectSerializationBinder
class_comment:
为动态实体在序列化和反序列化时，使用的绑定器 在序列化时，他在序列化的同时，记录下所有涉及的DynamicObjectType，以便记录这些信息 在反序列化时，外部传入指定一批可用的类型。参见DynamicObject中KnowTypes


class_name: kd.bos.dataentity.trace.EntityTraceHint
simple_name: EntityTraceHint
package_name: kd.bos.dataentity.trace
title: EntityTraceHint
class_comment:
创建实体运行监控节点时的参数设置 可通过参数控制是否与apm对接，默认会和apm对接，同步生成apm的调用链节点。 但部分方法调用非常频繁，会对apm产生很大性能压力，此时没有必要对接，可设置参数不对接


class_name: kd.bos.dataentity.utils.ArrayUtils
simple_name: ArrayUtils
package_name: kd.bos.dataentity.utils
title: ArrayUtils
class_comment:
Operations on arrays, primitive arrays (like ` int[]`) and primitive wrapper arrays (like ` Integer[]`).


class_name: kd.bos.dataentity.utils.Validate
simple_name: Validate
package_name: kd.bos.dataentity.utils
title: Validate
class_comment:
This class assists in validating arguments. The validation methods are based along the following principles: 
  * An invalid ` null` argument causes a NullPointerException.
  * A non-` null` argument causes an IllegalArgumentException.
  * An invalid index into an array/collection/map/string causes an IndexOutOfBoundsException.
All exceptions messages are [format strings](http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Formatter.html#syntax) as defined by the Java platform. For example:
    
    
      Validate.isTrue(i > 0, "The value must be greater than zero: %d", i);  Validate.notNull(surname, "The surname must not be %s", null);  
#ThreadSafe#  String#format(String, Object...)


class_name: kd.bos.db.splittingread.RW
simple_name: RW
package_name: kd.bos.db.splittingread
title: RW
class_comment:
RW是一个创建RWContext的API，可以使用RW创建一个从库优先或者主库优先的查询上下文。  例如：在配置了自定义key：“key1”为从库优先(read-first)时，在RWContext上下文范围内，ORM查询和DB查询都会优先使用从库  try(RWContext context = DB.rw().create("key1")){ DB.queryXXX() // 优先使用从库 ORM.queryXXX() // 优先使用从库 }


class_name: kd.bos.dlock.DLock
simple_name: DLock
package_name: kd.bos.dlock
title: DLock
class_comment:
分布式锁接口  基本用法: 
    
    
    try (DLocklock= DLock.create("key", "desc")) {
          lock.lock();
          // ...
      }


class_name: kd.bos.dlock.DLockInfo
simple_name: DLockInfo
package_name: kd.bos.dlock
title: DLockInfo
class_comment:
分布式锁信息 信息包含锁key(StorePath)、描述、创建时间、持有锁的微服务节点、锁申请者数量。 这些信息在Monitor中可查看到，代码中则通过`DLock.getLockInfo(key)`获取到。


class_name: kd.bos.entity.botp.runtime.TableDefine
simple_name: TableDefine
package_name: kd.bos.entity.botp.runtime
title: TableDefine
class_comment:
单据实体表格定义 主要用于BOTP：单据实体，包括单据头、单据体、子单据体均会各自动态生成一个唯一的长整数型表格编码，在BOTP关联关系中标识实体。 表格编码是动态生成的，在不同数据中心不一样，一经生成并在BOTP关联关系中应用，不能更改。


class_name: kd.bos.entity.datamodel.events.AfterMoveEntryEventArgs
simple_name: AfterMoveEntryEventArgs
package_name: kd.bos.entity.datamodel.events
title: AfterMoveEntryEventArgs
class_comment:
移动行之后事件参数 表单运行时模型层插件接口IDataModelChangeListener#afterMoveEntryDown(AfterMoveEntryEventArgs)、IDataModelChangeListener#afterMoveEntryUp(AfterMoveEntryEventArgs)事件参数


class_name: kd.bos.entity.datamodel.events.AfterTogetherMoveEntryRowEventArgs
simple_name: AfterTogetherMoveEntryRowEventArgs
package_name: kd.bos.entity.datamodel.events
title: AfterTogetherMoveEntryRowEventArgs
class_comment:
聚合分录行移动后事件参数 表单运行时模型层插件接口IDataModelChangeListener#afterTogetherMoveEntryRow(AfterTogetherMoveEntryRowEventArgs)、IDataModelChangeListener#afterTogetherMoveEntryRow(AfterTogetherMoveEntryRowEventArgs)事件参数


class_name: kd.bos.entity.datamodel.events.BeforePackageDataEvent
simple_name: BeforePackageDataEvent
package_name: kd.bos.entity.datamodel.events
title: BeforePackageDataEvent
class_comment:
单据列表控件数据格式化前事件参数 单据列表控件的格式化 kd.bos.entity.list.events.BeforePackageDataListener#beforePackageData(BeforePackageDataEvent) 事件参数


class_name: kd.bos.entity.datamodel.events.BeforeSetItemValueEventArgs
simple_name: BeforeSetItemValueEventArgs
package_name: kd.bos.entity.datamodel.events
title: BeforeSetItemValueEventArgs
class_comment:
基础资料字段赋值前事件参数 表单运行时模型层插件接口IDataModelChangeListener#beforeSetItemValue(BeforeSetItemValueEventArgs)事件参数


class_name: kd.bos.entity.datamodel.events.BeforeTogetherMoveEntryRowEventArgs
simple_name: BeforeTogetherMoveEntryRowEventArgs
package_name: kd.bos.entity.datamodel.events
title: BeforeTogetherMoveEntryRowEventArgs
class_comment:
聚合分录行移动前事件参数 表单运行时模型层插件接口IDataModelChangeListener#beforeTogetherMoveEntryRow(BeforeTogetherMoveEntryRowEventArgs)事件参数


class_name: kd.bos.entity.datamodel.events.IDataModelChangeListener
simple_name: IDataModelChangeListener
package_name: kd.bos.entity.datamodel.events
title: IDataModelChangeListener
class_comment:
表单运行时模型层插件事件接口，提供字段值改变、分录行增删事件 插件抽象基类 `  kd.bos.form.plugin.AbstractFormPlugin` 实现了本接口，可基于此抽象基类定义插件 示例：定义一个表单插件，从插件抽象基类派生


class_name: kd.bos.entity.datamodel.events.IDataModelListener
simple_name: IDataModelListener
package_name: kd.bos.entity.datamodel.events
title: IDataModelListener
class_comment:
表单运行时模型层插件事件接口，提供数据包初始化事件 插件抽象基类 `  kd.bos.form.plugin.AbstractFormPlugin` 实现了本接口，可基于此抽象基类定义插件 示例：定义一个表单插件，从插件抽象基类派生


class_name: kd.bos.entity.datamodel.events.QueryImportBasedataEventArgs
simple_name: QueryImportBasedataEventArgs
package_name: kd.bos.entity.datamodel.events
title: QueryImportBasedataEventArgs
class_comment:
单据引入，批量匹配依赖的基础数据事件参数 表单运行时模型层插件接口IDataModelListener#queryImportBasedata(QueryImportBasedataEventArgs)事件参数


class_name: kd.bos.entity.datamodel.ITreeModel
simple_name: ITreeModel
package_name: kd.bos.entity.datamodel
title: ITreeModel
class_comment:
左树右表列表运行时数据模型层访问、控制接口 本接口提供方法访问列表运行时数据模型层 左树右表列表插件(`  kd.bos.list.plugin.AbstractTreeListPlugin`) 可使用 ` this.getTreeModel()`获取此接口实例


class_name: kd.bos.entity.plugin.AbstractDataModelPlugin
simple_name: AbstractDataModelPlugin
package_name: kd.bos.entity.plugin
title: AbstractDataModelPlugin
class_comment:
表单运行时模型层插件抽象基类。 实现了运行时模型层插件接口 IDataModelListener、IDataModelChangeListener ，但未提供任何默认实现代码。 通常开发表单界面插件时，不会直接派生本类，而是派生本类的子类 kd.bos.form.plugin.AbstractFormPlugin，该类提供了表单插件的默认内部逻辑。


class_name: kd.bos.entity.plugin.AbstractOperationServicePlugIn
simple_name: AbstractOperationServicePlugIn
package_name: kd.bos.entity.plugin
title: AbstractOperationServicePlugIn
class_comment:
单据操作运行时服务层插件抽象基类。 单据操作在服务层运行时，会触发此插件的事件：包括数据检查、事务开启前、事务开启后、事务提交前、事务提交后等事件。 只有实体操作（如保存、删除、提交、审核等）能绑定操作插件，这些操作需要运行在操作服务层，把单据存入数据库。 表单操作（如刷新、退出）只会在表单层运行，不能绑定操作插件。 通过派生此类开发出操作插件，重写事件方法来处理事件。 开发好操作插件后，可以到单据设计器，把插件绑定到操作上。 如下是一个操作插件示例，只关注了事务开启前事件，且未实现具体逻辑：


class_name: kd.bos.entity.plugin.AddValidatorsEventArgs
simple_name: AddValidatorsEventArgs
package_name: kd.bos.entity.plugin
title: AddValidatorsEventArgs
class_comment:
单据操作插件IOperationServicePlugIn \- onAddValidators 事件参数 此事件在操作正式执行时，注册操作校验器前触发，后续用已注册的校验器检查单据数据是否符合操作要求 此参数对象中包含已经注册的操作校验器，插件可注册自定义的操作校验器


class_name: kd.bos.entity.plugin.args.AfterOperationArgs
simple_name: AfterOperationArgs
package_name: kd.bos.entity.plugin.args
title: AfterOperationArgs
class_comment:
操作事务提交后事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#afterExecuteOperationTransaction(AfterOperationArgs)事件参数


class_name: kd.bos.entity.plugin.args.BeforeOperationArgs
simple_name: BeforeOperationArgs
package_name: kd.bos.entity.plugin.args
title: BeforeOperationArgs
class_comment:
操作校验通过，开启事务前事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#beforeExecuteOperationTransaction(BeforeOperationArgs)事件参数


class_name: kd.bos.entity.plugin.args.BeforeSaveAuditLogArg
simple_name: BeforeSaveAuditLogArg
package_name: kd.bos.entity.plugin.args
title: BeforeSaveAuditLogArg
class_comment:
操作完成，保存审计日志前事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#beforeSaveAuditLog(BeforeSaveAuditLogArg)事件参数


class_name: kd.bos.entity.plugin.args.BeginOperationTransactionArgs
simple_name: BeginOperationTransactionArgs
package_name: kd.bos.entity.plugin.args
title: BeginOperationTransactionArgs
class_comment:
操作开启事务后事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#beginOperationTransaction(BeginOperationTransactionArgs)事件参数


class_name: kd.bos.entity.plugin.args.EndOperationTransactionArgs
simple_name: EndOperationTransactionArgs
package_name: kd.bos.entity.plugin.args
title: EndOperationTransactionArgs
class_comment:
调用操作事务结束（事务内）事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#endOperationTransaction(EndOperationTransactionArgs)事件参数


class_name: kd.bos.entity.plugin.args.InitOperationArgs
simple_name: InitOperationArgs
package_name: kd.bos.entity.plugin.args
title: InitOperationArgs
class_comment:
操作服务层操作初始化时事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#initialize(InitOperationArgs)事件参数


class_name: kd.bos.entity.plugin.args.ReturnOperationArgs
simple_name: ReturnOperationArgs
package_name: kd.bos.entity.plugin.args
title: ReturnOperationArgs
class_comment:
操作微服务执行结束，返回结果之前事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#onReturnOperation(ReturnOperationArgs)事件参数


class_name: kd.bos.entity.plugin.args.RollbackOperationArgs
simple_name: RollbackOperationArgs
package_name: kd.bos.entity.plugin.args
title: RollbackOperationArgs
class_comment:
操作处理失败，回滚事务时事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#rollbackOperation(RollbackOperationArgs)事件参数


class_name: kd.bos.entity.plugin.args.ValidatePrefixArgs
simple_name: ValidatePrefixArgs
package_name: kd.bos.entity.plugin.args
title: ValidatePrefixArgs
class_comment:
执行操作校验前事件参数 单据操作插件kd.bos.entity.plugin.IOperationServicePlugIn#validatePrefix(ValidatePrefixArgs)事件参数


class_name: kd.bos.entity.plugin.IOperationService
simple_name: IOperationService
package_name: kd.bos.entity.plugin
title: IOperationService
class_comment:
单据操作运行时服务层插件事件接口，提供操作上下文设置方法 提供了插件运行上下文环境变量设置的方法，操作插件抽象基类kd.bos.entity.plugin.AbstractOperationServicePlugIn默认实现了此接口，插件继承基类之后，不需要再实现此接口的方法。


class_name: kd.bos.entity.plugin.PreparePropertysEventArgs
simple_name: PreparePropertysEventArgs
package_name: kd.bos.entity.plugin
title: PreparePropertysEventArgs
class_comment:
单据操作插件IOperationServicePlugIn \- onPreparePropertys 事件参数 此事件在操作正式执行时，准备加载待处理的单据数据包前触发 插件可在此事件添加自身需要用到字段


class_name: kd.bos.entity.property.org.OrgRelationConfig
simple_name: OrgRelationConfig
package_name: kd.bos.entity.property.org
title: OrgRelationConfig
class_comment:
单据上组织字段之间的协作关系 内含业务协作类型、委托组织、受托组织、协作方向等下级属性。 应用于kd.bos.entity.BillEntityType#getOrgRelationConfigList()。


class_name: kd.bos.entity.tree.TreeNode
simple_name: TreeNode
package_name: kd.bos.entity.tree
title: TreeNode
class_comment:
树形控件节点 内含节点标识、节点内容、下级节点等信息， 应用于树形控件kd.bos.form.control.TreeView。 树形控件节点支持懒加载，即首次不加载子节点，等用户点击节点时才动态加载其下级节点。 要实现懒加载模式，节点的下级节点#getChildren()必须为空集合` treeNode.setChildren(new ArrayList())`。 可使用如下方式判断节点是否为子节点：` treenode.getChildren()==null</code>`


class_name: kd.bos.extplugin.StdExtPlugin
simple_name: StdExtPlugin
package_name: kd.bos.extplugin
title: StdExtPlugin
class_comment:
通用的二次扩展接口  业务场景可以直接使用此接口接入二次扩展插件， 也可以自行定义接口、参数，更加灵活。 使用 StdExtPluginProxy 配合使用本接口。 示例代码： ` StdExtPluginProxy stdExtPluginProxy = StdExtPluginProxy.create("kd.bos.extplugin.sample.universal.XXXBizFormPlugin"); // 准备触发before事件 ExtEvent beforeEvent = new ExtEvent("before"); beforeEvent.putEventArg("opParam", arg); // 可传入多个参数值，参数标识可按需要灵活调整 stdExtPluginProxy.fireExtEvent(beforeEvent); Boolean cancel = (Boolean) beforeEvent.getEventArg("cancel"); if (cancel != null && cancel) { return; } // todo 预置的业务逻辑 // 准备触发after事件 ExtEvent afterEvent = new ExtEvent("after"); afterEvent.putEventArg("result", arg); stdExtPluginProxy.fireExtEvent(afterEvent); // 触发release事件，释放资源 stdExtPluginProxy.release(); </code>````


class_name: kd.bos.fileservice.BatchDownloadRequest.Dir
simple_name: Dir
package_name: kd.bos.fileservice
title: BatchDownloadRequest.Dir
class_comment:
表示压缩包内的虚拟目录结构（支持多级嵌套） 通过组合dirs与files可构建复杂层级结构：
    
    
      new Dir("parent",      new Dir[] { new Dir("child") },      new File[] { new File("file.txt", "xxx/xxx/1.txt") }  )


class_name: kd.bos.fileservice.BatchDownloadRequest
simple_name: BatchDownloadRequest
package_name: kd.bos.fileservice
title: BatchDownloadRequest
class_comment:
批量下载请求实体，支持层级化文件结构打包功能 通过构建文件/目录树形结构，服务端可将多个资源打包为指定格式的压缩文件。典型使用场景：
    
    
      fileName: 文件名  zip中支持目录结构，明细节点是url文件，比如  最终结果是：  凭证-2018-4-12.zip  目录1      文件名1.xxx      文件名2.xxx  目录2   文件名3.xxx      文件名4.xxx  文件名5.xxx  文件名6.xxx   那么请求结构如下:  fileName=凭证-2018-4-12  dirs[]      dir1: name=目录1          files[]:              files[0]: name=文件名1.xxx,url=xxxx              files[1]: name=文件名2.xxx,url=xxxx   dir2: name=目录2       files[]:           files[3]: name=文件名3.xxx,url=xxxx              files[4]: name=文件名4.xxx,url=xxxx  files[]:          files[5]: name=文件名5.xxx,url=xxxx          files[6]: name=文件名6.xxx,url=xxxx   
  kd.bos.fileservice.Dir 目录结构定义  kd.bos.fileservice.File 文件元数据定义


class_name: kd.bos.filestorage.spi.FileStorageService
simple_name: FileStorageService
package_name: kd.bos.filestorage.spi
title: FileStorageService
class_comment:
文件存储服务扩展接口 (SPI机制核心契约) 定义与存储后端无关的统一文件操作接口，通过实现类适配不同存储系统(minio/S3/Swift等)。 实现类需确保线程安全，推荐使用无状态设计。  kd.bos.filestorage.minio.MinIOStorage 参考实现MinIO对象存储适配  kd.bos.filestorage.s3.S3Storage 参考实现AWS S3协议兼容存储适配  kd.bos.filestorage.swift.SwiftStorage 参考实现OpenStack Swift存储适配


class_name: kd.bos.form.chart.Label
simple_name: Label
package_name: kd.bos.form.chart
title: Label
class_comment:
图形上的文本标签，可用于说明图形的一些数据信息，比如值，名称等，label选项在 ECharts 2.x 中放置于itemStyle下，在 ECharts 3 中为了让整个配置项结构更扁平合理，label 被拿出来跟 itemStyle 平级，并且跟 itemStyle 一样拥有 emphasis 状态。


class_name: kd.bos.form.control.embedform.EmbedFormListener
simple_name: EmbedFormListener
package_name: kd.bos.form.control.embedform
title: EmbedFormListener
class_comment:
嵌入页面控件监听事件接口。 特别注意： 插件需要在 kd.bos.form.plugin.AbstractFormPlugin#beforeBindData(EventObject) 事件中调用 EmbedForm#addListener(EmbedFormListener) 方法注册监听器，否则可能不会被触发


class_name: kd.bos.form.control.events.BaseDataColumnDependFieldSetEvent
simple_name: BaseDataColumnDependFieldSetEvent
package_name: kd.bos.form.control.events
title: BaseDataColumnDependFieldSetEvent
class_comment:
设置常用过滤的基础资料依赖字段事件参数 应用于设置常用过滤的基础资料依赖字段事件接口BaseDataColumnDependFieldSetListener#dependFieldSet(BaseDataColumnDependFieldSetEvent)、 PC端列表插件kd.bos.list.plugin.IPCListPlugin#baseDataColumnDependFieldSet(BaseDataColumnDependFieldSetEvent)上


class_name: kd.bos.form.control.events.BaseDataColumnDependFieldSetListener
simple_name: BaseDataColumnDependFieldSetListener
package_name: kd.bos.form.control.events
title: BaseDataColumnDependFieldSetListener
class_comment:
设置常用过滤的基础资料依赖字段事件接口 应用于过滤容器kd.bos.filter.FilterContainer#addBaseDataColumnDependFieldSetListener(BaseDataColumnDependFieldSetListener)上


class_name: kd.bos.form.control.events.FilterContainerInitEvent
simple_name: FilterContainerInitEvent
package_name: kd.bos.form.control.events
title: FilterContainerInitEvent
class_comment:
容器过滤条件初始化事件参数 应用于容器过滤条件初始化事件接口FilterContainerInitListener#filterContainerInit(FilterContainerInitEvent)上


class_name: kd.bos.form.control.events.FilterContainerInitListener
simple_name: FilterContainerInitListener
package_name: kd.bos.form.control.events
title: FilterContainerInitListener
class_comment:
容器过滤条件初始化事件接口 应用于过滤容器kd.bos.filter.FilterContainer#addFilterContainerInitListener(FilterContainerInitListener)上


class_name: kd.bos.form.control.events.MobFilterSortInitListener
simple_name: MobFilterSortInitListener
package_name: kd.bos.form.control.events
title: MobFilterSortInitListener
class_comment:
过滤容器初始化事件接口 应用于移动端过滤排序kd.bos.filter.mcontrol.MobFilterSort#addMobFilterSortInitListener(MobFilterSortInitListener)上


class_name: kd.bos.form.control.events.MobileSearchInitEvent
simple_name: MobileSearchInitEvent
package_name: kd.bos.form.control.events
title: MobileSearchInitEvent
class_comment:
移动端搜索控件初始化事件参数 应用于移动端搜索控件初始化事件监听器MobileSearchInitListener#mobileSearchInit(MobileSearchInitEvent)、 移动端列表插件kd.bos.list.plugin.IMobListPlugin#mobileSearchInit(MobileSearchInitEvent)接口上


class_name: kd.bos.form.control.events.MobileSearchInitListener
simple_name: MobileSearchInitListener
package_name: kd.bos.form.control.events
title: MobileSearchInitListener
class_comment:
移动端搜索控件初始化事件接口 应用于移动端搜索控件kd.bos.list.MobileSearch#addMobileSearchInitListener(MobileSearchInitListener)上


class_name: kd.bos.form.events.AfterBindDataListener
simple_name: AfterBindDataListener
package_name: kd.bos.form.events
title: AfterBindDataListener
class_comment:
绑定数据后事件接口 应用于过滤容器kd.bos.filter.FilterContainer#addAfterBindDataListener(AfterBindDataListener)、 移动端过滤排序kd.bos.filter.mcontrol.MobFilterSort#addAfterBindDataListener(AfterBindDataListener)、 单据列表控件kd.bos.list.BillList#addAfterBindDataListener(AfterBindDataListener)、 移动搜索控件kd.bos.list.MobileSearch#addAfterBindDataListener(AfterBindDataListener)上


class_name: kd.bos.form.events.AfterMobileListPushDownRefreshEvent
simple_name: AfterMobileListPushDownRefreshEvent
package_name: kd.bos.form.events
title: AfterMobileListPushDownRefreshEvent
class_comment:
移动端列表下拉刷新界面事件参数 应用于移动端列表下拉刷新事件接口AfterMobileListPushDownRefreshListener#afterPushDownRefresh(AfterMobileListPushDownRefreshEvent)上


class_name: kd.bos.form.events.AfterMobileListPushDownRefreshListener
simple_name: AfterMobileListPushDownRefreshListener
package_name: kd.bos.form.events
title: AfterMobileListPushDownRefreshListener
class_comment:
移动端列表下拉刷新事件接口 移动端列表插件接口kd.bos.list.plugin.IMobListPlugin继承了本类 应用于单据列表控件kd.bos.list.BillList#addMobileListPushDownRefreshistener(AfterMobileListPushDownRefreshListener)上


class_name: kd.bos.form.events.BeforeBindDataListener
simple_name: BeforeBindDataListener
package_name: kd.bos.form.events
title: BeforeBindDataListener
class_comment:
绑定数据前事件接口 应用于过滤容器kd.bos.filter.FilterContainer#addBeforeBindDataListener(BeforeBindDataListener)、 单据列表控件kd.bos.list.BillList#addBeforeBindDataListener(BeforeBindDataListener)、 移动搜索控件kd.bos.list.MobileSearch#addBeforeBindDataListener(BeforeBindDataListener)上


class_name: kd.bos.form.events.BeforeBuildTreeNodeEvent
simple_name: BeforeBuildTreeNodeEvent
package_name: kd.bos.form.events
title: BeforeBuildTreeNodeEvent
class_comment:
构建树节点前置处理事件参数 应用于树形基础资料模板插件接口kd.bos.list.plugin.ITreeListPlugin#beforeBuildTreeNode(BeforeBuildTreeNodeEvent)上


class_name: kd.bos.form.events.BeforeCreateListColumnsArgs
simple_name: BeforeCreateListColumnsArgs
package_name: kd.bos.form.events
title: BeforeCreateListColumnsArgs
class_comment:
创建列表前事件参数 应用于创建列表列事件接口kd.bos.list.events.CreateListColumnsListener#createListColumns(BeforeCreateListColumnsArgs)、 列表插件接口kd.bos.list.plugin.IListPlugin#beforeCreateListColumns(BeforeCreateListColumnsArgs)上


class_name: kd.bos.form.events.BeforeDoCheckDataPermissionArgs
simple_name: BeforeDoCheckDataPermissionArgs
package_name: kd.bos.form.events
title: BeforeDoCheckDataPermissionArgs
class_comment:
操作检查数据权限前事件参数 应用于表单界面插件基本接口kd.bos.form.plugin.IFormPlugin#beforeCheckDataPermission(BeforeDoCheckDataPermissionArgs)上


class_name: kd.bos.form.events.BeforeExportFileEvent
simple_name: BeforeExportFileEvent
package_name: kd.bos.form.events
title: BeforeExportFileEvent
class_comment:
列表引出文件前事件参数 列表引出文件事件ExportFileEvent继承了本类 应用于列表插件接口kd.bos.list.plugin.IListPlugin#beforeExportFile(BeforeExportFileEvent)上


class_name: kd.bos.form.events.BeforeFieldPostBackEvent
simple_name: BeforeFieldPostBackEvent
package_name: kd.bos.form.events
title: BeforeFieldPostBackEvent
class_comment:
客户端提交字段值到服务端事件参数 应用于表单界面插件基本接口kd.bos.form.plugin.IFormPlugin#beforeFieldPostBack(BeforeFieldPostBackEvent)上


class_name: kd.bos.form.events.BeforeTreeNodeClickEvent
simple_name: BeforeTreeNodeClickEvent
package_name: kd.bos.form.events
title: BeforeTreeNodeClickEvent
class_comment:
树节点点击之前事件参数 应用于树形基础资料模板插件接口kd.bos.list.plugin.ITreeListPlugin#beforeTreeNodeClick(BeforeTreeNodeClickEvent)上


class_name: kd.bos.form.events.ClosedCallBackEvent
simple_name: ClosedCallBackEvent
package_name: kd.bos.form.events
title: ClosedCallBackEvent
class_comment:
关闭回调事件参数 应用于表单界面插件基本接口kd.bos.form.plugin.IFormPlugin#closedCallBack(ClosedCallBackEvent)、 子界面关闭后的回调处理接口kd.bos.form.ICloseCallBack#closedCallBack(ClosedCallBackEvent)上


class_name: kd.bos.form.events.FilterContainerInitArgs
simple_name: FilterContainerInitArgs
package_name: kd.bos.form.events
title: FilterContainerInitArgs
class_comment:
过滤容器初始化事件参数 应用于列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#filterContainerInit(FilterContainerInitArgs)上


class_name: kd.bos.form.events.FilterContainerSearchClickArgs
simple_name: FilterContainerSearchClickArgs
package_name: kd.bos.form.events
title: FilterContainerSearchClickArgs
class_comment:
过滤容器查询点击事件参数 应用于列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#filterContainerSearchClick(FilterContainerSearchClickArgs)、 列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#filterContainerAfterSearchClick(FilterContainerSearchClickArgs)、 报表表单插件接口kd.bos.report.plugin.IReportFormPlugin#filterContainerSearchClick(FilterContainerSearchClickArgs)上


class_name: kd.bos.form.events.HyperLinkClickEvent
simple_name: HyperLinkClickEvent
package_name: kd.bos.form.events
title: HyperLinkClickEvent
class_comment:
超链接点击事件参数 单据列表单元格链接点击事件BillListHyperLinkClickEvent继承了本类 应用于超链接点击事件接口HyperLinkClickListener#hyperLinkClick(HyperLinkClickEvent)接口上


class_name: kd.bos.form.events.ListColumnCompareTypesSetEvent
simple_name: ListColumnCompareTypesSetEvent
package_name: kd.bos.form.events
title: ListColumnCompareTypesSetEvent
class_comment:
列表表头过滤比较符设置事件参数 应用于列表表头过滤比较符设置事件接口ListColumnCompareTypesSetListener#listColumnCompareTypesSet(ListColumnCompareTypesSetEvent)、 列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#listColumnCompareTypesSet(ListColumnCompareTypesSetEvent)上


class_name: kd.bos.form.events.ListColumnCompareTypesSetListener
simple_name: ListColumnCompareTypesSetListener
package_name: kd.bos.form.events
title: ListColumnCompareTypesSetListener
class_comment:
列表表头过滤比较符设置事件接口 应用于单据列表控件kd.bos.list.BillList#addListColumnCompareTypesSetListener(ListColumnCompareTypesSetListener)、 列表字段控件kd.bos.list.ListColumn#setListColumnCompareTypesSetListeners(List)、 列表分组字段kd.bos.list.ListColumnGroup#setListColumnCompareTypesSetListeners(List)、 合并列表字段kd.bos.list.MergeListColumn#setListColumnCompareTypesSetListeners(List)上


class_name: kd.bos.form.events.LoadCustomControlMetasArgs
simple_name: LoadCustomControlMetasArgs
package_name: kd.bos.form.events
title: LoadCustomControlMetasArgs
class_comment:
加载定制控件元数据事件参数 应用于表单界面插件基本接口kd.bos.form.plugin.IFormPlugin#loadCustomControlMetas(LoadCustomControlMetasArgs)上


class_name: kd.bos.form.events.MessageBoxClosedEvent
simple_name: MessageBoxClosedEvent
package_name: kd.bos.form.events
title: MessageBoxClosedEvent
class_comment:
提示框关闭事件参数 应用于表单界面插件基本接口kd.bos.form.plugin.IFormPlugin#messageBoxClosed(MessageBoxClosedEvent)、 kd.bos.form.plugin.IFormPlugin#confirmCallBack(MessageBoxClosedEvent)、 确认提示回调处理接口kd.bos.form.IConfirmCallBack#confirmCallBack(MessageBoxClosedEvent)上


class_name: kd.bos.form.events.MobFilterSortSearchClickArgs
simple_name: MobFilterSortSearchClickArgs
package_name: kd.bos.form.events
title: MobFilterSortSearchClickArgs
class_comment:
移动过滤排序控件搜索事件参数 应用于移动端列表插件kd.bos.list.plugin.IMobListPlugin#mobFilterSortSearchClick(MobFilterSortSearchClickArgs) )}、 kd.bos.list.plugin.IMobListPlugin#mobFilterSortAfterSearchClick(MobFilterSortSearchClickArgs)上


class_name: kd.bos.form.events.OnCreateDynamicUIMetasArgs
simple_name: OnCreateDynamicUIMetasArgs
package_name: kd.bos.form.events
title: OnCreateDynamicUIMetasArgs
class_comment:
创建动态UI元数据事件参数 应用于表单界面插件基本接口kd.bos.form.plugin.IFormPlugin#onCreateDynamicUIMetas(OnCreateDynamicUIMetasArgs)上


class_name: kd.bos.form.events.SetFilterEvent
simple_name: SetFilterEvent
package_name: kd.bos.form.events
title: SetFilterEvent
class_comment:
设置过滤条件事件参数 将常用过滤字段设置成过滤条件事件FilterColumnSetFilterEvent继承了本类 应用于设置过滤条件事件接口SetFilterListener#setFilter(SetFilterEvent)、 列表插件接口kd.bos.list.plugin.IListPlugin#setFilter(SetFilterEvent)、 列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#filterColumnSetFilter(SetFilterEvent)上


class_name: kd.bos.form.events.SumDataLoadOnFirstSetEvent
simple_name: SumDataLoadOnFirstSetEvent
package_name: kd.bos.form.events
title: SumDataLoadOnFirstSetEvent
class_comment:
页面加载同时“计算合计”事件开关参数 应用于列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#sumDataLoadOnFirstSet(SumDataLoadOnFirstSetEvent)上


class_name: kd.bos.form.field.events.AfterChangeMainOrgEventArgs
simple_name: AfterChangeMainOrgEventArgs
package_name: kd.bos.form.field.events
title: AfterChangeMainOrgEventArgs
class_comment:
新建单据，切换主组织完成后事件参数 应用于主组织切换事件接口MainOrgChangeListener#afterChangeMainOrg(AfterChangeMainOrgEventArgs)上


class_name: kd.bos.form.field.events.BasedataFuzzySearchListener
simple_name: BasedataFuzzySearchListener
package_name: kd.bos.form.field.events
title: BasedataFuzzySearchListener
class_comment:
基础资料模糊查询干预api事件接口 应用于基础资料控件kd.bos.form.field.BasedataEdit#addBasedataFuzzySearchListener(BasedataFuzzySearchListener)上 Author: rd_sort_oyang Date: 2018/4/18


class_name: kd.bos.form.field.events.BeforeBasedataSetValueListener
simple_name: BeforeBasedataSetValueListener
package_name: kd.bos.form.field.events
title: BeforeBasedataSetValueListener
class_comment:
基础资料设值之前事件接口 应用于基础资料控件kd.bos.form.field.BasedataEdit#addBeforeBasedataSetValueListener(BeforeBasedataSetValueListener) 上


class_name: kd.bos.form.field.events.BeforeChangeMainOrgEventArgs
simple_name: BeforeChangeMainOrgEventArgs
package_name: kd.bos.form.field.events
title: BeforeChangeMainOrgEventArgs
class_comment:
新建单据，用户切换主组织前事件参数 应用于主组织切换事件接口MainOrgChangeListener#beforeChangeMainOrg(BeforeChangeMainOrgEventArgs)上


class_name: kd.bos.form.field.events.BeforeF7SelectEvent
simple_name: BeforeF7SelectEvent
package_name: kd.bos.form.field.events
title: BeforeF7SelectEvent
class_comment:
选择基础资料前（弹出过滤窗口前）事件参数 应用于选择基础资料前（弹出过滤窗口前）事件接口BeforeF7SelectListener#beforeF7Select(BeforeF7SelectEvent)上


class_name: kd.bos.form.field.events.BeforeF7SelectListener
simple_name: BeforeF7SelectListener
package_name: kd.bos.form.field.events
title: BeforeF7SelectListener
class_comment:
选择基础资料前（弹出过滤窗口前）事件接口 应用于基础资料控件kd.bos.form.field.BasedataEdit#addBeforeF7SelectListener(BeforeF7SelectListener)、 弹性域kd.bos.form.field.FlexEdit#registerBeforeF7SelectListener(BeforeF7SelectListener)上


class_name: kd.bos.form.field.events.BeforeFilterF7SelectEvent
simple_name: BeforeFilterF7SelectEvent
package_name: kd.bos.form.field.events
title: BeforeFilterF7SelectEvent
class_comment:
过滤容器F7弹出之前事件参数 应用于选择基础资料前（弹出过滤窗口前）事件监听器接口BeforeFilterF7SelectListener#beforeF7Select(BeforeFilterF7SelectEvent)、 移动端列表插件kd.bos.list.plugin.IMobListPlugin#mobFilterSortBeforeF7Select(BeforeFilterF7SelectEvent)、 列表PC端插件接口kd.bos.list.plugin.IPCListPlugin#filterContainerBeforeF7Select(BeforeFilterF7SelectEvent)、 报表表单插件接口类kd.bos.report.plugin.IReportFormPlugin#filterContainerBeforeF7Select(BeforeFilterF7SelectEvent)上


class_name: kd.bos.form.field.events.BeforeFilterF7SelectListener
simple_name: BeforeFilterF7SelectListener
package_name: kd.bos.form.field.events
title: BeforeFilterF7SelectListener
class_comment:
选择基础资料前（弹出过滤窗口前）事件监听器接口 应用于过滤容器kd.bos.filter.FilterContainer#addBeforeF7SelectListener(BeforeFilterF7SelectListener)、 移动端过滤排序kd.bos.filter.mcontrol.MobFilterSort#addBeforeF7SelectListener(BeforeFilterF7SelectListener)、 通用过滤控件kd.bos.form.control.FilterGrid#addBeforeF7SelectListener(BeforeFilterF7SelectListener)上


class_name: kd.bos.form.field.events.BeforeQuickAddNewListener
simple_name: BeforeQuickAddNewListener
package_name: kd.bos.form.field.events
title: BeforeQuickAddNewListener
class_comment:
快捷新增前事件接口 应用于基础资料控件kd.bos.form.field.BasedataEdit#addBeforeQuickAddNewListener(BeforeQuickAddNewListener)上


class_name: kd.bos.form.field.events.FlexControlMetaPreRenderListener
simple_name: FlexControlMetaPreRenderListener
package_name: kd.bos.form.field.events
title: FlexControlMetaPreRenderListener
class_comment:
弹性域元数据监听 应用于弹性域编辑控件kd.bos.form.field.FlexEdit#addFlexControlMetaPreRenderListener(FlexControlMetaPreRenderListener)上


class_name: kd.bos.form.field.events.ListExpandEvent
simple_name: ListExpandEvent
package_name: kd.bos.form.field.events
title: ListExpandEvent
class_comment:
列表折叠表单事件参数 应用于列表折叠表单事件接口ListExpandListener#expandClick(ListExpandEvent)、 列表插件接口kd.bos.list.plugin.IListPlugin#expandClick(ListExpandEvent)上


class_name: kd.bos.form.FormShowParameter
simple_name: FormShowParameter
package_name: kd.bos.form
title: FormShowParameter
class_comment:
表单显示参数 使用IFormView#showForm(FormShowParameter)打开动态表单，传入表单显示参数 必需填写表单标识参数，#setFormId(String)，其他参数可选 示例：


class_name: kd.bos.form.IFormUserConfig
simple_name: IFormUserConfig
package_name: kd.bos.form
title: IFormUserConfig
class_comment:
用户参数存取接口 表单服务接口：读取本表单相关的用户参数，封装此接口的目的： 1. 提供方法，方便插件获取用户参数 2. FormView层预置接口实现类FormUserConfig，批量读取表单相关参数，避免多次访问数据库 插件使用示例：


class_name: kd.bos.form.mcontrol.mobtable.events.BeforeCreateMobTableColumnsEvent
simple_name: BeforeCreateMobTableColumnsEvent
package_name: kd.bos.form.mcontrol.mobtable.events
title: BeforeCreateMobTableColumnsEvent
class_comment:
创建移动表格列前事件参数 应用于创建移动表格列前事件接口IBeforeCreateMobTableColumnsListener#beforeCreateMobTableColumns(BeforeCreateMobTableColumnsEvent)上


class_name: kd.bos.form.mcontrol.mobtable.events.IBeforeCreateMobTableColumnsListener
simple_name: IBeforeCreateMobTableColumnsListener
package_name: kd.bos.form.mcontrol.mobtable.events
title: IBeforeCreateMobTableColumnsListener
class_comment:
创建移动表格列前事件接口 应用于移动表格kd.bos.form.mcontrol.mobtable.MobTable#addBeforeCreateMobTableColumnsListener(IBeforeCreateMobTableColumnsListener)上


class_name: kd.bos.form.mcontrol.mobtable.events.IMobTableDataProviderListener
simple_name: IMobTableDataProviderListener
package_name: kd.bos.form.mcontrol.mobtable.events
title: IMobTableDataProviderListener
class_comment:
创建移动表格数据访问类事件接口 应用于移动表格kd.bos.form.mcontrol.mobtable.MobTable#addMobTableDataProviderListener(IMobTableDataProviderListener)上


class_name: kd.bos.form.mcontrol.mobtable.events.IMobTableHyperLinkClickListener
simple_name: IMobTableHyperLinkClickListener
package_name: kd.bos.form.mcontrol.mobtable.events
title: IMobTableHyperLinkClickListener
class_comment:
超链接点击事件接口 应用于表格基类控件kd.bos.form.mcontrol.mobtable.MobTable#addHyperClickListener(IMobTableHyperLinkClickListener)上


class_name: kd.bos.form.mcontrol.mobtable.events.IMobTablePackageDataHandlerListener
simple_name: IMobTablePackageDataHandlerListener
package_name: kd.bos.form.mcontrol.mobtable.events
title: IMobTablePackageDataHandlerListener
class_comment:
移动表格数据打包处理类事件接口 应用于移动表格kd.bos.form.mcontrol.mobtable.MobTable#addMobTablePackageDataHandlerListener(IMobTablePackageDataHandlerListener)上


class_name: kd.bos.form.mcontrol.mobtable.events.MobTablePackageDataHandlerArgs
simple_name: MobTablePackageDataHandlerArgs
package_name: kd.bos.form.mcontrol.mobtable.events
title: MobTablePackageDataHandlerArgs
class_comment:
移动表格数据打包处理类事件参数 应用于移动表格数据打包处理接口kd.bos.form.mcontrol.mobtable.IMobTablePackageDataHandler#getData(MobTablePackageDataHandlerArgs)、 kd.bos.form.mcontrol.mobtable.IMobTablePackageDataHandler#handleData(MobTablePackageDataHandlerArgs)、 kd.bos.form.mcontrol.mobtable.IMobTablePackageDataHandler#getFmtInfo(MobTablePackageDataHandlerArgs)上


class_name: kd.bos.form.mcontrol.mobtable.events.MobTablePackageDataHandlerEvent
simple_name: MobTablePackageDataHandlerEvent
package_name: kd.bos.form.mcontrol.mobtable.events
title: MobTablePackageDataHandlerEvent
class_comment:
移动表格数据打包处理类事件参数 应用于移动表格数据打包处理接口IMobTablePackageDataHandlerListener#createMobTablePackageDataHandler(MobTablePackageDataHandlerEvent)上


class_name: kd.bos.form.mcontrol.mobtable.MobTable
simple_name: MobTable
package_name: kd.bos.form.mcontrol.mobtable
title: MobTable
class_comment:
移动表格：可以视为移动端单据体(卡片分录)的表格视图 通过绑定数据源实体及字段从PC实体字段继承过来(修改字段映射相当于实体删除原字段/添加新字段) 特点：1.元数据通过动态发给前端; 2.移动端视图上不存在PC前端控件; 3.移动端与PC共用实体及模型 创建列: 将PC端字段属性信息与移动表格字段的个性化属性相合并动态发往前端 取数: 由于model实体PC和移动端使用同一套，可以直接使用model取数 格式化: 由于缺少前端字段控件，所以是读取PC元数据构建前端字段


class_name: kd.bos.form.operatecol.OperationColItem
simple_name: OperationColItem
package_name: kd.bos.form.operatecol
title: OperationColItem
class_comment:
操作列项 包括ID，操作显示方式（0文字1图片），操作名称，操作KEY，图标等下级属性。 应用于kd.bos.form.control.OperationColumn#getOperationColItems()


class_name: kd.bos.form.plugin.importentry.strategy.ImportEntryTemplateListener
simple_name: ImportEntryTemplateListener
package_name: kd.bos.form.plugin.importentry.strategy
title: ImportEntryTemplateListener
class_comment:
下载单据体导入模板注册事件，该接口插件绑定入口在：单据体导入模板-》插件文本框 案例说明： 1. 下载单据体导入引出模板时，通过数据库保存的模板数据，获取绑定的插件全路径 2. 用户插件实现该接口，重写beforeSetBaseData等方法 3. 下载单据体导入模板时，实例化模板数据的插件集合，取该接口的实现类，运行对应方法


class_name: kd.bos.form.plugin.ImportTemplateListener
simple_name: ImportTemplateListener
package_name: kd.bos.form.plugin
title: ImportTemplateListener
class_comment:
下载单据引入模板注册事件，该接口插件绑定入口在：单据引入模板-》插件文本框 案例说明： 1. 下载单据引入引出模板时，通过数据库保存的模板数据，获取绑定的插件全路径 2. 用户插件实现该接口，重写beforeSetBaseData等方法 3. 下载模板时，实例化模板数据的插件集合，取该接口的实现类，运行对应方法


class_name: kd.bos.form.widget.events.WidgetContainerDesignerListener
simple_name: WidgetContainerDesignerListener
package_name: kd.bos.form.widget.events
title: WidgetContainerDesignerListener
class_comment:
卡片容器设计器事件接口 应用于卡片容器kd.bos.form.widget.WidgetContainer#addWidgetContainerDesignerListener(WidgetContainerDesignerListener)上


class_name: kd.bos.formula.excel.UDFunction
simple_name: UDFunction
package_name: kd.bos.formula.excel
title: UDFunction
class_comment:
自定义函数运行接口 定义自定义函数需实现这个接口 例如： 实现一个contains函数 
    
    
    UDFunctionfuncLike=newUDFunction()
              {
    
                  public String getName() {
                      return"contains";
                  }
    
                  public Object call(Object... params) {
                      Stringleft= (String)params[0];
                      Stringright= (String)params[1];
    
                      return left.contains(right);
                  }
              };
    
              Stringformula="contains('abc','bc')";
              Objectresult= FormulaEngine.execExcelFormula(formula, Collections.<String,Object>emptyMap(), newUDFunction[]{funcLike});


class_name: kd.bos.formula.excel.Visitor
simple_name: Visitor
package_name: kd.bos.formula.excel
title: Visitor
class_comment:
表达式执行单元遍历接口 例如：kd.bos.entity.function.UDFunctionVisitor 收集表达式中所用到的函数 
    
    
    Stringexpression="right('hello', 2)";
           Exprexpr= FormulaEngine.parseFormula(expression);
           UDFunctionVisitorfunVisitor=newUDFunctionVisitor();
           expr.accept(funVisitor);
           Set<String> funcs = newHashSet<>();
           funcs.addAll(funVisitor.getFuncNames());
           Assert.assertEquals(true,funcs.contains("right"));


class_name: kd.bos.instance.Instance
simple_name: Instance
package_name: kd.bos.instance
title: Instance
class_comment:
Jvm运行实例 包含以下属性 clusterName: 集群 appName：应用名称 appIds:对外暴露的appIds deployedAppIds:部署代码的appIds instanceId：实例id ip:当前IP ports:端口


class_name: kd.bos.metadata.AbstractElement
simple_name: AbstractElement
package_name: kd.bos.metadata
title: AbstractElement
class_comment:
领域模型中的“元素”概念， 是构成领域模型的单元，从控件到实体字段，皆由“元素”这个该概念派生出来。 这里描述了元素之间的共性,比如元素之间的id和父元素id用于内部引擎不对外开放。 key和name作为用户输入指定，对于用户而言，这才是元素的标识


class_name: kd.bos.metadata.form.container.FlexPanelAp
simple_name: FlexPanelAp
package_name: kd.bos.metadata.form.container
title: FlexPanelAp
class_comment:
1,布局方向flex-direction:水平(默认),垂直 2,是否拉伸flex-grow,默认0,不拉伸 3,是否压缩flex-shrink,默认1,数字越大,拉伸或压缩比例越大 4,是否单行(flex-warp),默认单行(no-wrap) 5,溢出overflow,默认出现在容器外visible,hidden裁切,auto自动滚动栏


class_name: kd.bos.notification.AbstractNotificationClick
simple_name: AbstractNotificationClick
package_name: kd.bos.notification
title: AbstractNotificationClick
class_comment:
全局通知提醒弹窗点击事件处理抽象基类 使用示例 1、创建该抽象类的继承类 2、在发送全局消息通知时，将继承类全限定路径名作为ClickClassName参数封装在NotificationBody中 3、把NotificationBody封装在NotificationFormInfo中 4、把NotificationFormInfo和指定用户ID， 作为方法的参数发送全局消息通知


class_name: kd.bos.servicehelper.operation.OperationServiceHelper
simple_name: OperationServiceHelper
package_name: kd.bos.servicehelper.operation
title: OperationServiceHelper
class_comment:
实体操作服务类 注意事项：内部为调用微服务实现（存在3种可能 远程rpc/本地rpc/本地调用），请注意事务场景和入参受到的影响。 场景1.远程rpc: 若在微服务调用到其它节点执行逻辑，则无法控制在当前事务中，并且原入参对象（数据包）不会受操作逻辑改变，操作结束后需重新读取数据包（否则可能和数据库对不上）, 若数据包为新增场景（整单新增/单体新增行），反复使用触发操作的保存会出现重复新增/主键冲突; 场景2.本地rpc: 若在当前节点rpc执行，入参对象会序列/反序列化，操作中拿到的数据包是新的对象，进行的变更行为不会反馈在入参数据包对象，操作结束后需重新读取; 场景3.本地调用: 操作执行时，操作的数据包是原入参数据包对象。 场景2、3中，若外层开启事务，新增态的数据包（整单新增、分录新增）需要等到事务结束后才更新数据包中的状态信息，因此若后续还需要进行操作，建议视场景使用BusinessDataServiceHelper.load重新加载数据包


class_name: kd.hr.hbp.business.application.impl.common.AbstractSortingArrayService
simple_name: AbstractSortingArrayService
package_name: kd.hr.hbp.business.application.impl.common
title: AbstractSortingArrayService
class_comment:
快速排序算法排序, 使用时，必须实现 compareEqual，compareLarge方法 1、 通过 实现compareLarge方法 支持升序、降序 2、支持选择数组位置范围【起始、截止】排序 相比于 [jdk 自带的实现Comparable接口并重写compareTo()方法, 接着调用Collection.sort()方法实现排序]. 此方式无需代码侵入对象内部， 比如对动态对象 DynamicObject 排序


class_name: kd.hr.hbp.common.model.AuthorizedOrgResult
simple_name: AuthorizedOrgResult
package_name: kd.hr.hbp.common.model
title: AuthorizedOrgResult
class_comment:
授权的组织的结果 使用时，务必先判断 isHasAllOrgPerm()是否为true，如果是，getHasPermOrgs()是一个空集合，但含义却是所有组织都有权。 如果为false，则getHasPermOrgs()返回范围即为有权组织范围。


class_name: kd.hr.hbp.common.model.AuthorizedOrgResultWithSub
simple_name: AuthorizedOrgResultWithSub
package_name: kd.hr.hbp.common.model
title: AuthorizedOrgResultWithSub
class_comment:
授权的组织的结果，带是否包含下级的信息 使用时，务必先判断 isHasAllOrgPerm()是否为true，如果是，getHasPermOrgsWithSub()是一个空集合，但含义却是所有组织都有权。 如果为false，则getHasPermOrgsWithSub()返回范围即为有权组织范围。


class_name: kd.hr.hbp.common.model.AuthorizedOrgTeamResult
simple_name: AuthorizedOrgTeamResult
package_name: kd.hr.hbp.common.model
title: AuthorizedOrgTeamResult
class_comment:
授权的组织团队的结果 使用时，务必先判断 isHasAllOrgPerm()是否为true，如果是，getHasPermOrgs()是一个空集合，但含义却是所有组织都有权。 如果为false，则getHasPermOrgs()返回范围即为有权组织范围。


class_name: kd.sdk.annotation.SdkInternal
simple_name: SdkInternal
package_name: kd.sdk.annotation
title: SdkInternal
class_comment:
标识内部使用接口 
标注在方法、字段上：类被标注为SdkPublic后，默认其内部的public方法、字段是公开可用的。 有些内部使用的方法，受java访问控制的限制，也定义为了public，用本标识标注表明为不公开。 标注在类上：明确表示此类不会对外公开。


class_name: kd.sdk.annotation.SdkPackage
simple_name: SdkPackage
package_name: kd.sdk.annotation
title: SdkPackage
class_comment:
标识包 
用于`package-info.java`文件，表明此包所属的模块，一个模块含多个包情况下使用。 
在二开中使用，标准产品用SdkModule#includePackages()来定义。
  V4.2.0


class_name: kd.sdk.annotation.SdkScriptBound
simple_name: SdkScriptBound
package_name: kd.sdk.annotation
title: SdkScriptBound
class_comment:
标记java类是否在脚本中已有映射(绑定)关系，若不需要映射则可标识为  
本标注仅用于提高代码的可读性和可维护性：标注了SdkScriptBound的类，修改接口必须同步修改脚本。 
标注SdkPublic，接口通过bos-devtools的genSDK直接映射为脚本api。 标注SdkScriptBound，则表示被脚本使用，脚本的api为手工编写。(genSDK不会为此生成接口) 
若同时标注，则既生成接口又被手工编写为脚本接口，实际上不需要同时标注，不要为SDK提供两处使用入口。 
标注了SdkScriptBound之外的任何ElementType.TYPE类型Sdkxxx，均包含了SdkScriptBound的意思。 在非type上的标注，为更明细的脚本绑定标识。 
SDK接口版本变化的扫描，需要包含此标注的类。


class_name: kd.sdk.annotation.SdkScriptWrapper
simple_name: SdkScriptWrapper
package_name: kd.sdk.annotation
title: SdkScriptWrapper
class_comment:
对象：java对象的封装(wrapper)或者映射(明确声明它被脚本这样直接使用：$('xxx.xxx.xxx')) 
此标注scriptName名称优先于SdkPublic，见kd.sdk.j2k.kit.ClassAlias#getAlias


class_name: kd.sdk.hr.hspm.common.result.HrpiServiceOperateResult
simple_name: HrpiServiceOperateResult
package_name: kd.sdk.hr.hspm.common.result
title: HrpiServiceOperateResult
class_comment:
调用 IHRPIPersonService 的 saveOrUpdateInfo、deleteInfo 接口返回报文处理类 报文格式示例(saveOrUpdateInfo)： { "success": true, "message": null, "data": [ {"eventid": null, "entitynumber": "hrpi_person", "ids": [1354845125478415256,...]}, ... ] } 报文格式示例(deleteInfo)： { "success": true, "message": null, "data": 1 }


class_name: kd.sdk.hr.hspm.formplugin.web.file.ermanfile.ext.template.ManagePCFullFormDrawEdit
simple_name: ManagePCFullFormDrawEdit
package_name: kd.sdk.hr.hspm.formplugin.web.file.ermanfile.ext.template
title: ManagePCFullFormDrawEdit
class_comment:
管理端-pc端-全页面 参考：kd.sdk.hr.hspm.formplugin.web.file.ermanfile.base.CommonSingleFormDrawEdit 绑定 hspm_pagebase_dyv_extpl页面


class_name: kd.sdk.scm.sou.extpoint.ISouCompareAssistantRecentPriceSource
simple_name: ISouCompareAssistantRecentPriceSource
package_name: kd.sdk.scm.sou.extpoint
title: ISouCompareAssistantRecentPriceSource
class_comment:
比价助手最近交易价格参考数据源获取 1、通过实现当前插件，并在星瀚配置工具应用中维护现场自定义实现插件(扩展场景编码：SCM_SOU_COMPARETOOL_RECENTPRICE)实现来源数据特殊数据过滤要求。


class_name: kd.sdk.scmc.sbs.extpoint.ISbsSelectSNExpand
simple_name: ISbsSelectSNExpand
package_name: kd.sdk.scmc.sbs.extpoint
title: ISbsSelectSNExpand
class_comment:
选择已有序列号查询扩展:用于扩展选择已有序列号界面,查询执行时的sql语句逻辑 选择已有序列号页面为动态表单,点击查询按钮时,查询的sql是在程序中动态生成,当二开场景希望在页面上添加过滤字段时,系统并不能自动将添加字段的选择值拼接到查询sql的逻辑中 为此,提供本扩展点用于解决以上二开扩展场景


# doc_method

class_name: kd.bos.algo.Algo
method_name: createCachedDataSetBuilder
param_types_key: RowMeta,CacheHint
signature_text: public CachedDataSet.Builder createCachedDataSetBuilder(RowMeta rowMeta, CacheHint hint)
comment:
创建缓存结果集的Builder
@param `rowMeta` 元数据
@param `hint` 创建缓存结果集时的提示，可以设置缓存过期时间等信息
@return CachedDataSet.Builder


class_name: kd.bos.algo.Algo
method_name: createDataSet
param_types_key: Collection,RowMeta
signature_text: public abstract DataSet createDataSet(java.util.Collection<Object[]> rowList, RowMeta rowMeta)
comment:
使用一个集合,元数据创建DataSet，建议使用DataSetBuilder构造更好
@param `rowList` 集合数据
@param `rowMeta` 元数据
@return DataSet


class_name: kd.bos.algo.Algo
method_name: createDataSet
param_types_key: Input[]
signature_text: public abstract DataSet createDataSet(Input[] inputs)
comment:
使用Input源创建DataSet，这个输入源可以是kd.bos.algo.input.OrmInput，kd.bos.algo.input.DbInput等，或者自己实现一个Input。
@param `inputs` 输入源
@return DataSet


class_name: kd.bos.algo.AlgoException
method_name: create
param_types_key: String,Throwable,Object[]
signature_text: public static AlgoException create(String message, Throwable cause, Object[] args)
comment:
创建一个AlgoException
@param `cause` 被包装的异常
@param `message` 异常信息
@param `args` 异常信息中的参数
@return AlgoException


class_name: kd.bos.algo.AlgoException
method_name: wrap
param_types_key: Throwable,String,Object[]
signature_text: public static AlgoException wrap(Throwable cause, String message, Object[] args)
comment:
将异常包装成AlgoException
@param `cause` 被包装的异常
@param `message` 异常信息
@param `args` 异常信息中的占位参数
@return AlgoException


class_name: kd.bos.algo.CachedDataSet
method_name: toDataSet
param_types_key: Algo,boolean
signature_text: DataSet toDataSet(Algo algo, boolean closeAlso)
comment:
将CacheDataSet转成CacheDataSet
@param `algo` Algo对象
@param `closeAlso` 关闭DataSet时是否将缓存DataSet也关闭
@return DataSet 缓存结果转换后的DataSet


class_name: kd.bos.algo.CacheHint
method_name: setThrowExceptionWhenExceedAllowMaxRows
param_types_key: boolean
signature_text: public void setThrowExceptionWhenExceedAllowMaxRows(boolean throwExceptionWhenExceedAllowMaxRows)
comment:
设置触发dataset允许的最大数据行数时是否抛出异常
@param `throwExceptionWhenExceedAllowMaxRows` true为抛出异常，false不会抛出异常，会忽略超出最大行数的数据


class_name: kd.bos.algo.DataSet
method_name: executeSql
param_types_key: String,SqlHint
signature_text: public DataSet executeSql(String sql, SqlHint hint)
comment:
可以通过写sql的方式进行数据处理
@param `sql` sql语句
@param `hint` kd.bos.algo.SqlHint 执行sql语句时可以执行一些优化信息
@return DataSet


class_name: kd.bos.algo.DataSet
method_name: filter
param_types_key: String,Map
signature_text: public DataSet filter(String expr, java.util.Map<String, Object> params)
comment:
支持expr中写参数，参数值通过params传递 比如：
params.put("var1", 100);
filter("fqty>var1", params);
@param `expr` 过滤的表达式，支持变量方式
@param `params` 变量对应的参数值
@return DataSet


class_name: kd.bos.algo.DataSet
method_name: fullJoin
param_types_key: DataSet,JoinHint
signature_text: public default JoinDataSet fullJoin(DataSet rightDataSet, JoinHint hint)
comment:
指定join方式的全连接
@param `rightDataSet` join的另外一个结果集
@param `hint` kd.bos.algo.JoinHint Join的提示，可设置一些优化信息
@return JoinDataSet kd.bos.algo.JoinDataSet


class_name: kd.bos.algo.DataSet
method_name: groupBy
param_types_key: String[],boolean[]
signature_text: public GroupbyDataSet groupBy(String[] groupFields, boolean[] orderByDescs)
comment:
根据分组字段对DataSet进行分组，是否进行降序排列
@param `groupFields`
@param `orderByDescs` 是否根据分组字段进行降序排序
@return GroupbyDataSet


class_name: kd.bos.algo.DataSet
method_name: hashJoin
param_types_key: HashTable,String,String[]
signature_text:
public HashJoinDataSet hashJoin(HashTable hashTable, String leftJoinKeyField, String[] hashTableSelectFields)

comment:
将DataSet与HashTable进行hashjoin
@param `hashTable` HashTable
@param `leftJoinKeyField` join字段
@param `hashTableSelectFields` 选取HashTable中需返回的字段
@return kd.bos.algo.HashJoinDataSet


class_name: kd.bos.algo.DataSet
method_name: hashJoin
param_types_key: HashTable,String,String[],boolean
signature_text:
public HashJoinDataSet hashJoin(HashTable hashTable, String leftJoinKeyField, String[] hashTableSelectFields, boolean includeNotExist)

comment:
将DataSet与HashTable进行hashjoin
@param `hashTable` HashTable
@param `leftJoinKeyField` join字段
@param `hashTableSelectFields` 选取HashTable中需返回的字段
@param `includeNotExist` :` 类似left join,是否要包含数据不存在的行
@return kd.bos.algo.HashJoinDataSet


class_name: kd.bos.algo.DataSet
method_name: join
param_types_key: DataSet,JoinHint
signature_text: public JoinDataSet join(DataSet rightDataSet, JoinHint hint)
comment:
默认进行innerjoin ,可以指定join方式
@param `rightDataSet` join的另外一个结果集
@param `hint` kd.bos.algo.JoinHint Join的提示，可设置一些优化信息
@return JoinDataSet kd.bos.algo.JoinDataSet


class_name: kd.bos.algo.DataSet
method_name: join
param_types_key: DataSet,JoinType
signature_text: public JoinDataSet join(DataSet rightDataSet, JoinType type)
comment:
可以指定Join类型是left join还是right join
@param `rightDataSet` join的另外一个结果集
@param `type` kd.bos.algo.JoinType Join的类型
@return JoinDataSet kd.bos.algo.JoinDataSet


class_name: kd.bos.algo.DataSet
method_name: join
param_types_key: DataSet,JoinType,JoinHint
signature_text: public JoinDataSet join(DataSet rightDataSet, JoinType type, JoinHint hint)
comment:
可以指定join方式以及join类型
@param `rightDataSet` join的另外一个结果集
@param `type` kd.bos.algo.JoinType Join的类型
@param `hint` kd.bos.algo.JoinHint Join的提示，可设置一些优化信息
@return JoinDataSet kd.bos.algo.JoinDataSet


class_name: kd.bos.algo.DataSet
method_name: leftJoin
param_types_key: DataSet,JoinHint
signature_text: public default JoinDataSet leftJoin(DataSet rightDataSet, JoinHint hint)
comment:
指定join方式的左连接
@param `rightDataSet` join的另外一个结果集
@param `hint` kd.bos.algo.JoinHint Join的提示，可设置一些优化信息
@return JoinDataSet kd.bos.algo.JoinDataSet


class_name: kd.bos.algo.DataSet
method_name: rightJoin
param_types_key: DataSet,JoinHint
signature_text: public default JoinDataSet rightJoin(DataSet rightDataSet, JoinHint hint)
comment:
指定join方式的右连接
@param `rightDataSet` join的另外一个结果集
@param `hint` kd.bos.algo.JoinHint Join的提示，可设置一些优化信息
@return JoinDataSet kd.bos.algo.JoinDataSet


class_name: kd.bos.algo.DataSet
method_name: select
param_types_key: String[]
signature_text: public DataSet select(String[] exprs)
comment:
expr支持基本四则运算，包括：+,-,*,/,() 支持常量数字，字符串 支持逻辑表达式： <,>,<=,>=,<>, and, or, xor, not 支持宏: NULL, TRUE, FALSE 语法: field, expr alias，或expr as alias 例子： 1. famount 2. famount as amount 3. famount * 2 as amount, famount + 2 as amount, famount / fqty as amount, famount * fqty as mount, 4. (famount + qty) * 2 as amount 5. famount > fqty as b 6. famount > fqty and fqty > 100 as c 7. null as c, true as c, false as c 8. 100 as amount, 'abc' as name 9. fname + 'abc' as name
@param `exprs` 需要选择的列表达式
@return DataSet


class_name: kd.bos.algo.DataSet
method_name: select
param_types_key: boolean,String[]
signature_text: public DataSet select(boolean distinct, String[] exprs)
comment:
同 select(String... exprs);，提供去重参数。
@param `distinct` 是否需要去重
@param `exprs` 需要选择的列表达式
@return DataSet


class_name: kd.bos.algo.DataSet
method_name: select
param_types_key: String
signature_text: public DataSet select(String expr)
comment:
expr支持基本四则运算，包括：+,-,*,/,() 支持常量数字，字符串 支持逻辑表达式： <,>,<=,>=,<>, and, or, xor, not 支持宏: NULL, TRUE, FALSE 语法: field, expr alias，或expr as alias 例子： 1. famount 2. famount as amount 3. famount * 2 as amount, famount + 2 as amount, famount / fqty as amount, famount * fqty as mount, 4. (famount + qty) * 2 as amount 5. famount > fqty as b 6. famount > fqty and fqty > 100 as c 7. null as c, true as c, false as c 8. 100 as amount, 'abc' as name 9. fname + 'abc' as name
@param `expr` 单个expr或者用逗号隔开的多个expr
@return DataSet


class_name: kd.bos.algo.DataSet
method_name: splitByFilter
param_types_key: String[],boolean
signature_text: public DataSet[] splitByFilter(String[] filterExprs, boolean includeOthers)
comment:
根据过滤条件，每组过滤条件一个dataset，所有不在这些过滤条件的单独作为一个dataset
@param `filterExprs` 过滤条件
@param `includeOthers` 是否返回不在这些条件中的dataset
@return 结果集


class_name: kd.bos.algo.dataset.RowFactory
method_name: createPersistedRow
param_types_key: RowMeta,Object[],boolean
comment: 创建行数据 @param `rowMeta` 元数据信息 @param `values` 转为行的数组值 @param `needConvert` 是否需要进行类型转换
signature_text:
public static kd.bos.algo.dataset.PersistedRow createPersistedRow(RowMeta rowMeta, Object[] values, boolean needConvert)


class_name: kd.bos.algo.DataType
method_name: createBigDecimalType
param_types_key: int
signature_text: public static BigDecimalType createBigDecimalType(int precision)
comment:
TODO: if supported standalone BigDecimalType, dataType==DataType.BigDecimalType is illegal
@param `precision` 数值长度
@return BigDecimalType


class_name: kd.bos.algo.exception.AlgoExceedAllowMaxDataSetsException
method_name: <init>
param_types_key: String,int,int
signature_text:
public AlgoExceedAllowMaxDataSetsException(String message, int currentDataSetCount, int maxDataSetCount)

comment:
构造函数
@param `message` 异常信息
@param `currentDataSetCount` 当前线程有多少dataset
@param `maxDataSetCount` 当前线程最大允许的dataset数量


class_name: kd.bos.algo.exception.AlgoExceedCollectionAllowMaxCellsException
method_name: <init>
param_types_key: String,long,long
comment: 构造函数 @param `message` 异常信息 @param `currentCellsCount` 当前有多少单元格子 @param `maxCellsCount` 最大可写入的单元格
signature_text:
public AlgoExceedCollectionAllowMaxCellsException(String message, long currentCellsCount, long maxCellsCount)


class_name: kd.bos.algo.GroupbyDataSet
method_name: maxP
param_types_key: String,String,String
signature_text: GroupbyDataSet maxP(String expr, String propertyField, String alias)
comment:
用max(expr)计算最大行，然后获取当前行propertyField字段的值，并给其起别名alias
@param `expr` 支持表达式计算
@param `propertyField` 获取该字段的值
@param `alias` 别名


class_name: kd.bos.algo.GroupbyDataSet
method_name: minP
param_types_key: String,String,String
signature_text: GroupbyDataSet minP(String expr, String propertyField, String alias)
comment:
用min(expr)计算最小行，然后获取当前行propertyField字段的值，并给其起别名alias
@param `expr` 计算最大值的字段
@param `propertyField` 获取该字段的值
@param `alias` 别名


class_name: kd.bos.algo.HashJoinDataSet
method_name: addHashTable
param_types_key: HashTable,String,String[]
signature_text:
HashJoinDataSet addHashTable(HashTable hashTable, String leftJoinKeyField, String[] hashTableSelectFields)

comment:
进行hashjoin后，继续添加HashTable形成一个新的HashJoinDataSet。
@param `hashTable` 要添加的HashTable
@param `leftJoinKeyField` 连接的字段
@param `hashTableSelectFields` 需要返回的字段
@return HashJoinDataSet


class_name: kd.bos.algo.HashJoinDataSet
method_name: addHashTable
param_types_key: HashTable,String,String[],boolean
signature_text:
HashJoinDataSet addHashTable(HashTable hashTable, String leftJoinKeyField, String[] hashTableSelectFields, boolean includeNotExist)

comment:
进行hashjoin后，继续添加HashTable形成一个新的HashJoinDataSet。
@param `hashTable` 要添加的HashTable
@param `leftJoinKeyField` 连接的字段
@param `hashTableSelectFields` 需要返回的字段
@param `includeNotExist` :` 类似left join


class_name: kd.bos.algo.input.DbInput
method_name: <init>
param_types_key: String,String,String,Object[],RowMeta
signature_text: public DbInput(String algoKey, String routeKey, String sql, Object[] params, RowMeta rowMeta)
comment:
构造函数
@param `algoKey` 追踪dataset的可以
@param `routeKey` 数据路由key
@param `sql` sql语句
@param `params` sql参数
@param `rowMeta` 元素据


class_name: kd.bos.algo.input.OrmInput
method_name: <init>
param_types_key: String,String,String,QFilter[]
signature_text: public OrmInput(String algoKey, String entityName, String selectFields, QFilter[] filters)
comment:
构造函数
@param `algoKey` 追踪DataSet的key
@param `entityName` 实体名称
@param `selectFields` 查询列名称
@param `filters` 过滤条件


class_name: kd.bos.algo.input.OrmInput
method_name: <init>
param_types_key: String,String,String,QFilter[],Integer
signature_text:
public OrmInput(String algoKey, String entityName, String selectFields, QFilter[] filters, Integer cacheSize)

comment:
构造函数
@param `algoKey` 追踪DataSet的key
@param `entityName` 实体名称
@param `selectFields` 查询列名称
@param `filters` 过滤条件
@param `cacheSize` 查询结果DataSet每次缓存的数据量，用于查询隐私字段的场景


class_name: kd.bos.algo.input.OrmInput
method_name: <init>
param_types_key: String,String,String,QFilter[],RowMeta
signature_text:
public OrmInput(String algoKey, String entityName, String selectFields, QFilter[] filters, RowMeta rowMeta)

comment:
构造函数
@param `algoKey` 追踪DataSet的key
@param `entityName` 实体名称
@param `selectFields` 查询列名称
@param `filters` 过滤条件
@param `rowMeta` 元素据


class_name: kd.bos.algo.input.OrmInput
method_name: <init>
param_types_key: String,String,String,QFilter[],RowMeta,Integer
signature_text:
public OrmInput(String algoKey, String entityName, String selectFields, QFilter[] filters, RowMeta rowMeta, Integer cacheSize)

comment:
构造函数
@param `algoKey` 追踪DataSet的key
@param `entityName` 实体名称
@param `selectFields` 查询列名称
@param `filters` 过滤条件
@param `rowMeta` 元素据
@param `cacheSize` 查询结果DataSet每次缓存的数据量，用于查询隐私字段的场景


class_name: kd.bos.algox.CoGroupFunction
method_name: coGroup
param_types_key: Iterable,Iterable,Collector
signature_text: public abstract void coGroup(Iterable<RowX> iter1, Iterable<RowX> iter2, Collector collector)
comment:
分组协作回调函数
@param `iter1` 左分组数据集，已经按照on中的字段分组好，且iter1和iter2中的分组key一致
@param `iter2` 右分组数据集
@param `collector` collector


class_name: kd.bos.algox.DataSetX
method_name: coGroup
param_types_key: DataSetX,CoGroupFunction
signature_text: public CoGroupDataSetX coGroup(DataSetX dataSet, CoGroupFunction func)
comment:
分组协作
是一种特殊的join，coGroup后必须调用CoGroupDataSetX#on方法，用于确定分组join的key。
@param `dataSet` 需要join的数据集
@param `func` 分组协作函数
@return CoGroupDataSetX


class_name: kd.bos.algox.DataSetX
method_name: filter
param_types_key: String,Map
signature_text: public DataSetX filter(String expr, java.util.Map<String, Object> params)
comment:
过滤数据集： 类似于SQL中的WHERE操作，返回满足条件的列
@param `expr` 带参数的表达式，例如： id > var
@param `params` 参数，例如： var -> 50
@return DataSetX


class_name: kd.bos.algox.DataSetX
method_name: output
param_types_key: Output
signature_text: public void output(Output output)
comment:
任务结果输出
Job必须有Output，运行时Output全部正常结束，Job才结束。
* kd.bos.algo.output.DataSetOutput： 输出为 algo DataSet，在当前 JobSession 中可以获取到，不可跨会话访问
* kd.bos.algo.output.DataSetCacheOutput： 输出为 algo CachedDataSet，通过Algo. getCacheDataSet 获取到， 可跨会话访问
* kd.bos.algo.output.DbOutput： 输出到DB
* kd.bos.algo.output.CustomizedOutput： 自定义Output接口，自己实现
* kd.bos.algo.CustomizedOutput： 打印，用于调试
* kd.bos.algo.output.IgnoreOutput： 忽略输出
@param `output` 输出


class_name: kd.bos.algox.JobSession
method_name: asyncCommit
param_types_key: int,TimeUnit,AlgoXCallBack
signature_text:
public String asyncCommit(int timeout, java.util.concurrent.TimeUnit timeUnit, AlgoXCallBack callback)

comment:
提交异步任务
@param `timeout` 超时时间（同时设置任务提交超时时间及任务运行超时时间）
@param `timeUnit` 超时时间单位
@param `callback` 任务执行完毕后回调接口
@return 任务ID


class_name: kd.bos.algox.JobSession
method_name: asyncCommit
param_types_key: int,TimeUnit,AlgoXCallBack,boolean
signature_text:
public String asyncCommit(int timeout, java.util.concurrent.TimeUnit timeUnit, AlgoXCallBack callback, boolean timeoutAutoCancel)

comment:
提交异步任务
@param `timeout` 超时时间（同时设置任务提交超时时间及任务运行超时时间）
@param `timeUnit` 超时时间单位
@param `callback` 任务执行完毕后回调接口
@param `timeoutAutoCancel` 运行超时自动取消
@return 任务ID


class_name: kd.bos.algox.JobSession
method_name: asyncCommit
param_types_key: int,int,TimeUnit,AlgoXCallBack
signature_text:
public String asyncCommit(int commitTimeout, int runningTimeout, java.util.concurrent.TimeUnit timeUnit, AlgoXCallBack callback)

comment:
提交异步任务
@param `commitTimeout` 任务提交超时时间
@param `runningTimeout` 任务执行超时时间
@param `timeUnit` 超时时间单位
@param `callback` 任务执行完毕后回调接口
@return 任务ID


class_name: kd.bos.algox.JobSession
method_name: asyncCommit
param_types_key: int,int,TimeUnit,AlgoXCallBack,boolean
signature_text:
public String asyncCommit(int commitTimeout, int runningTimeout, java.util.concurrent.TimeUnit timeUnit, AlgoXCallBack callback, boolean timeoutAutoCancel)

comment:
提交异步任务
@param `commitTimeout` 任务提交超时时间
@param `runningTimeout` 任务执行超时时间
@param `timeUnit` 超时时间单位
@param `callback` 任务执行完毕后回调接口
@param `timeoutAutoCancel` 运行超时自动取消
@return 任务ID


class_name: kd.bos.algox.JobSession
method_name: cancel
param_types_key: String,int,TimeUnit
signature_text:
public void cancel(String jobId, int cancelTimeout, java.util.concurrent.TimeUnit timeUnit) throws CancelTimeoutException

comment:
取消任务
@param `jobId` jobId
@param `cancelTimeout` 任务取消超时时间
@param `timeUnit` 超时时间单位
@throws `CancelTimeoutException` 任务取消超时异常


class_name: kd.bos.algox.JobSession
method_name: commit
param_types_key: int,TimeUnit
signature_text:
public void commit(int timeout, java.util.concurrent.TimeUnit timeUnit) throws CommitTimeoutException, RunningTimeoutException

comment:
提交同步任务
@param `timeout` 超时时间（同时设置任务提交超时时间及任务运行超时时间）
@param `timeUnit` 超时时间的单位
@throws `CommitTimeoutException` 任务提交超时异常
@throws `RunningTimeoutException` 任务运行超时异常


class_name: kd.bos.algox.JobSession
method_name: commit
param_types_key: int,TimeUnit,boolean
signature_text:
public void commit(int timeout, java.util.concurrent.TimeUnit timeUnit, boolean timeoutAutoCancel) throws CommitTimeoutException, RunningTimeoutException

comment:
提交同步任务
@param `timeout` 超时时间（同时设置任务提交超时时间及任务运行超时时间）
@param `timeUnit` 超时时间的单位
@param `timeoutAutoCancel` 运行超时自动取消
@throws `CommitTimeoutException` 任务提交超时异常
@throws `RunningTimeoutException` 任务运行超时异常


class_name: kd.bos.algox.JobSession
method_name: commit
param_types_key: int,int,TimeUnit
signature_text:
public void commit(int commitTimeout, int runningTimeout, java.util.concurrent.TimeUnit timeUnit) throws CommitTimeoutException, RunningTimeoutException

comment:
提交同步任务
@param `commitTimeout` 任务提交超时时间
@param `runningTimeout` 任务执行超时时间
@param `timeUnit` 超时时间单位
@throws `CommitTimeoutException` 任务提交超时异常
@throws `RunningTimeoutException` 任务运行超时异常


class_name: kd.bos.algox.JobSession
method_name: commit
param_types_key: int,int,TimeUnit,boolean
signature_text:
public void commit(int commitTimeout, int runningTimeout, java.util.concurrent.TimeUnit timeUnit, boolean timeoutAutoCancel) throws CommitTimeoutException, RunningTimeoutException

comment:
提交同步任务
@param `commitTimeout` 任务提交超时时间
@param `runningTimeout` 任务执行超时时间
@param `timeUnit` 超时时间单位
@param `timeoutAutoCancel` 运行超时自动取消
@throws `CommitTimeoutException` 任务提交超时异常
@throws `RunningTimeoutException` 任务运行超时异常


class_name: kd.bos.algox.JobSession
method_name: fromInput
param_types_key: Input
signature_text: public DataSetX fromInput(Input input)
comment:
创建数据源
Input用来创建数据源，是Job的源头。常见有以下几种：
* kd.bos.algo.input.OrmInput： ORM查询
* kd.bos.algo.input.DbInput： DB KSQL 查询
* kd.bos.algo.input.DataSetInput： 将Algo DataSet作为Input
* kd.bos.algo.input.CollectionInput： 集合对象
* kd.bos.algo.CustomizedInput： 抽象类，可自定义取数逻辑
@param `input` 数据源
@return DataSetX


class_name: kd.bos.algox.JobSession
method_name: setRegion
param_types_key: String
signature_text: public void setRegion(String region)
comment:
为任务设置分区标识
推荐所有的任务都设置分区标识，将同一领域或者模块的任务归为同一分区；该设置只有在AlgoX集群配置了分区集群时才会生效。
@param `region` 分区标识，区分大小写，只能是字符及数字


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: addCtrlTableColumns
param_types_key: String,String
signature_text: public boolean addCtrlTableColumns(String dbKey, String tableName)
comment:
给受控资料主表添加特定的字段
* 场景一：模板新增属性，对于历史已经发布的资料，DDL语句无该字段，可以用该接口补全
* 场景二：历史资料新预置数据时，如果无DDL语句更新，则需要业务线先在beforeExecuteSqlWithResult调用，防止预置数据失败
* 场景三：模板新增了属性，对应所有继承模板的历史资料类型，如果需要矫正数据，需要在矫正数据接口中先调用该接口处理新字段不存在的问题
@param `dbKey` 数据库路由标识
@param `tableName` 基础资料主表名称
@return 成功true/false


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: assign
param_types_key: String,Long,String,Set,Set
signature_text:
public BaseDataResponse assign(String entityId, Long assignOrgId, String appId, java.util.Set<Long> dataIds, java.util.Set<Long> orgIds)

comment:
@param `dataIds` 被分配数据ID 分配接口 兼容逐级分配/自由分配、新/旧模型
@param `entityId` 基础资料ID
@param `assignOrgId` 分配组织ID
@param `appId` 基础资料所在应用ID
@param `orgIds` 被分配组织ID


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: assignQueryByData
param_types_key: List,String,Long,String
signature_text:
public AssignQueryResponse assignQueryByData(java.util.List<Long> dataIds, String entity, Long orgId, String appId)

comment:
分配查询，查询对应的数据都分配给了哪些组织
@param `dataIds` 数据id集合，orgId能使用的数据
@param `entity` 受控资料实体
@param `orgId` 当前执行分配查询的组织，是数据dataIds的使用组织
@param `appId` 资料所属应用ID，用于验权
@return 数据分配情况


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: baseDataDeleteHandler
param_types_key: DynamicObject,Long
signature_text: public void baseDataDeleteHandler(DynamicObject dataInfo, Long orgID)
comment:
描述：删除基础数据时基础数据使用登记表处理 删除数据后需要清除该条基础数据的使用关系表和个性化排除表记录；
@param `dataInfo` 删除的基础数据
@param `orgID` 创建组织ID(废弃参数)


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: batchAssign
param_types_key: String,Long,List,List
signature_text:
public java.util.Map<Long, java.util.Map<Long, String>> batchAssign(String entityID, Long assignOrgID, java.util.List<Long> dataIDs, java.util.List<Long> orgIDs)

comment:
批量分配
@param `entityID` 实体标志
@param `assignOrgID` 分配组织ID
@param `dataIDs` 待分配的基础资料ID
@param `orgIDs` 待分配的目标组织ID
@return 检查失败的待分配基础资料及组织信息map,key是基础资料ID，value是目标组织ID集合


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: batchAssignOnFreeStrategy
param_types_key: Long,String,Set,Set,String
signature_text:
public BaseDataResponse batchAssignOnFreeStrategy(Long assignOrgId, String appId, java.util.Set<Long> dataIds, java.util.Set<Long> orgIds, String entity)

comment:
批量分配自助游
@param `assignOrgId` 分配组织ID
@param `appId` 基础资料所在应用ID
@param `dataIds` 被分配数据ID
@param `orgIds` 被分配组织ID
@param `entity` 实体
@return BaseDataResponse 全部校验不通过Success为false，全部成功或者部分成功时为true


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: batchHandleModify
param_types_key: String,Long,List
signature_text:
public java.util.Map<Long, String> batchHandleModify(String entityID, Long orgID, java.util.List<DynamicObject[]> dataList)

comment:
描述：批量个性化后续处理，如维护相关的使用登记表和个性化排除表记录。
@param `entityID` 受控基础资料类型
@param `orgID` 执行批量个性化操作的组织ID
@param `dataList` 批量个性化的受控基础资料列表。列表元素是一个长度为2的DynamicObject数组。其中 DynamicObject[0] 是个性化前的数据，DynamicObject[1] 是个性化后的数据。
@return 批量个性化后续处理失败的基础资料ID和失败原因映射。


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: batchModifyVerify
param_types_key: String,Long,List
signature_text:
public java.util.Map<Long, String> batchModifyVerify(String entityID, Long orgID, java.util.List<DynamicObject> dataList)

comment:
描述：批量个性化前校验。
@param `entityID` 受控基础资料类型
@param `orgID` 执行批量个性化操作的组织ID
@param `dataList` 需要批量个性化的受控基础资料列表
@return 校验失败的基础资料ID和失败原因映射。


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: cancelAssign
param_types_key: String,String,Long,Set,Set
signature_text:
public java.util.List<CancelAssignResult> cancelAssign(String entityId, String appId, Long opOrgId, java.util.Set<Long> dataIds, java.util.Set<Long> orgIds)

comment:
取消分配接口
@param `entityId` 基础资料实体ID
@param `appId` 应用ID
@param `opOrgId` 执行取消分配的操作组织
@param `dataIds` 待取消分配的数据集合
@param `orgIds` 目标组织集合
@return CancelAssignResult 取消分配结果


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: changeCtrlStrategy
param_types_key: String,Set,String,String,Long
signature_text:
public BaseDataResponse changeCtrlStrategy(String entityId, java.util.Set<Long> dataIds, String ctrlStrategy, String appId, Long useOrgId)

comment:
变更控制策略
@param `entityId` 基础资料标识ID
@param `dataIds` 数据ID
@param `ctrlStrategy` 目标控制策略
@param `useOrgId` 使用组织ID
@return BaseDataResponse boolean success 成功/失败 String errorMsg 失败原因


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: changeManageRight
param_types_key: String,Long,String,Set,Long
signature_text:
public BaseDataResponse changeManageRight(String entityId, Long useOrgId, String appId, java.util.Set<Long> dataIds, Long targetOrgId)

comment:
基础资料管理权转让接口
@param `entityId` 基础资料标识
@param `useOrgId` 使用组织
@param `appId` 应用ID
@param `dataIds` 基础资料ID
@param `targetOrgId` 目标组织ID
@return BaseDataResponse 返回实体 success：是否成功 errorMsg：错误信息


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: chectDuplicate
param_types_key: String,Map,Long,Long
signature_text:
public Boolean chectDuplicate(String entityType, java.util.Map<String, String> chectProperties, Long orgID, Long dataID)

comment:
描述：检查基础数据是否存在重复
@param `entityType` 实体类型ID
@param `chectProperties` 检查属性,如 key = NUMBER, value = "A001";key = "name", value = "AAA"
@param `orgID` 使用组织ID
@param `dataID` 基础数据ID
@return Boolean true：有重复；false：没有重复


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: chectDuplicate
param_types_key: String,Long,List
signature_text: public Boolean chectDuplicate(String entityType, Long orgID, java.util.List numberList)
comment:
描述：检查目标组织是否存在相同编码的基础数据
@param `entityType` 实体类型ID
@param `orgID` 使用组织ID
@param `numberList` 基础数据编码列表
@return Boolean true：有重复；false：没有重复


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: executeIndividualizeOnFreeStrategy
param_types_key: String,Long,String,Set,Object
signature_text:
public java.util.Map<Long, String> executeIndividualizeOnFreeStrategy(String entity, Long useOrgId, String appId, java.util.Set<Long> dataIds, Object service)

comment:
自由分配型基础资料个性化接口
@param `entity` 实体标识
@param `useOrgId` 使用组织
@param `appId` 应用ID， 验权使用
@param `dataIds` 基础资料ID
@param `service` 业务自定义控制服务，注意：需要实现IBaseDataCtrlPlugin接口
@return 失败的数据信息，K：数据ID，V：失败原因


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: fillCtrlStrategyFieldAfterCopy
param_types_key: String,List
signature_text: public void fillCtrlStrategyFieldAfterCopy(String entity, java.util.List<DynamicObject> dataList)
comment:
给数据重新生成位图、原位图字段的值
* 使用场景：通过拷贝数据之后不走保存操作，而且直接执行save方法，此时所保存的是数据是无法正常生成管控范围数据信息，需要先执行该方法后save，再重建使用范围数据
@param `entity` 实体
@param `dataList` 数据集合


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getAssignDesOrgs
param_types_key: Long,String,Long
signature_text: public java.util.List<Long> getAssignDesOrgs(Long srcOrgID, String ctrlType, Long orgViewID)
comment:
描述：获取分配目标组织。 1、按当前基础数据的创建组织查找基础数据对应的基础数据管控策略，获取相关参数； 2、当控制策略=按管控单元逐级分配时，从基础数据的管控视图中获取当前组织的直接下级控制单元； 当控制策略=按组织逐级分配时，从基础数据的管控视图中获取当前组织的直接下级组织； 当控制策略=按管控单元自由分配时，从基础数据的管控视图中获取当前组织以外的所有控制单元； 当控制策略=按组织自由分配时，从基础数据的管控视图中获取当前组织以外的所有组织； 3、根据组织在当前基础数据的使用关系表中获取已分配组织； 4、将第2步的数据排除第3步的数据得到待分配组织；
@param `srcOrgID` 分配源组织
@param `ctrlType` 控制类型
@param `orgViewID` 组织视图ID
@return List 分配目标组织


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getAssignUseOrgSet
param_types_key: DynamicObject,Long,Long
signature_text:
public java.util.List<Long> getAssignUseOrgSet(DynamicObject dataInfo, Long orgID, Long createorgId)

comment:
获取可分配的使用组织集合
@param `dataInfo` dataInfo
@param `orgID` orgID
@param `createorgId` createorgId
@return List


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseAccountingInfo
param_types_key: Long
signature_text: public static java.util.Map<String, Long> getBaseAccountingInfo(Long accountOrgID)
comment:
描述：根据业务组织取本位币和汇率表 1、先根据单据返回的主业务组织获取实体核算组织（已提供接口）； 2、再从核算组织本位币设置中获取本位币或汇率表； 3、获取逻辑：优先获取核算组织本身的本位币或汇率表，若没有则往上找上级，直到找到为止；
@param `accountOrgID` 实体核算组织ID


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseDataCreaterOrgFilter
param_types_key: String,Long
signature_text: public QFilter getBaseDataCreaterOrgFilter(String entityID, Long orgID)
comment:
获取基础资料创建组织过滤
@param `entityID` 实体标识
@param `orgID` 组织机构ID
@return QFilter 过滤条件。类似于QFilter(CREATEORG, "in", baseDataCreaterOrgSet)


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseDataFilter
param_types_key: String,Long
signature_text: public QFilter getBaseDataFilter(String entityID, Long orgID)
comment:
获取基础资料ID过滤
@param `entityID` 实体标识
@param `orgID` 组织机构ID
@return QFilter 过滤条件。类似于ctrlstrategy = '5' or fid in(select fdataid from T_BD_BaseData_U where fuseorgid=100000)


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseDataFilter
param_types_key: String,List,boolean
signature_text: public QFilter getBaseDataFilter(String entityID, java.util.List<Long> orgIDs, boolean isRemoveDup)
comment:
获取多个使用组织的基础资料过滤条件
@param `entityID` 实体标识
@param `orgIDs` 组织机构ID
@param `isRemoveDup` 是否去除重复数据，只返回masterid=fid的数据,默认传true
@return QFilter 过滤条件。类似于ctrlstrategy = '5' or fid in(select fdataid from T_BD_BaseData_U where fuseorgid in (100000, 1, 2, 3))


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseDataFilter
param_types_key: Long,String,String,QFilter,boolean
signature_text:
public QFilter getBaseDataFilter(Long userID, String appID, String entityID, QFilter orgQFilter, boolean isRemoveDup)

comment:
获取多个使用组织的基础资料过滤条件，包含基础资料的组织使用范围，以及用户的基础资料数据规则。
@param `userID` 用户ID，用于权限校验
@param `appID` 应用Id，用于权限校验
@param `entityID` 实体标识
@param `orgQFilter` 组织过滤条件，当为空时，表示不限组织
@param `isRemoveDup` 是否去除重复数据，只返回masterid=fid的数据,默认传true
@return QFilter 过滤条件。


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseDataFilterWithOrgIds
param_types_key: Long,String,String,Set,boolean
signature_text:
public QFilter[] getBaseDataFilterWithOrgIds(Long userId, String appId, String entityId, java.util.Set<Long> orgIds, boolean isRemoveDup)

comment:
获取组织可用的受控基础资料数据过滤器
@param `userId` 用户Id
@param `appId` 应用Id
@param `entityId` 基础资料单据标识
@param `orgIds` 组织Id集合
@param `isRemoveDup` 是否去重
@return 组织可用数据过滤条件


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBaseDataProFilter
param_types_key: String,Long,String
signature_text: public QFilter getBaseDataProFilter(String entityID, Long orgID, String property)
comment:
获取基础资料过滤
@param `entityID` 实体标识
@param `orgID` 组织机构ID
@param `property` 过滤属性
@return QFilter 过滤条件。类似于QFilter("id", "in", baseDataIdSet)


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getBdCtrlStrgyBatch
param_types_key: String,List
signature_text:
public java.util.Map<String, String> getBdCtrlStrgyBatch(String entity, java.util.List<Long> createOrgs)


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getExchangeRate
param_types_key: Long,Long,Long,Date
signature_text:
public static java.math.BigDecimal getExchangeRate(Long exchangeTableID, Long sourceCurrencyID, Long targetCurrencyID, java.util.Date date)

comment:
根据汇率表，源币，目标币和日期得到直接汇率 1.当希望得到最新汇率时，则设date为null; 2.当该日期的汇率不存在时，就往前找离该日期最近的生效日期的汇率
@param `exchangeTableID` 汇率表ID
@param `sourceCurrencyID` 源货币ID
@param `targetCurrencyID` 目标货币ID
@param `date` 日期 格式yyyy-MM-dd
@return exchangeRate 汇率


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getExchangeRate
param_types_key: Long,Long,Long,String,Date
signature_text:
public static java.math.BigDecimal getExchangeRate(Long exchangeTableID, Long sourceCurrencyID, Long targetCurrencyID, String convertMode, java.util.Date date)

comment:
根据汇率表，源币，目标币和日期得到汇率 1.当希望得到最新汇率时，则设date为null; 2.当该日期的汇率不存在时，就往前找离该日期最近的生效日期的汇率
@param `exchangeTableID` 汇率表ID
@param `sourceCurrencyID` 源货币ID
@param `targetCurrencyID` 目标货币ID
@param `convertMode` 换算方式 1:直接汇率;2:间接汇率
@param `date` 日期 格式yyyy-MM-dd
@return exchangeRate 汇率


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getFullTextIndex
param_types_key: String
signature_text: public static String getFullTextIndex(String entityNumber)
comment:
描述：根据实体编码获取配置的全文索引，未配置则返回null。
@param `entityNumber` 实体编码
@return fullTextIndex 对应实体配置的全文索引，未配置则返回null;


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getHasCtrlQueryPermOrgIds
param_types_key: Long,String,String
signature_text: public java.util.List<Long> getHasCtrlQueryPermOrgIds(Long userId, String entityId, String appId)
comment:
获取有基础资料查询权限的组织Id集合
@param `entityId` 基础资料单据标识
@param `userId` 用户Id
@param `appId` 应用Id
@return 有查询权的组织Id集合


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getMasterIdFieldName
param_types_key: String
signature_text: public String getMasterIdFieldName(String entityName)
comment:
@param `entityName` 基础资料实体ID
@return String 基础资料masterid对应属性名 获取基础资料配置的masterid字段名 如果没有配置，返回默认的fmasterId


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getMasterIdPropName
param_types_key: String
signature_text: public String getMasterIdPropName(String entityName)
comment:
@param `entityName` 基础资料实体ID
@return String 基础资料masterid对应属性名 获取基础资料配置的masterid属性名 如果没有配置，返回默认的masterid


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getUnInsertExcHistory
param_types_key: String,List
signature_text:
public java.util.List<Object[]> getUnInsertExcHistory(String entityID, java.util.List<Long> uesOrgIDs)

comment:
获取已个性化分配未插入个性化排除表的异常数据
@param `entityID` 受控基础资料类型
@param `uesOrgIDs` 使用组织
@return Object[3]:useorgid,dataid,createorgid(使用组织ID，数据ID,创建组织ID)


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: getWorkCalendar
param_types_key: Long,Date,Date
signature_text: public DynamicObject getWorkCalendar(Long orgId, java.util.Date startDate, java.util.Date endDate)
comment:
描述：获取指定组织,开始日期，结束日期的工作日历。
@param `orgId` 组织机构
@param `startDate` 开始日期
@param `endDate` 结束日期
@return DynamicObject 工作日历


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: handleBatchDisable
param_types_key: String,List,List
signature_text:
public void handleBatchDisable(String entityID, java.util.List<Object> orgIds, java.util.List<Object> masterIds)

comment:
描述：批量处理禁用基础资料时相关处理。
@param `entityID` 实体标识
@param `orgIds` 禁用基础资料组织范围ID集合
@param `masterIds` 待禁用的基础数据主ID集合


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: individualize
param_types_key: String,Long,String,Set
signature_text:
public BaseDataResponse individualize(String entityId, Long useOrgId, String appId, java.util.Set<Long> dataIds)

comment:
基础资料个性化接口
@param `entityId` 基础资料ID
@param `useOrgId` 使用组织
@param `appId` 应用ID
@param `dataIds` 基础资料ID
@return BaseDataResponse 返回实体 success：是否成功 errorMsg：错误信息


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: isAlreadyAssign
param_types_key: String,Object,Long
signature_text: public boolean isAlreadyAssign(String entity, Object pkId, Long useOrgId)
comment:
是否分配的数据
@param `entity` 受控实体
@param `pkId` 数据id
@param `useOrgId` 使用组织
@return 已经分配 true / 未分配 false


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: isDBFulltext
param_types_key: String,String
signature_text: public static Boolean isDBFulltext(String entityNumber, String propertyNumber)
comment:
描述：检查实体的属性是否配置全文索引。
@param `entityNumber` 实体编码
@param `propertyNumber`
@return isDBFulltextProperty 检查属性在实体中已经配置全文索引则返回true,否则返回false;


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: isHasAssignData
param_types_key: String,Object
signature_text: public boolean isHasAssignData(String entityNumber, Object dataID)
comment:
描述：判断基础数据是否被分配过。
@param `entityNumber` 实体标识
@param `dataID` 基础数据ID
@return boolean 如果基础数据被分配过，则返回true,否则返回false.


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: orgAddnewHandler
param_types_key: Long
signature_text: public void orgAddnewHandler(Long orgId)
comment:
1、根据管控视图在基础数据管控策略找到使用该视图的所有基础数据； 2、从某个基础数据的使用关系表中查找使用组织=新增组织所属管控单元并且控制策略=按管控单元逐级分配或按管控单元自由分配的记录； 3、如果找到则在使用关系表中增加新增组织的记录，如果没有则不处理； 4、存在多个基础数据时，按第2，3点逐一处理。
@param `orgId` 组织单元信息对象


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: orgAddnewHandler
param_types_key: Long,List
signature_text: public void orgAddnewHandler(Long orgViewId, java.util.List<Long> orgs)
comment:
1、根据管控视图在基础数据管控策略找到使用该视图的所有基础数据； 2、从某个基础数据的使用关系表中查找使用组织=新增组织所属管控单元并且控制策略=按管控单元逐级分配或按管控单元自由分配的记录； 3、如果找到则在使用关系表中增加新增组织的记录，如果没有则不处理； 4、存在多个基础数据时，按第2，3点逐一处理。
@param `orgViewId` 组织视图ID
@param `orgs` 组织ID


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: presetCtrlOrgUseRangData
param_types_key: String,String,String,Map,boolean
signature_text:
public UpgradeResult presetCtrlOrgUseRangData(String dbKey, String entity, String tableName, java.util.Map<Long, Long> dataOrgMap, boolean isTreeType)

comment:
受控基础资料预置数据自动生成相关使用范围数据
* 1、新模型生成位图值，补充位图数据
* 2、旧模型补充使用范围表的数据
@param `dbKey` 数据库路由标识
@param `entity` 受控资料实体
@param `tableName` 基础资料主表名称
@param `dataOrgMap` 需要预置的数据和组织的信息， K：数据Id，V：创建组织Id
@param `isTreeType` 是否树形基础资料，树形：true， 非树形：false
@return UpgradeResult


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: queryBaseData
param_types_key: String,Long,QFilter,String
signature_text:
public DynamicObjectCollection queryBaseData(String entityID, Long orgID, QFilter filter, String selectFields)

comment:
获取基础资料
@param `entityID` 资料实体
@param `orgID` 组织id
@param `filter` 过滤条件
@param `selectFields` 查询字段
@return 结果


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: queryBaseDataByDate
param_types_key: String,Long,QFilter,String,Date
signature_text:
public DynamicObjectCollection queryBaseDataByDate(String entityID, Long orgID, QFilter filter, String selectFields, java.util.Date queryDate)

comment:
根据查询日期获取基础资料
@param `entityID` 实体标识
@param `orgID` 组织机构ID
@param `filter` 过滤条件
@param `selectFields` 查询字段列表
@param `queryDate` 查询日期
@return dataObj


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: queryBaseDataFromCache
param_types_key: String,Long,QFilter,String
signature_text:
public java.util.Map<Object, DynamicObject> queryBaseDataFromCache(String entityID, Long orgID, QFilter filter, String selectFields)

comment:
从缓存获取基础资料
@param `entityID` 资料实体
@param `orgID` 组织id
@param `filter` 过滤条件
@param `selectFields` 查询字段
@return 组织可以使用的数据信息


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: saveBaseDataExc
param_types_key: String,List,Long,List
signature_text:
public void saveBaseDataExc(String entityID, java.util.List<Long> dataIds, Long createOrgID, java.util.List<Long> orgIds)

comment:
描述：保存基础数据修改化排除表
@param `entityID` 基础资料实体ID
@param `dataIds` 基础数据ID
@param `createOrgID` 创建组织ID
@param `orgIds` 组织ID集合


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: saveBaseDataExc
param_types_key: DynamicObject,Long,Long,List
signature_text:
public void saveBaseDataExc(DynamicObject dataInfo, Long dataPk, Long createOrgID, java.util.List<Long> orgList)

comment:
描述：保存基础数据修改化排除表
@param `dataInfo` 基础数据ID
@param `dataPk` 数据id
@param `createOrgID` 组织ID
@param `orgList` 组织ID集合


class_name: kd.bos.basedata.service.BaseDataServiceImpl
method_name: treeNodeUpdate
param_types_key: Object,Object,GroupProp
signature_text: public boolean treeNodeUpdate(Object currentId, Object newParentId, GroupProp prop)
comment:
用于树形列表更新节点
@param `currentId` ` 当前节点id
@param `newParentId` ` 新的父节点id
@param `prop` ` 分组属性
@return 操作结果


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getAllRelBitMapByEntity
param_types_key: String
comment: 获取所有组织关系位图数据（先从缓存中取） @param `entity` 基础资料实体 @return map 组织 / 组织基础资料使用关系位图
signature_text:
public static java.util.Map<Long, BaseDataUseRelBit> getAllRelBitMapByEntity(String entity) throws Exception


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getAllRelBitMapByEntityFromDb
param_types_key: String
comment: 从数据库中获取所有组织关系位图数据 @param `entity` 基础资料实体 @return map 组织 / 组织基础资料使用关系位图
signature_text:
protected static java.util.Map<Long, BaseDataUseRelBit> getAllRelBitMapByEntityFromDb(String entity)


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getAllUseBitByOrgIds
param_types_key: Collection,String
comment: 获取所有组织的所有位图数据 @param `orgIds` 组织 @param `entity` 实体 @return 位图集合
signature_text:
public static java.util.Set<Integer> getAllUseBitByOrgIds(java.util.Collection<Long> orgIds, String entity)


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getCURelBitMapByEntity
param_types_key: String
comment: 获取CU组织关系位图数据（先从缓存取） @param `entity` 基础资料实体 @return map 组织 / 组织基础资料使用关系位图
signature_text:
public static java.util.Map<Long, BaseDataUseRelBit> getCURelBitMapByEntity(String entity) throws Exception


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getOrgUseRelBitMapByOrgIds
param_types_key: Collection,String
comment: 批量查询组织位图信息 @param `orgIds` 组织id集合 @param `entity` entity @return 组织 -> 数据位图信息 @throws `Exception` e
signature_text:
public static java.util.Map<Long, RoaringBitmap> getOrgUseRelBitMapByOrgIds(java.util.Collection<Long> orgIds, String entity) throws Exception


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getRelBitMapByOrgIds
param_types_key: Collection,String
signature_text:
public static java.util.Map<Long, BaseDataUseRelBit> getRelBitMapByOrgIds(java.util.Collection<Long> orgIds, String entity) throws Exception

comment:
批量查询组织位图信息
@param `orgIds` 组织id集合
@param `entity` entity
@return 组织 -> 数据位图信息
@throws `ExecutionException` e
@throws `InterruptedException` e


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getRelBitMapByOrgIds
param_types_key: Collection,String,String,DBRoute
signature_text:
public static java.util.Map<Long, BaseDataUseRelBit> getRelBitMapByOrgIds(java.util.Collection<Long> orgIds, String entity, String tableName, DBRoute route) throws Exception

comment:
批量查询组织位图信息
@param `orgIds` 组织id集合
@param `entity` 基础资料单据实体
@param `tableName` 位图数据表名
@param `route` 数据库路由
@return 组织 -> 数据位图信息
@throws `Exception` e


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getUseBaseDataIndexArrByOrgId
param_types_key: List,String
comment: 获取特定组织在特定类型的基础资料下所能查询到的基础资料 @param `orgIds` 组织id @param `entityId` 实体 @return 基础资料fbitindex集合
signature_text:
public static int[] getUseBaseDataIndexArrByOrgId(java.util.List<Long> orgIds, String entityId) throws Exception


class_name: kd.bos.bd.engine.BaseDataUseRelQueryEngine
method_name: getUseBaseDataIndexByOrgId
param_types_key: Long,String
comment: 获取特定组织在特定类型的基础资料下所能查询到的基础资料 @param `orgId` 组织id @param `entityId` 实体 @return 基础资料fbitindex集合
signature_text:
public static java.util.List<Integer> getUseBaseDataIndexByOrgId(Long orgId, String entityId) throws Exception


class_name: kd.bos.bd.service.BaseDataCommonService
method_name: isNewModel
param_types_key: String
signature_text: public static boolean isNewModel(String entity)
comment:
受控基础资料是否使用新模型
* 此方法应该使用缓存存储升级状态，但是升级服务是否有升级之后回退的情况，如果有那可能会出现业务不一致性
@param `entity` 受控实体
@return true/false


class_name: kd.bos.bill.AbstractBillWebApiPlugin
method_name: query
param_types_key: String,String,QFilter[],String,int
comment: 查询数据 @param `entityName` @param `selectFields` @param `filters` @param `orderBys` @param `top`
signature_text:
protected DynamicObjectCollection query(String entityName, String selectFields, QFilter[] filters, String orderBys, int top)


class_name: kd.bos.bill.BillShowParameter
method_name: getPermissionItemId
signature_text: public String getPermissionItemId()
comment:
返回打开单据界面时，验权使用的权限项 返回值是自动生成的，规则如下： 1. 单据，未传入pkid，验证新增权； 2. 单据，传入了pkid，如果有定制参数IsCopy，则验证新增权； 3. 单据，传入了pkid，如果编辑状态，验证修改权； 4. 单据，传入了pkid，如果是查看状态，验证查看权；


class_name: kd.bos.bill.BillShowParameter
method_name: setBillStatus
param_types_key: BillOperationStatus
signature_text: public void setBillStatus(BillOperationStatus billStatus)
comment:
设置单据界面状态 和[setStatus](https://docs.oracle.com/javase/8/docs/api/setStatus/package-summary.html)功能有重复和冲突，如两者同时设置，以后者为准
@param `billStatus` 单据界面状态


class_name: kd.bos.bill.BillShowParameter
method_name: setEnableUserReentrant
param_types_key: boolean
signature_text: public void setEnableUserReentrant(boolean enableUserReentrant)
comment:
设置单据是否允许同账号重入 用户打开单据进行编辑后，会申请互斥锁，其他人打开单据会提示冲突，同账号重入也会提示冲突。 设置此选项为true，同账号允许重入，打开单据不会提示冲突
@param `enableUserReentrant` 设置为true，允许同账号重入


class_name: kd.bos.bill.BillShowParameter
method_name: setPermissionEntityId
param_types_key: String
signature_text: public void setPermissionEntityId(String permissionEntityId)
comment:
设置功能验权所用的业务对象实体编码 功能权限默认按单据授权、验权。特殊场景多种单据需共用授权，打开这些单据时，指定验权采用的业务对象实体编码实现共用授权
@param `permissionEntityId` 实体编码


class_name: kd.bos.bill.BillShowParameter
method_name: setRouteKey
param_types_key: String
signature_text: public void setRouteKey(String routeKey)
comment:
设置历史单据归档主路由 历史单据归档后，存储位置发生了变化。要打开已归档的单据，必须指定数据归档主路由及归档分路由 #setArchiveKey(String) 本方法通常在列表打开单据时由系统设置，插件不需关注
@param `routeKey` 数据归档主路由


class_name: kd.bos.botp.ConvertDataService
method_name: loadThirdConvertBills
param_types_key: String,String
signature_text:
public java.util.List<ConvertBill> loadThirdConvertBills(String sourceEntityNumber, String targetEntityNumber)

comment:
加载第三方目标单据信息，用于下推操作
@param `sourceEntityNumber` ：源单单据编码
@param `targetEntityNumber` ：目标单单据编码
@return 可转换的目标单列表


class_name: kd.bos.ca.ICAService
method_name: verifySign
param_types_key: String,String,String,Map
signature_text:
VerifySignResult verifySign(String signData, String plainData, String publicKey, java.util.Map<String, Object> caConfig)

comment:
CA认证服务验签方法。
@param `signData` 签名信息
@param `plainData` 原文信息
@param `publicKey` 证书公钥
@param `caConfig` ca配置信息
@return 验签结果


class_name: kd.bos.cache.CacheFactory
method_name: $getOrCreateLocalMemoryCache
param_types_key: String,String,CacheConfigInfo,EhcacheStoreType
comment: 获取或创建指定存储类型的本地缓存
signature_text:
$getOrCreateLocalMemoryCache(String region, String type, CacheConfigInfo cacheConfig, kd.bos.cache.EhcacheStoreType storeType)


class_name: kd.bos.cache.LocalMemoryCache
method_name: get
param_types_key: String[]
signature_text: public java.util.Map<String, Object> get(String[] keys)
comment:
批量获取多个键对应的缓存值。
返回的 Map 仅包含存在的键值对，未找到的键不会出现在结果中。
@param `keys` 一个或多个缓存键
@return 存在的键值对映射（不会为 ` null`，但可能为空）


class_name: kd.bos.cache.LocalMemoryCache
method_name: put
param_types_key: String,Object
signature_text: public void put(String key, Object value)
comment:
存储键值对到缓存中。
若 ` key` 已存在，则旧值将被 ` value` 覆盖，并重置过期时间（取决于实现策略）。
@param `key` 缓存键，不可为 ` null`，需确保全局唯一性
@param `value` 缓存值，不可为 ` null`，支持任意可序列化对象
@throws `IllegalArgumentException` 若 ` key` 或 ` value` 为 ` null`（由具体实现决定）


class_name: kd.bos.cache.LocalMemoryCache
method_name: removeMapFields
param_types_key: String,String[]
signature_text: public void removeMapFields(String key, String[] fields)
comment:
从缓存中的 Map 结构删除指定字段。
此方法要求 ` key` 对应的值必须为 Map 类型，否则行为取决于实现（可能抛出 ClassCastException 或静默失败）。
@param `key` 缓存中 Map 结构的键
@param `fields` 要删除的 Map 字段，若为空数组则不执行任何操作
@throws `ClassCastException` 若 ` key` 对应的值不是 Map 类型（由具体实现决定）


class_name: kd.bos.cache.tempfile.TempFileCacheDownloadable
method_name: download
param_types_key: HttpServletRequest
signature_text: public kd.bos.cache.tempfile.TempFileCacheDownloadable.Content download(HttpServletRequest request)
comment:
通过HTTP请求下载临时文件
@param `request` HTTP请求对象，需包含configKey/id等必要参数
@return 文件内容封装对象，包含文件流和元数据
@throws `IllegalArgumentException` 当请求参数不完整时抛出


class_name: kd.bos.coderule.api.CodeRuleEntryInfo
method_name: getAttributeType
signature_text: public String getAttributeType()
comment:
获取编码段类型
常量 ：1；业务对象日期：2；业务对象字段：8；系统日期：9；随机码：10；流水号：16；校验码：128
具体参考枚举类：`CodeRuleEntryTypeEnum`
@return 编码段类型


class_name: kd.bos.coderule.api.CodeRuleEntryInfo
method_name: setAttributeType
param_types_key: String
signature_text: public void setAttributeType(String attributeType)
comment:
设置编码段类型
常量 ：1；业务对象日期：2；业务对象字段：8；系统日期：9；随机码：10；流水号：16；校验码：128
具体参考枚举类：`CodeRuleEntryTypeEnum`
@param `attributeType` 编码段类型


class_name: kd.bos.coderule.api.CodeRuleInfo
method_name: getEnableCondition
signature_text: public String getEnableCondition()
comment:
获取启动条件配置
通用过滤控件序列化数据
可通过此方式反序列化使用：`FilterCondition condition = SerializationUtils.fromJsonString(enableCondition, FilterCondition.class)`
@return 启动条件配置


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: getBatchNumber
param_types_key: String,DynamicObject,String,int
signature_text: public String[] getBatchNumber(String entityId, DynamicObject dataInfo, String orgID, int count)
comment:
批量生成编号，会根据指定实体，动态对象信息和受控组织ID，生成编号。
@param `entityId` 实体编码
@param `dataInfo` 数据对象（单据或基础资料，对象上需要具有生成编码的所需信息）
@param `orgID` 受控组织ID，如果没有配置受控组织，传null即可
@param `count` 批量生成编号的个数
@return String[] 编码规则生成的批量编号


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: getCodeRule
param_types_key: String,DynamicObject,String
signature_text: public CodeRuleInfo getCodeRule(String entityId, DynamicObject dataInfo, String orgID)
comment:
获取编码规则配置信息
@param `entityId` 实体编码
@param `dataInfo` 数据对象集合（单据或基础资料，对象上需要具有编码规则配置的所需信息）
@param `orgID` 受控组织ID，如果没有配置受控组织，传null即可


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: getNumber
param_types_key: String,DynamicObject,String
signature_text: public String getNumber(String entityId, DynamicObject dataInfo, String orgId)
comment:
生成编号
会根据指定实体，动态对象信息和受控组织ID，生成编号。
调用后最大号会加1，或者消耗断号记录（当前编码规则流水号段开启“断号补偿”时，才会消耗断号表的记录）
@param `entityId` 实体编码
@param `dataInfo` 数据对象（单据或基础资料，对象上需要具有生成编码的所需信息）
@param `orgId` 受控组织id，为空时默认取动态对象的主业务组织，主业务组织为空时默认取当前用户的组织
@return 编号


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: getNumbers
param_types_key: String,List
signature_text:
default java.util.List<String> getNumbers(String entityId, java.util.List<DynamicObject> dynamicObjects)

comment:
批量生成编号, 根据动态对象集合, 顺序返回对应的编号 (未匹配到的动态对象也会在返回集合中占用一个位置, 值为null)
@param `entityId` 实体编码
@param `dynamicObjects` 动态对象集合（单据或基础资料，对象上需要具有生成编码的所需信息）
@return 返回对应的编号 (按照 dynamicObjects 的顺序)


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: readNumber
param_types_key: String,DynamicObject,String
signature_text: public String readNumber(String entityId, DynamicObject dataInfo, String orgId)
comment:
预读编号
根据指定实体，动态对象信息和受控组织ID，生成编号。调用后最大号不变，断号记录也不会被消耗。
@param `entityId` 实体编码
@param `dataInfo` 数据对象（单据或基础资料，对象上需要具有生成编码的所需信息）
@param `orgId` 受控组织ID，如果没有配置受控组织，传null即可
@return 编号


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: recycleBatchNumber
param_types_key: String,DynamicObject[],String,String[]
signature_text:
public boolean[] recycleBatchNumber(String entityId, DynamicObject[] dataInfo, String orgID, String[] numbers)

comment:
批量回收断号，当删除编号时，可以调用此方法保存断号
@param `entityId` 实体编码
@param `dataInfo` 数据对象集合（单据或基础资料，对象上需要具有回收编码的所需信息） 数据对象集合的顺序要和待回收编号集合numbers顺序一致
@param `orgID` 受控组织ID，如果没有配置受控组织，传null即可
@param `numbers` 待回收的编号集合
@return 是否成功


class_name: kd.bos.coderule.api.ICodeRuleService
method_name: recycleNumber
param_types_key: String,DynamicObject,String,String
signature_text: public boolean recycleNumber(String entityId, DynamicObject dataInfo, String orgID, String number)
comment:
回收断号，当删除编号时，可以调用此方法保存断号
@param `entityId` 实体编码
@param `dataInfo` 数据对象（单据或基础资料，对象上需要具有回收编码的所需信息）
@param `orgID` 受控组织ID，如果没有配置受控组织，传null即可
@param `number` 待回收的编号
@return 是否成功


class_name: kd.bos.context.RequestContextCreator
method_name: create
param_types_key: HttpServletRequest,String,SessionInfo
signature_text:
public static void create(HttpServletRequest request, String globalSessionId, kd.bos.session.SessionInfo sessionInfo)

comment:
根据用户会话信息创建请求上下文
@param `request` servlet容器的request对象
@param `globalSessionId` 全局会话id
@param `sessionInfo` 用户会话信息


class_name: kd.bos.context.RequestContextCreator
method_name: create
param_types_key: HttpServletRequest,String,SessionInfo,boolean
signature_text:
public static void create(HttpServletRequest request, String globalSessionId, kd.bos.session.SessionInfo sessionInfo, boolean isRefreshSession)

comment:
创建上下文
@param `request` servlet容器的请求对象
@param `globalSessionId` 全局会话id
@param `sessionInfo` 用户会话信息
@param `isRefreshSession` 是否刷新session


class_name: kd.bos.context.RequestContextCreator
method_name: createBatch
param_types_key: String,String,String
signature_text: public static void createBatch(String tenantId, String accountId, String userId)
comment:
创建userAgent=Schedule，client=batch的请求上下文
@param `tenantId` 租户id
@param `accountId` 账套id
@param `userId` 用户id


class_name: kd.bos.context.RequestContextCreator
method_name: createBatch
param_types_key: String,String,String,long,Lang
signature_text:
public static void createBatch(String tenantId, String accountId, String userId, long orgId, Lang lang)

comment:
创建userAgent=Schedule，client=batch的请求上下文
@param `tenantId` 租户id
@param `accountId` 账套id
@param `userId` 用户id
@param `orgId` 组织id
@param `lang` 语种


class_name: kd.bos.context.RequestContextCreator
method_name: createBatch
param_types_key: String,String,String,long,Lang,boolean
signature_text:
public static void createBatch(String tenantId, String accountId, String userId, long orgId, Lang lang, boolean cacheGlSessionId)

comment:
创建userAgent=Schedule，client=batch的请求上下文
@param `tenantId` 租户id
@param `accountId` 账套id
@param `userId` 用户id
@param `orgId` 组织id
@param `lang` 语种
@param `cacheGlSessionId` 是否缓存会话信息


class_name: kd.bos.context.RequestContextCreator
method_name: createFor3RDMQ
param_types_key: String,String,String,Lang
signature_text: public static void createFor3RDMQ(String tenantId, String accountId, String userId, Lang lang)
comment:
第三方的MQ集成，需要在后台创建上下文对象 注意的地方：使用时，只有traceId，globalSessionId，和传入的3个参数是可靠可用的
@param `tenantId` 租户id
@param `accountId` 账套id
@param `userId` 用户id
@param `lang` 语种


class_name: kd.bos.context.RequestContextCreator
method_name: createForOnlySesssion
param_types_key: String,SessionInfo,String
signature_text:
public static void createForOnlySesssion(String globalSessionId, kd.bos.session.SessionInfo sessionInfo, String client)

comment:
创建符合当前session的上下文，目前仅给Mutex删除使用
@param `globalSessionId` 全局会话id
@param `sessionInfo` 会话信息
@param `client` 客户端


class_name: kd.bos.dataentity.entity.DataEntityState
method_name: isBizChanged
signature_text: public final boolean isBizChanged()
comment:
实体在填写完默认值之后，有没有改动过字段值 同方法#isChanged 实体数据包在创建后，可能会自动创建一些空行，并填写属性默认值，保存时需要删除掉 填写属性默认值时，会记录脏标志位，因此不能通过脏标志位判断空行 本标志也会监控值变化，并在填写完默认值之后，重置为false，只记录非默认值的改动 特别说明： _bizChanged按属性对象的序号记录对应属性有没有被改变；第0位特殊，特别用来代表的是否下推生成,因此判断字段值有没有被改变过，需要跳过第0位


class_name: kd.bos.dataentity.entity.DynamicObject
method_name: getBigDecimal
param_types_key: String,boolean
signature_text: public java.math.BigDecimal getBigDecimal(String propertyName, boolean enableNull)
comment:
获取下级属性值，把值转为BigDecimal类型返回
@param `propertyName` 属性名称
@param `enableNull` 是否允许为空
@return BigDecimal对象


class_name: kd.bos.dataentity.entity.DynamicObjectCollection
method_name: <init>
param_types_key: DynamicObjectType,Object,List
signature_text:
public DynamicObjectCollection(DynamicObjectType dynamicItemPropertyType, Object parent, java.util.List<DynamicObject> list)

comment:
构造函数：创建动态实体对象集合实例
@param `dynamicItemPropertyType` 集合关联的明细类型
@param `parent` 指定此集合的父对象。
@param `list` 默认的内部集合实例。


class_name: kd.bos.dataentity.entity.IDataCacheControl
method_name: isCache
signature_text: boolean isCache()
comment:
用于确定在加载数据时是否缓存，来提升性能 如果需要修改这一行为，可以在具体实现类中重写此方法，目前只有基础资料实体有重写此方法
@return boolean true：缓存数据，false：不缓存数据


class_name: kd.bos.dataentity.entity.LocaleDynamicObjectCollection
method_name: createLocaleValue
param_types_key: LocaleDynamicObjectCollection,DynamicSimpleProperty
comment: 创建Orm专用多语言文本字段值对象 @param `col` 多语言分录特定的数据行集合 @param `inLocaleProperty` 属性对象
signature_text:
public static Object createLocaleValue(LocaleDynamicObjectCollection col, DynamicSimpleProperty inLocaleProperty)


class_name: kd.bos.dataentity.entity.LocaleDynamicObjectCollection
method_name: setValue
param_types_key: IDataEntityProperty,String,Object
signature_text: public void setValue(IDataEntityProperty inLocalProperty, String localeId, Object newValue)
comment:
设置某个国家语言的值，当这个国家语言的行不存在时，会自动创建行
@param `inLocalProperty`
@param `localeId` 语言代码
@param `newValue` 新值


class_name: kd.bos.dataentity.entity.LocaleValue
method_name: setResourceProvider
param_types_key: IMetadataResourceProvider
signature_text:
public void setResourceProvider(kd.bos.dataentity.entity.IMetadataResourceProvider resourceProvider)


class_name: kd.bos.dataentity.entity.MulBasedataDynamicObjectCollection
method_name: <init>
param_types_key: DynamicObjectType,Object,List
comment: 构造函数 @param `dynamicItemPropertyType` 动态实体类型 @param `parent` 指定此集合的父对象 @param `list` 默认的内部集合实例
signature_text:
public MulBasedataDynamicObjectCollection(DynamicObjectType dynamicItemPropertyType, Object parent, java.util.List<DynamicObject> list)


class_name: kd.bos.dataentity.entity.ObjectConverter
method_name: convert
param_types_key: Object,Class,boolean
signature_text: public static Object convert(Object value, Class<T> cls, boolean enableNull)
comment:
转换原始对象为目标类型 ， 若找不到转换器会返回原始对象
@param `value` 原对象
@param `cls` 目标类型
@param `enableNull` 不转换null对象
@return 目标类型对象


class_name: kd.bos.dataentity.entity.SimplePropertyAttribute
method_name: tableGroup
signature_text: public String tableGroup()
comment:
返回/设置此字段存储的扩展表后缀 当我们的业务设计的越来越多时，会出现一个表有太多的字段，这个时候可以利用ORM提供的扩展表功能。 例如你在某个简单属性上标示TableGroup='Ex‘，那么此简单属性将存储在 table_Ex 这张表中(table是原始表的名称），此扩展表和原始表具有 1..1 的关系。 目前仅支持标记在简单属性上，还不支持复杂属性，因为这样会造成命名的复杂性


class_name: kd.bos.dataentity.exception.SerializationException
method_name: <init>
param_types_key: String,String,SerializationExceptionData
comment: ORM运行时异常类 @param `code` 异常编号 @param `message` 异常信息 @param `data` 序列化出错时的异常数据
signature_text:
public SerializationException(String code, String message, kd.bos.dataentity.exception.SerializationException.SerializationExceptionData data)


class_name: kd.bos.dataentity.exception.SerializationException
method_name: <init>
param_types_key: String,String,SerializationExceptionData,RuntimeException
signature_text:
public SerializationException(String code, String message, kd.bos.dataentity.exception.SerializationException.SerializationExceptionData data, RuntimeException inner)

comment:
通过传入异常消息和原始异常 实例化 异常对象
@param `code` 异常编号
@param `message` 异常消息
@param `data` 序列化出错时的异常数据
@param `inner` 原始异常


class_name: kd.bos.dataentity.exception.SerializationException
method_name: getExceptionData
comment: 返回异常的相关信息 @return SerializationExceptionData
signature_text:
public final kd.bos.dataentity.exception.SerializationException.SerializationExceptionData getExceptionData()


class_name: kd.bos.dataentity.message.PushMessage
method_name: <init>
param_types_key: PushMessageRange,String,Object
signature_text: public PushMessage(PushMessageRange range, String to, Object body)
comment:
构造向前端推送的消息
@param `range` 推送消息的范围（页面，会话，租户，全局） PushMessageRange
@param `to` 消息去向（页面ID，会话ID，租户ID）
@param `body` 推送消息体


class_name: kd.bos.dataentity.message.PushMessage
method_name: <init>
param_types_key: String,PushMessageRange,PushMessageType,String,String,ZonedDateTime,Map,Object
signature_text:
public PushMessage(String id, PushMessageRange range, PushMessageType type, String from, String to, java.time.ZonedDateTime createTime, java.util.Map<String, String> properties, Object body)

comment:
构造向前端推送的消息
@param `id` 对应推送消息的id
@param `range` 推送消息的范围（页面，会话，租户，全局） PushMessage
@param `type` 推送消息类型（表单指令，更新指令*） PushMessageType
@param `from` 消息来源
@param `to` 消息去向（页面ID，会话ID，租户ID）
@param `createTime` 推送消息生成时间
@param `properties` 推送消息属性
@param `body` 推送消息体


class_name: kd.bos.dataentity.metadata.clr.DataEntityPropertyCollection
method_name: getCollectionProperties
param_types_key: boolean
signature_text: public java.util.List<ICollectionProperty> getCollectionProperties(boolean onlyDbProperty)
comment:
返回属性集合中所有的集合属性
@param `properties` ` 实体的属性集合
@param `onlyDbProperty` ` 是否仅仅包含数据库中定义的属性
@return 被检测的属性列表


class_name: kd.bos.dataentity.metadata.clr.DataEntityPropertyCollection
method_name: getComplexProperties
param_types_key: boolean
signature_text: public java.util.List<IComplexProperty> getComplexProperties(boolean onlyDbProperty)
comment:
返回属性集合中所有的复杂属性
@param `properties` ` 实体的属性集合
@param `onlyDbProperty` ` 是否仅仅包含数据库中定义的属性
@return 被检测的属性列表


class_name: kd.bos.dataentity.metadata.clr.DataEntityPropertyCollection
method_name: getSimpleProperties
param_types_key: boolean
signature_text: public java.util.List<ISimpleProperty> getSimpleProperties(boolean onlyDbProperty)
comment:
返回属性集合中所有的简单属性
@param `properties` ` 实体的属性集合
@param `onlyDbProperty` ` 是否仅仅包含数据库中定义的属性
@return 被检测的属性列表


class_name: kd.bos.dataentity.metadata.clr.DataEntityType
method_name: getDirtyProperties
param_types_key: Object,boolean
signature_text:
public final java.util.List<IDataEntityProperty> getDirtyProperties(Object dataEntity, boolean includehasDefualt)


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicCollectionProperty
method_name: <init>
param_types_key: String,DynamicObjectType
signature_text: public DynamicCollectionProperty(String name, DynamicObjectType dynamicItemPropertyType)
comment:
动态集合属性构造函数
@param `name` ` 属性名称
@param `propertyType` ` 属性类型
@param `dynamicItemPropertyType` ` 属性动态实体属性类型
@param `attributes` ` 扩展属性


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicCollectionProperty
method_name: <init>
param_types_key: String,DynamicObjectType,Class
signature_text:
public DynamicCollectionProperty(String name, DynamicObjectType dynamicItemPropertyType, Class<?> collectionType)

comment:
动态集合属性构造函数,用于将强类型对象转为DynamicCollectionProperty对象
@param `name` ` 属性名称
@param `dynamicItemPropertyType` ` 属性动态实体属性类型
@param `collectionType` ` 强类型


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicComplexProperty
method_name: <init>
param_types_key: String,String,DynamicObjectType,boolean
signature_text:
public DynamicComplexProperty(String name, String refIdPropertyName, DynamicObjectType dynamicPropertyType, boolean isReadonly)

comment:
@param `name`
@param `dynamicPropertyType` ` 动态实体属性类型
@param `attributes` ` 扩展属性
@param `isReadonly` ` 是否只读


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType
method_name: <init>
param_types_key: String
signature_text: public DynamicObjectType(String name)
comment:
动态实体类型定义类,ORM所有的实体类型最终都会转化为动态类型,所不同的只是各个实体的字段属性不一样 通过统一的动态类型,可以实现多个元数据模型统一基类,是平台动态编程、客户自定义开发可扩展的基础.
// 构建一个订单DynamicObjectTypesaleOrderType=newDynamicObjectType("SaleOrder");
// 定义SaleOrderID属性，并设置为主键
saleOrderType.registerSimpleProperty("SaleOrderID", typeof(int), 0, false, newSimplePropertyAttribute(true));
// 单据日期
saleOrderType.registerSimpleProperty("SheetDate", typeof(DateTime));
//创建实例DynamicObjectobj=newDynamicObject(saleOrderType);
//访问值
SaleOrderIDProperty.getValue(obj);
//设置值
SaleOrderIDProperty.setValue(obj, 99);
//继承,动态类型可以通过参数baseType实现继承DynamicObjectTypemyOrderType=newDynamicObjectType("SaleOrder",saleOrderType);
@param `name` ` 动态实体类型名称


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType
method_name: getDirtyProperties
param_types_key: Object,boolean
comment: 获取实体脏属性 @param `dataEntity` @param `includehasDefualt`
signature_text:
public java.util.List<IDataEntityProperty> getDirtyProperties(Object dataEntity, boolean includehasDefualt)


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType
method_name: registerCollectionProperty
param_types_key: DynamicCollectionProperty
signature_text:
public final DynamicCollectionProperty registerCollectionProperty(DynamicCollectionProperty property)

comment:
注册一个集合属性 集合属性和复杂属性一样也是指向另外一个实体类型的引用，所不同的是集合属性表达主表与明细表的关系时候使用。 在数据库中，集合属性会保存在明细表中，为一对多的关系。主实体与集合属性的关联主键使用主实体的主键，即要求明细表的外键名字和主表主键名字相同。 如系统中的订单主表及明细表分录即使用集合属性来表示
//构建一个订单DynamicObjectTypesaleOrderType=newDynamicObjectType("SaleOrder");
//定义SaleOrderID属性，并设置为主键
saleOrderType.RegisterSimpleProperty("SaleOrderID", typeof(int), 0, false, newSimplePropertyAttribute(true));
//定义单据明细DynamicObjectTypesaleOrderItemType=newDynamicObjectType("SaleOrderItem");
saleOrderItemType.RegisterSimpleProperty("SaleOrderItemID", typeof(int), 0, false, newSimplePropertyAttribute(true));
//产品
saleOrderItemType.RegisterSimpleProperty("ProductID", typeof(int));
//注册集合属性DynamicPropertyItemsProperty= saleOrderType.RegisterCollectionProperty("Items", saleOrderItemType);
//集合属性的读取和设置  DynamicObjectobj=newDynamicObject(saleOrderType);
//添加数据 IListlist= (IList)ItemsProperty.GetValue(people);  //取得分录集合
list.Add(ItemsProperty.CollectionItemPropertyType.CreateInstance()); //集合操作，添加数据objectaItem= list[0];
IDataEntityTypeaItemType= aItem.CollectionItemPropertyType;  //取到第一个分录
((ISimpleProperty)aItemType.Properties["ProductID"]).SetValue(items[0], 2);  //赋值
@param `name` ` 属性的名称
@param `itemDataEntityType` ` 集合中元素的类型
@param `collectionType` ` 集合本省的属性类型，默认是typeof(DynamicObjectCollection)
@param `attributes` ` 自定义标记集合
@return 新定义的属性


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType
method_name: registerComplexProperty
param_types_key: DynamicComplexProperty
signature_text: public final DynamicComplexProperty registerComplexProperty(DynamicComplexProperty property)
comment:
注册一个复杂属性 复杂属性指向另外一个实体类型的引用，以一个属性保存一个整体段信息。 如系统中常用的中繁英文三个字段则可整体定义为复杂属性，整个系统可共用这个类型。 注意的是数据库中复杂属性字段与主字段在同一个表中，对于保存到另一表中的情况，使用引用属性ReferenceAttribute.
//构建一个订单DynamicObjectTypesaleOrderType=newDynamicObjectType("SaleOrder");
// 定义SaleOrderID属性，并设置为主键
saleOrderType.registerSimpleProperty("SaleOrderID", typeof(int), 0, false, newSimplePropertyAttribute(true));
//注册复杂属性DynamicObjectTypecpxType=newDynamicObjectType("CPX");
DynamicPropertyTelProperty= cpxType.registerSimpleProperty("Tel", typeof(string));
DynamicPropertycpxProperty= saleOrderType.registerComplexProperty("ComplexProperty", cpxType);
//复杂属性的读取和设置DynamicObjectobj=newDynamicObject(saleOrderType);
DynamicObjectcpxValue= (DynamicObject)cpxProperty.getValue(obj);
TelProperty.setValue(cpxValue, "2008");
@param `name` ` 属性的名称
@param `dataEntityType` ` 注册的复杂属性返回类型
@param `isReadonly` ` 此属性是否只读
@param `attributes` ` 自定义标签集
@return 新定义的属性定义


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType
method_name: registerProperty
param_types_key: String,Class,Object,boolean
signature_text:
public final DynamicProperty registerProperty(String name, Class<?> propertyType, Object defaultValue, boolean isReadonly)

comment:
注册一个普通属性，此属性不参与ORM的分析过程 仅供内部使用，外部请使用RegisterSimpleProperty
@param `name` ` 属性的名称，不能为空
@param `propertyType` ` 属性的返回类型
@param `defaultValue` ` 缺省值，如果未设置，其为返回数据类型的默认值
@param `isReadonly` ` 此属性是否只读
@param `attributes` ` 自定义的标记
@return 新定义的属性对象


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicObjectType
method_name: registerSimpleProperty
param_types_key: DynamicSimpleProperty
signature_text: public final DynamicProperty registerSimpleProperty(DynamicSimpleProperty property)
comment:
注册一个简单属性，此属性参与ORM的处理 简单属性对应数据库中最基本的类型,包括(整型、字符、浮点型、日期等)
//构建一个订单DynamicObjectTypesaleOrderType=newDynamicObjectType("SaleOrder");
//定义SaleOrderID属性，并设置为主键
SaleOrderIDProperty = saleOrderType.registerSimpleProperty("SaleOrderID", typeof(int), 0, false, newSimplePropertyAttribute(true));
//单据日期DynamicPropertySheetDateProperty= saleOrderType.registerProperty("SheetDate", typeof(DateTime),newDateTime(2009,9,1));
//简单属性的读取和设置DynamicObjectobj=newDynamicObject(saleOrderType);
SaleOrderIDProperty.getValue(obj); //缺省值0
SheetDateProperty.getValue(obj); //缺省值
SaleOrderIDProperty.setValue(obj, 99);
)
</pre></code>
`
`
`
@param `name` ` 属性的名称，不能为空
@param `propertyType` ` 属性的返回类型
@param `defaultValue` ` 缺省值，如果未设置，其为返回数据类型的默认值
@param `isReadonly` ` 此属性是否只读
@param `attributes` ` 自定义的标记
@return 新定义的属性对象


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicProperty
method_name: <init>
param_types_key: String,Class,Object,boolean
comment: 仅允许派生类创建实例
signature_text:
protected DynamicProperty(String name, Class<?> propertyType, Object defaultValue, boolean isReadonly)


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicProperty
method_name: isEquals
param_types_key: Object
signature_text: protected boolean isEquals(Object obj)
comment:
判断两个属性描述符，其名称、返回类型及位置等信息，来判断是否相等。
@param `obj` ` 要判断相等的元素
@return 如果两个属性描述符，其名称、返回类型及位置等信息相等，那么属性描述符就相等。


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicProperty
method_name: onPropertyChanged
param_types_key: DynamicObject,Object,Object
signature_text: protected void onPropertyChanged(DynamicObject dataEntity, Object newValue, Object oldValue)
comment:
触发属性的值更新事件，从而触发DynamicObject的值更新事件，用于记录更新脏标志
@param `dataEntity`
@param `newValue`
@param `oldValue`


class_name: kd.bos.dataentity.metadata.dynamicobject.DynamicProperty
method_name: setDTValueFast
param_types_key: DynamicObject,Object
signature_text: public void setDTValueFast(DynamicObject dataEntity, Object newValue)
comment:
设置动态实体的值,在确定dataEntity实体类型和此属性对应实体类型一致时采用此方法
@param `dataEntity` ` 要设置的动态实体实例
@param `newValue` ` 此属性新的值


class_name: kd.bos.dataentity.metadata.dynamicobject.ExtractOption
method_name: register
param_types_key: String,String[]
signature_text: public void register(String dtName, String[] properties)
comment:
注册提取的属性信息。包括实体类型名称及你需要提取的属性列表
@param `dtName` ` 要提取的实体类型名称，比如你可以定义明细名称
@param `properties` ` 要提取的属性列表，要提取明细的数据也需要包括在内


class_name: kd.bos.dataentity.metadata.IComplexProperty
method_name: getDataEntityWalkerItems
param_types_key: List
comment: 获取字段类型与值的映射 @param `dataEntities`
signature_text:
default java.util.Map<Tuple<IComplexProperty , IDataEntityType, java.util.List<Object>> getDataEntityWalkerItems(java.util.List<Object> dataEntities)


class_name: kd.bos.dataentity.metadata.IDataEntityProperty
method_name: getValueFast
param_types_key: Object
signature_text: Object getValueFast(Object dataEntity)
comment:
给定一个实体，快速读取此属性描述符在此实体的值，在确定dataEntity实体类型和此属性对应实体类型一致时采用此方法
@param `dataEntity` ` 要读取属性值的实体实例，不能为空
@return 最后取得的值


class_name: kd.bos.dataentity.metadata.IDataEntityProperty
method_name: setValueFast
param_types_key: Object,Object
signature_text: void setValueFast(Object dataEntity, Object value)
comment:
给定一个实体，为给定实体的属性填充指定的值，在确定dataEntity实体类型和此属性对应实体类型一致时采用此方法
@param `dataEntity` ` 要设置值得实体对象
@param `value` ` 新的值


class_name: kd.bos.dataentity.metadata.IDataEntityType
method_name: isDirty
param_types_key: Object
signature_text: boolean isDirty(Object dataEntity)
comment:
返回某个实体数据是否已经发生了变更
@param `dataEntity` ` 要检查的实体对象
@return 如果当前实体发生了变更将返回ture，否则返回false。注意这里不判断复杂属性和集合属性的变更


class_name: kd.bos.dataentity.OperateOption
method_name: getVariableValue
param_types_key: String,String
signature_text: public String getVariableValue(String name, String defaultValue)
comment:
从选项中获取定义的值
@param `name` 选项的键，不区分大小写
@param `defaultValue` 如果没有找到选项定义，其缺省值是多少
@return 如果有定义，返回定义的值，否则返回缺省值


class_name: kd.bos.dataentity.resource.ResManager
method_name: getLocaleString
param_types_key: String,String,String
signature_text:
public static LocaleString getLocaleString(String description, String resourceID, String systemType)

comment:
根据资源ID获取LocaleString信息对象。
@param `description` 描述字符串
@param `resourceID` 资源ID
@param `systemType` 资源文件
@return LocaleStringLocaleString


class_name: kd.bos.dataentity.resource.ResManager
method_name: loadKDString
param_types_key: String,String,String,Object[]
signature_text:
public static String loadKDString(String description, String resourceID, String systemType, Object[] args)

comment:
加载多语言字符
@param `description` 描述字符串
@param `resourceID` 资源ID
@param `systemType` 资源文件
@param `args` 参数列表


class_name: kd.bos.dataentity.resource.ResManager
method_name: loadKDString
param_types_key: Lang,String,String,String,Object[]
signature_text:
public static String loadKDString(Lang lang, String description, String resourceID, String systemType, Object[] args)

comment:
加载多语言字符
@param `lang` 语种
@param `description` 描述字符串
@param `resourceID` 资源ID
@param `systemType` 资源文件
@param `args` 参数列表


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: convertDataEntityToMap
param_types_key: Object,DataEntitySerializerOption
comment: 根据序列化参数将数据包序列化成Map @param `dataEntity` 数据包 @param `option` DataEntitySerializerOption 序列化参数
signature_text:
public static java.util.Map<String, Object> convertDataEntityToMap(Object dataEntity, DataEntitySerializerOption option)


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: convertMapToDataEntity
param_types_key: IDataEntityType,Map
comment: 将Map反序列化转换成数据包 @param `dt` 实体类型 @param `mapObj` 数据
signature_text:
public static Object convertMapToDataEntity(IDataEntityType dt, java.util.Map<String, Object> mapObj)


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: convertMapToDataEntity
param_types_key: IDataEntityType,Map,DataEntityDeserializerOption
signature_text:
public static Object convertMapToDataEntity(IDataEntityType dt, java.util.Map<String, Object> mapObj, DataEntityDeserializerOption option)

comment:
根据反序列化参数将Map反序列化转换成数据包
@param `dt` 实体类型
@param `mapObj` 数据
@param `option` DataEntityDeserializerOption 反序列化参数


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: deSerializerFromString
param_types_key: String,IDataEntityType,DataEntityDeserializerOption
signature_text:
public static Object deSerializerFromString(String strOrder, IDataEntityType dataEntityType, DataEntityDeserializerOption option)

comment:
根据反序列化参数将String反序列化成数据包
@param `strOrder` 值
@param `dataEntityType` 实体类型
@param `option` DataEntityDeserializerOption 反序列化参数


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: deserializerFromListString
param_types_key: List,IDataEntityType,String[]
comment: 将数组反序列化成数据包集合 @param `cols` 数据集合 @param `dt` 实体类型 @param `strList` 需要反序列的值
signature_text:
public static java.util.List<DynamicObject> deserializerFromListString(java.util.List<DynamicObject> cols, IDataEntityType dt, String[] strList)


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: deserializerFromListString
param_types_key: List,IDataEntityType,String[],DataEntityDeserializerOption
signature_text:
public static java.util.List<DynamicObject> deserializerFromListString(java.util.List<DynamicObject> cols, IDataEntityType dt, String[] strList, DataEntityDeserializerOption option)

comment:
根据反序列化参数将数据反序列成数据包集合
@param `cols` 数据包集合
@param `dt` 实体类型
@param `strList` 需要反序列的值
@param `option` DataEntityDeserializerOption 反序列化参数


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: deserializerFromListString
param_types_key: IDataEntityType,String,DataEntityDeserializerOption
signature_text:
public static DynamicObject deserializerFromListString(IDataEntityType dt, String strList, DataEntityDeserializerOption option)

comment:
根据反序列化参数将数据反序列成数据包集合
@param `dt` 实体类型
@param `strList` 需要反序列的值
@param `option` DataEntityDeserializerOption 反序列化参数


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: deserializerFromMap
param_types_key: Map,List,IDataEntityType,DataEntityDeserializerOption
comment: 数据包反序列 @param `map` 数据包json @param `cols` 动态对象list @param `dt` 动态对象实体属性 @param `option` 反序列化选项
signature_text:
public static java.util.List<DynamicObject> deserializerFromMap(java.util.Map<String, Object> map, java.util.List<DynamicObject> cols, IDataEntityType dt, DataEntityDeserializerOption option)


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: serializerToListString
param_types_key: IDataEntityType,List,DataEntitySerializerOption
comment: 将数据包序列化成数组 @param `dt` 实体类型 @param `cols` 数据集合 @param `option` DataEntitySerializerOption 序列化参数
signature_text:
public static String[] serializerToListString(IDataEntityType dt, java.util.List<DynamicObject> cols, DataEntitySerializerOption option)


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: serializerToMap
param_types_key: IDataEntityType,List,DataEntitySerializerOption
comment: 将数据包序列化成数组 @param `dt` 实体类型 @param `cols` 数据集合 @param `option` DataEntitySerializerOption 序列化参数
signature_text:
public static java.util.Map<String, Object> serializerToMap(IDataEntityType dt, java.util.List<DynamicObject> cols, DataEntitySerializerOption option)


class_name: kd.bos.dataentity.serialization.DataEntitySerializer
method_name: serializerToString
param_types_key: Object,boolean,boolean
signature_text:
public static String serializerToString(Object dataEntity, boolean includeType, boolean includeComplexProperty)

comment:
将数据包序列化成String
@param `dataEntity` 数据包
@param `includeType` 是否包含实体类型
@param `includeComplexProperty` 是否包含复合属性


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: afterWriteJsonObject
param_types_key: Object,Object,Map
comment: 对象json序列化后事件 @param `currentEntity` 当前实体 @param `baseEntity` 基准实体 @param `serObj` 序列化json
signature_text:
public void afterWriteJsonObject(Object currentEntity, Object baseEntity, java.util.Map<String, Object> serObj)


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: bindEqualsFunc
param_types_key: Class,IBindEqualsFunc
signature_text:
public kd.bos.dataentity.serialization.IBindEqualsFunc bindEqualsFunc(Class<?> dataType, kd.bos.dataentity.serialization.IBindEqualsFunc defaultFunc)

comment:
允许定义个性化的相等判断机制，如果不重载此方法，将使用默认的判断机制。
@param `dataType` ` 要进行相等判断的数据类型。
@param `defaultFunc` ` 缺省的实现。
@return 最终的实现


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: bindJSONReadAction
param_types_key: Class,ISetJsonValueAction
signature_text:
public kd.bos.dataentity.serialization.ISetJsonValueAction bindJSONReadAction(Class<?> dataType, kd.bos.dataentity.serialization.ISetJsonValueAction defaultAction)

comment:
允许定义某个数据类型的读取XML的机制，如果不重载，可以使用默认的读取方式。
@param `dataType` ` 数据类型，每个数据类型可以定义不同的读取行为。
@param `defaultAction` ` 缺省的实现
@return 最终的实现。


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: bindLocaleReadAction
param_types_key: ISetJsonValueAction
comment: 允许定义多语言对象json反序列化读取器。 @param `defaultAction` ` 缺省的实现 @return 最终的实现。
signature_text:
public kd.bos.dataentity.serialization.ISetJsonValueAction bindLocaleReadAction(kd.bos.dataentity.serialization.ISetJsonValueAction defaultAction)


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: bindReadAction
param_types_key: Class,ISetValueAction
signature_text:
protected kd.bos.dataentity.serialization.ISetValueAction bindReadAction(Class<?> dataType, kd.bos.dataentity.serialization.ISetValueAction defaultAction)

comment:
允许定义某个数据类型的读取XML的机制，如果不重载，可以使用默认的读取方式。
@param `dataType` ` 数据类型，每个数据类型可以定义不同的读取行为。
@param `defaultAction` ` 缺省的实现
@return 最终的实现。


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: bindToStringFunc
param_types_key: Class,IBindToStringFunc,RefObject
signature_text:
public kd.bos.dataentity.serialization.IBindToStringFunc bindToStringFunc(Class<?> dataType, kd.bos.dataentity.serialization.IBindToStringFunc defaultFunc, RefObject<Boolean> isCData)

comment:
允许自定义数据类型转换为字符串的机制，如果不重载，将使用默认的行为。
@param `dataType` ` 要转换的数据类型
@param `defaultFunc` ` 缺省的数据转换函数
@param `isCData` ` 是否是CData结构。
@return 最终的实现。


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: createInstance
param_types_key: IDataEntityType
signature_text: public Object createInstance(IDataEntityType dt)
comment:
由Binder创建实例，默认实现是直接调用dt的CreateInstance方法
@param `dt` ` 要创建实例的类型
@return 新的实例 派生类可以重载此方法，例如标记实例创建的时机，或返回他的代理。


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: getConvertFunc
param_types_key: ISimpleProperty,Object,Object,RefObject,IBindToStringFunc
signature_text:
public kd.bos.dataentity.serialization.IBindToStringFunc getConvertFunc(ISimpleProperty property, Object dataEntity, Object value, RefObject<Boolean> isCData, kd.bos.dataentity.serialization.IBindToStringFunc func)

comment:
获取转换函数
@param `property` 属性
@param `dataEntity` 实体
@param `value` 值
@param `isCData` 是否写入CDATA
@param `func` 值转换函数
@return 转换函数


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: tryBindToType
param_types_key: String,Map
signature_text:
public abstract IDataEntityType tryBindToType(String elementName, java.util.Map<String, String> attributes)

comment:
根据节点的名称确定数据类型
@param `elementName` ` 节点的名称
@param `attributes` ` 额外的附属Attribute信息
@param `result` ` 返回数据类型
@return 如果找到返回true，否则返回false


class_name: kd.bos.dataentity.serialization.DcBinder
method_name: writeCustomJsonProperties
param_types_key: Map,Object,Object
comment: 自定义属性数据写入Json @param `serObj` ：Json对象 @param `current` ：当前对象 @param `base` ：基对象
signature_text:
public void writeCustomJsonProperties(java.util.Map<String, Object> serObj, Object current, Object base)


class_name: kd.bos.dataentity.serialization.DcxmlSerializer
method_name: getDiffDesc
param_types_key: String,Object,IDcDescReadPlugin
signature_text:
public final String getDiffDesc(String diffxml, Object baseentity, kd.bos.dataentity.serialization.IDcDescReadPlugin plugin)

comment:
对指定的文本执行反序列化操作
@param `diffxml` 数据来源
@param `baseentity` 如果已经存在一个实体，可以提供给他
@param `plugin` 插件
@return 反序列化后的实体


class_name: kd.bos.dataentity.serialization.DcxmlSerializer
method_name: serializeToString
param_types_key: Object,Object
signature_text: public final String serializeToString(Object currentEntity, Object baseEntity)
comment:
比对当前实体和基础实体的信息，并返回差量化的XML数据。
@param `currentEntity` 当前实体
@param `baseEntity` 基础比对实体。
@return 差量化的XML数据。


class_name: kd.bos.dataentity.serialization.DynamicObjectSerializationBinder
method_name: tryBindToType
param_types_key: String,Map
signature_text: public IDataEntityType tryBindToType(String elementName, java.util.Map<String, String> attributes)
comment:
根据节点的名称确定数据类型
@param `elementName` 节点的名称
@param `attributes` 额外的附属Attribute信息
@param `result` 返回数据类型
@return 如果找到返回true，否则返回false


class_name: kd.bos.dataentity.serialization.IDataEntityBinder
method_name: isSerializProperty
param_types_key: IDataEntityProperty,DataEntitySerializerOption
comment: 是否序列化目标属性 @param `prop` 目标属性 @param `option` 序列化选项
signature_text:
public default boolean isSerializProperty(IDataEntityProperty prop, DataEntitySerializerOption option)


class_name: kd.bos.dataentity.serialization.ListDcxmlBinder
method_name: tryBindToType
param_types_key: String,Map
signature_text: public IDataEntityType tryBindToType(String elementName, java.util.Map<String, String> attributes)
comment:
根据节点的名称确定数据类型
@param `elementName` ` 节点的名称
@param `attributes` ` 额外的附属Attribute信息
@param `result` ` 返回数据类型
@return 如果找到返回IDataEntityType，否则返回空


class_name: kd.bos.dataentity.serialization.SerializationUtils
method_name: toJsonString
param_types_key: Object,boolean,OperateOption
signature_text: public static String toJsonString(Object o, boolean inclusionNON_NULL, OperateOption option)
comment:
将数据序列化输出
@param `o` 待序列化数据
@param `inclusionNON_NULL` 是否包含不允许为null
@param `option` OperateOption 数据的操作提供额外的选项


class_name: kd.bos.dataentity.SqlParameter
method_name: <init>
param_types_key: String,int,Object,ParameterDirection
comment: 有参构造函数
signature_text:
SqlParameter(String name, int columnType, Object value, kd.bos.dataentity.SqlParameter.ParameterDirection direction)


class_name: kd.bos.dataentity.trace.EntityTracer
method_name: throwException
param_types_key: String,String,String,Throwable,Map
signature_text:
public static void throwException(String type, String name, String msg, Throwable e, java.util.Map<String, Object> tags)

comment:
抛出异常，通知监听器开始收集调用链上下文数据，保护异常现场
@param `type` 触发异常的类名
@param `name` 触发异常的方法名
@param `msg` 异常提示
@param `e` 异常对象
@param `tags` 附加信息数组，每个元素为一条附加信息，包括标识+信息对象


class_name: kd.bos.dataentity.trace.EntityTraceSpan
method_name: addLocaleTag
param_types_key: String,Object
signature_text: EntityTraceSpan addLocaleTag(String key, Object value)
comment:
输出本地变量，仅供监听器监听取用 使用addTag方法会向底层apm平台输出信息，会增加apm存储负担； 使用本方法则仅保留在本地，如果没有注册监听器则略过，不输出到apm平台
@param `key` 键
@param `value` 值
@return 返回本对象，以便连续调用addLocaleTag


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: <init>
signature_text: public ArrayUtils()
comment:
ArrayUtils instances should NOT be constructed in standard programming. Instead, the class should be used as `ArrayUtils.clone(new int[] {2})`.
This constructor is public to permit tools that require a JavaBean instance to operate.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: Object[],Object
signature_text: public static Object add(T[] array, T element)
comment:
Copies the given array and adds the given element at the end of the new array.
The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element, unless the element itself is null, in which case the return type is Object[]
ArrayUtils.add(null, null)      = [null[]  ArrayUtils.add(null, "a")       = ["a"]  ArrayUtils.add(["a"], null)     = ["a", null[]  ArrayUtils.add(["a"], "b")      = ["a", "b"]  ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"]
@param `<T>` the component type of the array
@param `array` the array to "add" the element to, may be ` null`
@param `element` the object to add, may be ` null`
@return A new array containing the existing elements plus the new element The returned array type will be that of the input array (unless null), in which case it will have the same type as the element. If both are null, an IllegalArgumentException is thrown
@throws `IllegalArgumentException` if both arguments are null


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: boolean[],boolean
signature_text: public static boolean[] add(boolean[] array, boolean element)
comment:
Copies the given array and adds the given element at the end of the new array.
The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add(null, true)          = [true[]  ArrayUtils.add([true], false)       = [true, false[]  ArrayUtils.add([true, false], true) = [true, false, true]
@param `array` the array to copy and add the element to, may be ` null`
@param `element` the object to add at the last index of the new array
@return A new array containing the existing elements plus the new element


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: byte[],byte
signature_text: public static byte[] add(byte[] array, byte element)
comment:
Copies the given array and adds the given element at the end of the new array.
The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add(null, 0)   = [0]  ArrayUtils.add([1], 0)    = [1, 0]  ArrayUtils.add([1, 0], 1) = [1, 0, 1]
@param `array` the array to copy and add the element to, may be ` null`
@param `element` the object to add at the last index of the new array
@return A new array containing the existing elements plus the new element


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: char[],char
signature_text: public static char[] add(char[] array, char element)
comment:
Copies the given array and adds the given element at the end of the new array.
The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add(null, '0')       = ['0']  ArrayUtils.add(['1'], '0')      = ['1', '0']  ArrayUtils.add(['1', '0'], '1') = ['1', '0', '1']
@param `array` the array to copy and add the element to, may be ` null`
@param `element` the object to add at the last index of the new array
@return A new array containing the existing elements plus the new element


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: Object[],int,Object
signature_text: public static Object add(T[] array, int index, T element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add(null, 0, null)      = [null[]  ArrayUtils.add(null, 0, "a")       = ["a"]  ArrayUtils.add(["a"], 1, null)     = ["a", null[]  ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]  ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
@param `<T>` the component type of the array
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).
@throws `IllegalArgumentException` if both array and element are null


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: boolean[],int,boolean
signature_text: public static boolean[] add(boolean[] array, int index, boolean element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add(null, 0, true)          = [true[]  ArrayUtils.add([true], 0, false)       = [false, true[]  ArrayUtils.add([false], 1, true)       = [false, true[]  ArrayUtils.add([true, false], 1, true) = [true, true, false]
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: char[],int,char
signature_text: public static char[] add(char[] array, int index, char element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add(null, 0, 'a')            = ['a']  ArrayUtils.add(['a'], 0, 'b')           = ['b', 'a']  ArrayUtils.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']  ArrayUtils.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']  ArrayUtils.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: byte[],int,byte
signature_text: public static byte[] add(byte[] array, int index, byte element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add([1], 0, 2)         = [2, 1]  ArrayUtils.add([2, 6], 2, 3)      = [2, 6, 3]  ArrayUtils.add([2, 6], 0, 1)      = [1, 2, 6]  ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: short[],int,short
signature_text: public static short[] add(short[] array, int index, short element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add([1], 0, 2)         = [2, 1]  ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]  ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]  ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: long[],int,long
signature_text: public static long[] add(long[] array, int index, long element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add([1L], 0, 2L)           = [2L, 1L]  ArrayUtils.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]  ArrayUtils.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]  ArrayUtils.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: float[],int,float
signature_text: public static float[] add(float[] array, int index, float element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]  ArrayUtils.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]  ArrayUtils.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]  ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: add
param_types_key: double[],int,double
signature_text: public static double[] add(double[] array, int index, double element)
comment:
Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, a new one element array is returned whose component type is the same as the element.
ArrayUtils.add([1.1], 0, 2.2)              = [2.2, 1.1]  ArrayUtils.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]  ArrayUtils.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]  ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
@param `array` the array to add the element to, may be ` null`
@param `index` the position of the new object
@param `element` the object to add
@return A new array containing the existing elements and the new element
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index > array.length).


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: Object[],Object[]
signature_text: public static Object addAll(T[] array1, T[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(null, null)     = null  ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []  ArrayUtils.addAll([null], [null]) = [null, null[]  ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
@param `<T>` the component type of the array
@param `array1` the first array whose elements are added to the new array, may be ` null`
@param `array2` the second array whose elements are added to the new array, may be ` null`
@return The new array, ` null` if both arrays are ` null`. The type of the new array is the type of the first array, unless the first array is null, in which case the type is the same as the second array.
@throws `IllegalArgumentException` if the array types are incompatible


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: boolean[],boolean[]
signature_text: public static boolean[] addAll(boolean[] array1, boolean[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new boolean[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: char[],char[]
signature_text: public static char[] addAll(char[] array1, char[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new char[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: byte[],byte[]
signature_text: public static byte[] addAll(byte[] array1, byte[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new byte[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: short[],short[]
signature_text: public static short[] addAll(short[] array1, short[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new short[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: int[],int[]
signature_text: public static int[] addAll(int[] array1, int[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new int[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: long[],long[]
signature_text: public static long[] addAll(long[] array1, long[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new long[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: float[],float[]
signature_text: public static float[] addAll(float[] array1, float[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new float[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: addAll
param_types_key: double[],double[]
signature_text: public static double[] addAll(double[] array1, double[] array2)
comment:
Adds all the elements of the given arrays into a new array.
The new array contains all of the element of ` array1` followed by all of the elements ` array2`. When an array is returned, it is always a new array.
ArrayUtils.addAll(array1, null)   = cloned copy of array1  ArrayUtils.addAll(null, array2)   = cloned copy of array2  ArrayUtils.addAll([], [])         = []
@param `array1` the first array whose elements are added to the new array.
@param `array2` the second array whose elements are added to the new array.
@return The new double[] array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: clone
param_types_key: Object[]
signature_text: public static Object clone(T[] array)
comment:
Shallow clones an array returning a typecast result and handling ` null`.
The objects in the array are not cloned, thus there is no special handling for multi-dimensional arrays.
This method returns ` null` for a ` null` input array.
@param `<T>` the component type of the array
@param `array` the array to shallow clone, may be ` null`
@return the cloned array, ` null` if ` null` input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: clone
param_types_key: long[]
signature_text: public static long[] clone(long[] array)
comment:
Clones an array returning a typecast result and handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` the array to clone, may be ` null`
@return the cloned array, ` null` if ` null` input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: contains
param_types_key: Object[],Object
signature_text: public static boolean contains(Object[] array, Object objectToFind)
comment:
Checks if the object is in the given array.
The method returns ` false` if a ` null` array is passed in.
@param `array` the array to search through
@param `objectToFind` the object to find
@return ` true` if the array contains the object


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: contains
param_types_key: long[],long
signature_text: public static boolean contains(long[] array, long valueToFind)
comment:
Checks if the value is in the given array.
The method returns ` false` if a ` null` array is passed in.
@param `array` the array to search through
@param `valueToFind` the value to find
@return ` true` if the array contains the object


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: contains
param_types_key: double[],double,double
signature_text: public static boolean contains(double[] array, double valueToFind, double tolerance)
comment:
Checks if a value falling within the given tolerance is in the given array. If the array contains a value within the inclusive range defined by (value - tolerance) to (value + tolerance).
The method returns ` false` if a ` null` array is passed in.
@param `array` the array to search
@param `valueToFind` the value to find
@param `tolerance` the array contains the tolerance of the search
@return true if value falling within tolerance is in array


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: getLength
param_types_key: Object
signature_text: public static int getLength(Object array)
comment:
Returns the length of the specified array. This method can deal with ` Object` arrays and with primitive arrays.
If the input array is ` null`, ` 0` is returned.
ArrayUtils.getLength(null)            = 0  ArrayUtils.getLength([])              = 0  ArrayUtils.getLength([null])          = 1  ArrayUtils.getLength([true, false])   = 2  ArrayUtils.getLength([1, 2, 3])       = 3  ArrayUtils.getLength(["a", "b", "c"]) = 3
@param `array` the array to retrieve the length from, may be null
@return The length of the array, or ` 0` if the array is ` null`
@throws `IllegalArgumentException` if the object argument is not an array.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: hashCode
param_types_key: Object
signature_text: public static int hashCode(Object array)
comment:
Get a hash code for an array handling multi-dimensional arrays correctly.
Multi-dimensional primitive arrays are also handled correctly by this method.
@param `array` the array to get a hash code for, ` null` returns zero
@return a hash code for the array


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: indexOf
param_types_key: Object[],Object
signature_text: public static int indexOf(Object[] array, Object objectToFind)
comment:
Finds the index of the given object in the array.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
@param `array` the array to search through for the object, may be ` null`
@param `objectToFind` the object to find, may be ` null`
@return the index of the object within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: indexOf
param_types_key: Object[],Object,int
signature_text: public static int indexOf(Object[] array, Object objectToFind, int startIndex)
comment:
Finds the index of the given object in the array starting at the given index.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
A negative startIndex is treated as zero. A startIndex larger than the array length will return #INDEX_NOT_FOUND (` -1`).
@param `array` the array to search through for the object, may be ` null`
@param `objectToFind` the object to find, may be ` null`
@param `startIndex` the index to start searching at
@return the index of the object within the array starting at the index, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: indexOf
param_types_key: long[],long
signature_text: public static int indexOf(long[] array, long valueToFind)
comment:
Finds the index of the given value in the array.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
@param `array` the array to search through for the object, may be ` null`
@param `valueToFind` the value to find
@return the index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: indexOf
param_types_key: long[],long,int
signature_text: public static int indexOf(long[] array, long valueToFind, int startIndex)
comment:
Finds the index of the given value in the array starting at the given index.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
A negative startIndex is treated as zero. A startIndex larger than the array length will return #INDEX_NOT_FOUND (` -1`).
@param `array` the array to search through for the object, may be ` null`
@param `valueToFind` the value to find
@param `startIndex` the index to start searching at
@return the index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: indexOf
param_types_key: double[],double,double
signature_text: public static int indexOf(double[] array, double valueToFind, double tolerance)
comment:
Finds the index of the given value within a given tolerance in the array. This method will return the index of the first value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
@param `array` the array to search through for the object, may be ` null`
@param `valueToFind` the value to find
@param `tolerance` tolerance of the search
@return the index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: indexOf
param_types_key: double[],double,int,double
signature_text: public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance)
comment:
Finds the index of the given value in the array starting at the given index. This method will return the index of the first value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
A negative startIndex is treated as zero. A startIndex larger than the array length will return #INDEX_NOT_FOUND (` -1`).
@param `array` the array to search through for the object, may be ` null`
@param `valueToFind` the value to find
@param `startIndex` the index to start searching at
@param `tolerance` tolerance of the search
@return the index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: Object[]
signature_text: public static boolean isEmpty(Object[] array)
comment:
Checks if an array of Objects is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: long[]
signature_text: public static boolean isEmpty(long[] array)
comment:
Checks if an array of primitive longs is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: int[]
signature_text: public static boolean isEmpty(int[] array)
comment:
Checks if an array of primitive ints is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: short[]
signature_text: public static boolean isEmpty(short[] array)
comment:
Checks if an array of primitive shorts is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: char[]
signature_text: public static boolean isEmpty(char[] array)
comment:
Checks if an array of primitive chars is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: byte[]
signature_text: public static boolean isEmpty(byte[] array)
comment:
Checks if an array of primitive bytes is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: double[]
signature_text: public static boolean isEmpty(double[] array)
comment:
Checks if an array of primitive doubles is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: float[]
signature_text: public static boolean isEmpty(float[] array)
comment:
Checks if an array of primitive floats is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isEmpty
param_types_key: boolean[]
signature_text: public static boolean isEmpty(boolean[] array)
comment:
Checks if an array of primitive booleans is empty or ` null`.
@param `array` the array to test
@return ` true` if the array is empty or ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: Object[]
signature_text: public static boolean isNotEmpty(T[] array)
comment:
Checks if an array of Objects is not empty or not ` null`.
@param `<T>` the component type of the array
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: long[]
signature_text: public static boolean isNotEmpty(long[] array)
comment:
Checks if an array of primitive longs is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: int[]
signature_text: public static boolean isNotEmpty(int[] array)
comment:
Checks if an array of primitive ints is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: short[]
signature_text: public static boolean isNotEmpty(short[] array)
comment:
Checks if an array of primitive shorts is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: char[]
signature_text: public static boolean isNotEmpty(char[] array)
comment:
Checks if an array of primitive chars is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: byte[]
signature_text: public static boolean isNotEmpty(byte[] array)
comment:
Checks if an array of primitive bytes is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: double[]
signature_text: public static boolean isNotEmpty(double[] array)
comment:
Checks if an array of primitive doubles is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: float[]
signature_text: public static boolean isNotEmpty(float[] array)
comment:
Checks if an array of primitive floats is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isNotEmpty
param_types_key: boolean[]
signature_text: public static boolean isNotEmpty(boolean[] array)
comment:
Checks if an array of primitive booleans is not empty or not ` null`.
@param `array` the array to test
@return ` true` if the array is not empty or not ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isSameLength
param_types_key: Object[],Object[]
signature_text: public static boolean isSameLength(Object[] array1, Object[] array2)
comment:
Checks whether two arrays are the same length, treating ` null` arrays as length ` 0`.
Any multi-dimensional aspects of the arrays are ignored.
@param `array1` the first array, may be ` null`
@param `array2` the second array, may be ` null`
@return ` true` if length of arrays matches, treating ` null` as an empty array


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isSameLength
param_types_key: long[],long[]
signature_text: public static boolean isSameLength(long[] array1, long[] array2)
comment:
Checks whether two arrays are the same length, treating ` null` arrays as length ` 0`.
@param `array1` the first array, may be ` null`
@param `array2` the second array, may be ` null`
@return ` true` if length of arrays matches, treating ` null` as an empty array


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: isSameType
param_types_key: Object,Object
signature_text: public static boolean isSameType(Object array1, Object array2)
comment:
Checks whether two arrays are the same type taking into account multi-dimensional arrays.
@param `array1` the first array, must not be ` null`
@param `array2` the second array, must not be ` null`
@return ` true` if type of arrays matches
@throws `IllegalArgumentException` if either array is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: Object[],Object
signature_text: public static int lastIndexOf(Object[] array, Object objectToFind)
comment:
Finds the last index of the given object within the array.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
@param `array` the array to travers backwords looking for the object, may be ` null`
@param `objectToFind` the object to find, may be ` null`
@return the last index of the object within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: Object[],Object,int
signature_text: public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex)
comment:
Finds the last index of the given object in the array starting at the given index.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
A negative startIndex will return #INDEX_NOT_FOUND (` -1`). A startIndex larger than the array length will search from the end of the array.
@param `array` the array to traverse for looking for the object, may be ` null`
@param `objectToFind` the object to find, may be ` null`
@param `startIndex` the start index to travers backwards from
@return the last index of the object within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: long[],long
signature_text: public static int lastIndexOf(long[] array, long valueToFind)
comment:
Finds the last index of the given value within the array.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
@param `array` the array to travers backwords looking for the object, may be ` null`
@param `valueToFind` the object to find
@return the last index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: long[],long,int
signature_text: public static int lastIndexOf(long[] array, long valueToFind, int startIndex)
comment:
Finds the last index of the given value in the array starting at the given index.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
A negative startIndex will return #INDEX_NOT_FOUND (` -1`). A startIndex larger than the array length will search from the end of the array.
@param `array` the array to traverse for looking for the object, may be ` null`
@param `valueToFind` the value to find
@param `startIndex` the start index to travers backwards from
@return the last index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: double[],double,double
signature_text: public static int lastIndexOf(double[] array, double valueToFind, double tolerance)
comment:
Finds the last index of the given value within a given tolerance in the array. This method will return the index of the last value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
@param `array` the array to search through for the object, may be ` null`
@param `valueToFind` the value to find
@param `tolerance` tolerance of the search
@return the index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: double[],double,int,double
signature_text: public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance)
comment:
Finds the last index of the given value in the array starting at the given index. This method will return the index of the last value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.
This method returns #INDEX_NOT_FOUND (` -1`) for a ` null` input array.
A negative startIndex will return #INDEX_NOT_FOUND (` -1`). A startIndex larger than the array length will search from the end of the array.
@param `array` the array to traverse for looking for the object, may be ` null`
@param `valueToFind` the value to find
@param `startIndex` the start index to travers backwards from
@param `tolerance` search for value within plus/minus this amount
@return the last index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: lastIndexOf
param_types_key: boolean[],boolean
signature_text: public static int lastIndexOf(boolean[] array, boolean valueToFind)
comment:
Finds the last index of the given value within the array.
This method returns #INDEX_NOT_FOUND (` -1`) if ` null` array input.
@param `array` the array to travers backwords looking for the object, may be ` null`
@param `valueToFind` the object to find
@return the last index of the value within the array, #INDEX_NOT_FOUND (` -1`) if not found or ` null` array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: nullToEmpty
param_types_key: Object[]
signature_text: public static Object[] nullToEmpty(Object[] array)
comment:
Defensive programming technique to change a ` null` reference to an empty one.
This method returns an empty array for a ` null` input array.
As a memory optimizing technique an empty array passed in will be overridden with the empty ` public static` references in this class.
@param `array` the array to check for ` null` or empty
@return the same array, ` public static` empty array if ` null` or empty input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: remove
param_types_key: Object[],int
signature_text: public static Object remove(T[] array, int index)
comment:
Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
ArrayUtils.remove(["a"], 0)           = []  ArrayUtils.remove(["a", "b"], 0)      = ["b"]  ArrayUtils.remove(["a", "b"], 1)      = ["a"]  ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]
@param `<T>` the component type of the array
@param `array` the array to remove the element from, may not be ` null`
@param `index` the position of the element to be removed
@return A new array containing the existing elements except the element at the specified position.
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index >= array.length), or if the array is ` null`.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: remove
param_types_key: boolean[],int
signature_text: public static boolean[] remove(boolean[] array, int index)
comment:
Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
ArrayUtils.remove([true], 0)              = []  ArrayUtils.remove([true, false], 0)       = [false[]  ArrayUtils.remove([true, false], 1)       = [true[]  ArrayUtils.remove([true, true, false], 1) = [true, false]
@param `array` the array to remove the element from, may not be ` null`
@param `index` the position of the element to be removed
@return A new array containing the existing elements except the element at the specified position.
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index >= array.length), or if the array is ` null`.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: remove
param_types_key: byte[],int
signature_text: public static byte[] remove(byte[] array, int index)
comment:
Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
ArrayUtils.remove([1], 0)          = []  ArrayUtils.remove([1, 0], 0)       = [0]  ArrayUtils.remove([1, 0], 1)       = [1]  ArrayUtils.remove([1, 0, 1], 1)    = [1, 1]
@param `array` the array to remove the element from, may not be ` null`
@param `index` the position of the element to be removed
@return A new array containing the existing elements except the element at the specified position.
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index >= array.length), or if the array is ` null`.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: remove
param_types_key: char[],int
signature_text: public static char[] remove(char[] array, int index)
comment:
Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
ArrayUtils.remove(['a'], 0)           = []  ArrayUtils.remove(['a', 'b'], 0)      = ['b']  ArrayUtils.remove(['a', 'b'], 1)      = ['a']  ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c']
@param `array` the array to remove the element from, may not be ` null`
@param `index` the position of the element to be removed
@return A new array containing the existing elements except the element at the specified position.
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index >= array.length), or if the array is ` null`.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: remove
param_types_key: double[],int
signature_text: public static double[] remove(double[] array, int index)
comment:
Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
ArrayUtils.remove([1.1], 0)           = []  ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]  ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]  ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
@param `array` the array to remove the element from, may not be ` null`
@param `index` the position of the element to be removed
@return A new array containing the existing elements except the element at the specified position.
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index >= array.length), or if the array is ` null`.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: remove
param_types_key: int[],int
signature_text: public static int[] remove(int[] array, int index)
comment:
Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
If the input array is ` null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
ArrayUtils.remove([1], 0)         = []  ArrayUtils.remove([2, 6], 0)      = [6]  ArrayUtils.remove([2, 6], 1)      = [2]  ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
@param `array` the array to remove the element from, may not be ` null`
@param `index` the position of the element to be removed
@return A new array containing the existing elements except the element at the specified position.
@throws `IndexOutOfBoundsException` if the index is out of range (index < 0 || index >= array.length), or if the array is ` null`.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: removeElement
param_types_key: Object[],Object
signature_text: public static Object removeElement(T[] array, Object element)
comment:
Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
ArrayUtils.removeElement(null, "a")            = null  ArrayUtils.removeElement([], "a")              = []  ArrayUtils.removeElement(["a"], "b")           = ["a"]  ArrayUtils.removeElement(["a", "b"], "a")      = ["b"]  ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"]
@param `<T>` the component type of the array
@param `array` the array to remove the element from, may be ` null`
@param `element` the element to be removed
@return A new array containing the existing elements except the first occurrence of the specified element.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: removeElement
param_types_key: boolean[],boolean
signature_text: public static boolean[] removeElement(boolean[] array, boolean element)
comment:
Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
ArrayUtils.removeElement(null, true)                = null  ArrayUtils.removeElement([], true)                  = []  ArrayUtils.removeElement([true], false)             = [true[]  ArrayUtils.removeElement([true, false], false)      = [true[]  ArrayUtils.removeElement([true, false, true], true) = [false, true]
@param `array` the array to remove the element from, may be ` null`
@param `element` the element to be removed
@return A new array containing the existing elements except the first occurrence of the specified element.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: removeElement
param_types_key: byte[],byte
signature_text: public static byte[] removeElement(byte[] array, byte element)
comment:
Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
ArrayUtils.removeElement(null, 1)        = null  ArrayUtils.removeElement([], 1)          = []  ArrayUtils.removeElement([1], 0)         = [1]  ArrayUtils.removeElement([1, 0], 0)      = [1]  ArrayUtils.removeElement([1, 0, 1], 1)   = [0, 1]
@param `array` the array to remove the element from, may be ` null`
@param `element` the element to be removed
@return A new array containing the existing elements except the first occurrence of the specified element.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: removeElement
param_types_key: char[],char
signature_text: public static char[] removeElement(char[] array, char element)
comment:
Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
ArrayUtils.removeElement(null, 'a')            = null  ArrayUtils.removeElement([], 'a')              = []  ArrayUtils.removeElement(['a'], 'b')           = ['a']  ArrayUtils.removeElement(['a', 'b'], 'a')      = ['b']  ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
@param `array` the array to remove the element from, may be ` null`
@param `element` the element to be removed
@return A new array containing the existing elements except the first occurrence of the specified element.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: removeElement
param_types_key: double[],double
signature_text: public static double[] removeElement(double[] array, double element)
comment:
Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
ArrayUtils.removeElement(null, 1.1)            = null  ArrayUtils.removeElement([], 1.1)              = []  ArrayUtils.removeElement([1.1], 1.2)           = [1.1]  ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]  ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
@param `array` the array to remove the element from, may be ` null`
@param `element` the element to be removed
@return A new array containing the existing elements except the first occurrence of the specified element.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: removeElement
param_types_key: int[],int
signature_text: public static int[] removeElement(int[] array, int element)
comment:
Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
ArrayUtils.removeElement(null, 1)      = null  ArrayUtils.removeElement([], 1)        = []  ArrayUtils.removeElement([1], 2)       = [1]  ArrayUtils.removeElement([1, 3], 1)    = [3]  ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
@param `array` the array to remove the element from, may be ` null`
@param `element` the element to be removed
@return A new array containing the existing elements except the first occurrence of the specified element.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: reverse
param_types_key: Object[]
signature_text: public static void reverse(Object[] array)
comment:
Reverses the order of the given array.
There is no special handling for multi-dimensional arrays.
This method does nothing for a ` null` input array.
@param `array` the array to reverse, may be ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: reverse
param_types_key: long[]
signature_text: public static void reverse(long[] array)
comment:
Reverses the order of the given array.
This method does nothing for a ` null` input array.
@param `array` the array to reverse, may be ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: reverse
param_types_key: boolean[],int,int
signature_text: public static void reverse(boolean[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Reverses the order of the given array in the given range.
This method does nothing for a ` null` input array.
@param `array` ` the array to reverse, may be ` null`
@param `startIndexInclusive` ` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in no change.
@param `endIndexExclusive` ` elements up to endIndex-1 are reversed in the array. Undervalue (< start index) results in no change. Overvalue (>array.length) is demoted to array length.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: Object[],int,int
signature_text: public static Object subarray(T[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
The component type of the subarray is always the same as that of the input array. Thus, if the input is an array of type ` Date`, the following usage is envisaged:
Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5);
@see kd.bos.dataentity.utils.Arrays#copyOfRange(Object[], int, int)
@param `<T>` the component type of the array
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: long[],int,int
signature_text: public static long[] subarray(long[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` long` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(long[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: int[],int,int
signature_text: public static int[] subarray(int[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` int` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(int[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: short[],int,int
signature_text: public static short[] subarray(short[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` short` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(short[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: char[],int,int
signature_text: public static char[] subarray(char[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` char` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(char[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: byte[],int,int
signature_text: public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` byte` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(byte[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: double[],int,int
signature_text: public static double[] subarray(double[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` double` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(double[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: float[],int,int
signature_text: public static float[] subarray(float[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` float` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(float[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: subarray
param_types_key: boolean[],int,int
signature_text: public static boolean[] subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive)
comment:
Produces a new ` boolean` array containing the elements between the start and end indices.
The start index is inclusive, the end index exclusive. Null array input produces null output.
@see kd.bos.dataentity.utils.Arrays#copyOfRange(boolean[], int, int)
@param `array` the array
@param `startIndexInclusive` the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
@param `endIndexExclusive` elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
@return a new array containing the elements between the start and end indices.


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toArray
param_types_key: Object[]
signature_text: public static Object toArray(T[] items)
comment:
Create a type-safe generic array.
The Java language does not allow an array to be created from a generic type:
public static <T> T[] createAnArray(int size) {         return new T[size]; // compiler error here     }     public static <T> T[] createAnArray(int size) {         return (T[])new Object[size]; // ClassCastException at runtime     }
Therefore new arrays of generic types can be created with this method. For example, an array of Strings can be created:
String[] array = ArrayUtils.toArray("1", "2");     String[] emptyArray = ArrayUtils.<String>toArray();
The method is typically used in scenarios, where the caller itself uses generic types that have to be combined into an array.
Note, this method makes only sense to provide arguments of the same type so that the compiler can deduce the type of the array itself. While it is possible to select the type explicitly like in `Number[] array = ArrayUtils.<Number>toArray(Integer.valueOf(42), Double.valueOf(Math.PI))`, there is no real advantage when compared to `new Number[] {Integer.valueOf(42), Double.valueOf(Math.PI)}`.
@param `<T>` the array's element type
@param `items` the varargs array items, null allowed
@return the array, not null unless a null array is passed in


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toMap
param_types_key: Object[]
signature_text: public static java.util.Map<Object, Object> toMap(Object[] array)
comment:
Converts the given array into a java.util.Map. Each element of the array must be either a java.util.Map.Entry or an Array, containing at least two elements, where the first element is used as key and the second as value.
This method can be used to initialize:
// Create a Map mapping colors.  Map colorMap = MapUtils.toMap(new String[][] {{      {"RED", "#FF0000"},      {"GREEN", "#00FF00"},      {"BLUE", "#0000FF"}});
This method returns ` null` for a ` null` input array.
@param `array` an array whose elements are either a java.util.Map.Entry or an Array containing at least two elements, may be ` null`
@return a ` Map` that was created from the array
@throws `IllegalArgumentException` if one element of this Array is itself an Array containing less then two elements
@throws `IllegalArgumentException` if the array contains elements other than java.util.Map.Entry and an Array


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: char[]
signature_text: public static Character[] toObject(char[] array)
comment:
Converts an array of primitive chars to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` char` array
@return a ` Character` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: long[]
signature_text: public static Long[] toObject(long[] array)
comment:
Converts an array of primitive longs to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` long` array
@return a ` Long` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: int[]
signature_text: public static Integer[] toObject(int[] array)
comment:
Converts an array of primitive ints to objects.
This method returns ` null` for a ` null` input array.
@param `array` an ` int` array
@return an ` Integer` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: short[]
signature_text: public static Short[] toObject(short[] array)
comment:
Converts an array of primitive shorts to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` short` array
@return a ` Short` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: byte[]
signature_text: public static Byte[] toObject(byte[] array)
comment:
Converts an array of primitive bytes to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` byte` array
@return a ` Byte` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: double[]
signature_text: public static Double[] toObject(double[] array)
comment:
Converts an array of primitive doubles to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` double` array
@return a ` Double` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: float[]
signature_text: public static Float[] toObject(float[] array)
comment:
Converts an array of primitive floats to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` float` array
@return a ` Float` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toObject
param_types_key: boolean[]
signature_text: public static Boolean[] toObject(boolean[] array)
comment:
Converts an array of primitive booleans to objects.
This method returns ` null` for a ` null` input array.
@param `array` a ` boolean` array
@return a ` Boolean` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Character[]
signature_text: public static char[] toPrimitive(Character[] array)
comment:
Converts an array of object Characters to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Character` array, may be ` null`
@return a ` char` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Character[],char
signature_text: public static char[] toPrimitive(Character[] array, char valueForNull)
comment:
Converts an array of object Character to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Character` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` char` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Long[]
signature_text: public static long[] toPrimitive(Long[] array)
comment:
Converts an array of object Longs to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Long` array, may be ` null`
@return a ` long` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Long[],long
signature_text: public static long[] toPrimitive(Long[] array, long valueForNull)
comment:
Converts an array of object Long to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Long` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` long` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Integer[]
signature_text: public static int[] toPrimitive(Integer[] array)
comment:
Converts an array of object Integers to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Integer` array, may be ` null`
@return an ` int` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Integer[],int
signature_text: public static int[] toPrimitive(Integer[] array, int valueForNull)
comment:
Converts an array of object Integer to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Integer` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return an ` int` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Short[]
signature_text: public static short[] toPrimitive(Short[] array)
comment:
Converts an array of object Shorts to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Short` array, may be ` null`
@return a ` byte` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Short[],short
signature_text: public static short[] toPrimitive(Short[] array, short valueForNull)
comment:
Converts an array of object Short to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Short` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` byte` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Byte[]
signature_text: public static byte[] toPrimitive(Byte[] array)
comment:
Converts an array of object Bytes to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Byte` array, may be ` null`
@return a ` byte` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Byte[],byte
signature_text: public static byte[] toPrimitive(Byte[] array, byte valueForNull)
comment:
Converts an array of object Bytes to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Byte` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` byte` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Double[]
signature_text: public static double[] toPrimitive(Double[] array)
comment:
Converts an array of object Doubles to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Double` array, may be ` null`
@return a ` double` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Double[],double
signature_text: public static double[] toPrimitive(Double[] array, double valueForNull)
comment:
Converts an array of object Doubles to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Double` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` double` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Float[]
signature_text: public static float[] toPrimitive(Float[] array)
comment:
Converts an array of object Floats to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Float` array, may be ` null`
@return a ` float` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Float[],float
signature_text: public static float[] toPrimitive(Float[] array, float valueForNull)
comment:
Converts an array of object Floats to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Float` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` float` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Boolean[]
signature_text: public static boolean[] toPrimitive(Boolean[] array)
comment:
Converts an array of object Booleans to primitives.
This method returns ` null` for a ` null` input array.
@param `array` a ` Boolean` array, may be ` null`
@return a ` boolean` array, ` null` if null array input
@throws `NullPointerException` if array content is ` null`


class_name: kd.bos.dataentity.utils.ArrayUtils
method_name: toPrimitive
param_types_key: Boolean[],boolean
signature_text: public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull)
comment:
Converts an array of object Booleans to primitives handling ` null`.
This method returns ` null` for a ` null` input array.
@param `array` a ` Boolean` array, may be ` null`
@param `valueForNull` the value to insert if ` null` found
@return a ` boolean` array, ` null` if null array input


class_name: kd.bos.dataentity.utils.CharSequenceUtils
method_name: <init>
signature_text: public CharSequenceUtils()
comment:
` CharSequenceUtils` instances should NOT be constructed in standard programming.
This constructor is public to permit tools that require a JavaBean instance to operate.


class_name: kd.bos.dataentity.utils.CharSequenceUtils
method_name: subSequence
param_types_key: CharSequence,int
signature_text: public static CharSequence subSequence(CharSequence cs, int start)
comment:
Returns a new ` CharSequence` that is a subsequence of this sequence starting with the ` char` value at the specified index.
This provides the ` CharSequence` equivalent to String#substring(int). The length (in ` char`) of the returned sequence is ` length() - start`, so if ` start == end` then an empty sequence is returned.
@param `cs` the specified subsequence, null returns null
@param `start` the start index, inclusive, valid
@return a new subsequence, may be null
@throws `IndexOutOfBoundsException` if ` start` is negative or if ` start` is greater than ` length()`


class_name: kd.bos.dataentity.utils.CharUtils
method_name: <init>
signature_text: public CharUtils()
comment:
` CharUtils` instances should NOT be constructed in standard programming. Instead, the class should be used as ` CharUtils.toString('c');`.
This constructor is public to permit tools that require a JavaBean instance to operate.


class_name: kd.bos.dataentity.utils.CharUtils
method_name: compare
param_types_key: char,char
signature_text: public static int compare(char x, char y)
comment:
Compares two ` char` values numerically. This is the same functionality as provided in Java 7.
@param `x` the first ` char` to compare
@param `y` the second ` char` to compare
@return the value ` 0` if ` x == y`; a value less than ` 0` if ` x < y`; and a value greater than ` 0` if ` x > y`


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAscii
param_types_key: char
signature_text: public static boolean isAscii(char ch)
comment:
Checks whether the character is ASCII 7 bit.
CharUtils.isAscii('a')  = true    CharUtils.isAscii('A')  = true    CharUtils.isAscii('3')  = true    CharUtils.isAscii('-')  = true    CharUtils.isAscii('\n') = true    CharUtils.isAscii('©') = false
@param `ch` the character to check
@return true if less than 128


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiAlpha
param_types_key: char
signature_text: public static boolean isAsciiAlpha(char ch)
comment:
Checks whether the character is ASCII 7 bit alphabetic.
CharUtils.isAsciiAlpha('a')  = true    CharUtils.isAsciiAlpha('A')  = true    CharUtils.isAsciiAlpha('3')  = false    CharUtils.isAsciiAlpha('-')  = false    CharUtils.isAsciiAlpha('\n') = false    CharUtils.isAsciiAlpha('©') = false
@param `ch` the character to check
@return true if between 65 and 90 or 97 and 122 inclusive


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiAlphaLower
param_types_key: char
signature_text: public static boolean isAsciiAlphaLower(char ch)
comment:
Checks whether the character is ASCII 7 bit alphabetic lower case.
CharUtils.isAsciiAlphaLower('a')  = true    CharUtils.isAsciiAlphaLower('A')  = false    CharUtils.isAsciiAlphaLower('3')  = false    CharUtils.isAsciiAlphaLower('-')  = false    CharUtils.isAsciiAlphaLower('\n') = false    CharUtils.isAsciiAlphaLower('©') = false
@param `ch` the character to check
@return true if between 97 and 122 inclusive


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiAlphaUpper
param_types_key: char
signature_text: public static boolean isAsciiAlphaUpper(char ch)
comment:
Checks whether the character is ASCII 7 bit alphabetic upper case.
CharUtils.isAsciiAlphaUpper('a')  = false    CharUtils.isAsciiAlphaUpper('A')  = true    CharUtils.isAsciiAlphaUpper('3')  = false    CharUtils.isAsciiAlphaUpper('-')  = false    CharUtils.isAsciiAlphaUpper('\n') = false    CharUtils.isAsciiAlphaUpper('©') = false
@param `ch` the character to check
@return true if between 65 and 90 inclusive


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiAlphanumeric
param_types_key: char
signature_text: public static boolean isAsciiAlphanumeric(char ch)
comment:
Checks whether the character is ASCII 7 bit numeric.
CharUtils.isAsciiAlphanumeric('a')  = true    CharUtils.isAsciiAlphanumeric('A')  = true    CharUtils.isAsciiAlphanumeric('3')  = true    CharUtils.isAsciiAlphanumeric('-')  = false    CharUtils.isAsciiAlphanumeric('\n') = false    CharUtils.isAsciiAlphanumeric('©') = false
@param `ch` the character to check
@return true if between 48 and 57 or 65 and 90 or 97 and 122 inclusive


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiControl
param_types_key: char
signature_text: public static boolean isAsciiControl(char ch)
comment:
Checks whether the character is ASCII 7 bit control.
CharUtils.isAsciiControl('a')  = false    CharUtils.isAsciiControl('A')  = false    CharUtils.isAsciiControl('3')  = false    CharUtils.isAsciiControl('-')  = false    CharUtils.isAsciiControl('\n') = true    CharUtils.isAsciiControl('©') = false
@param `ch` the character to check
@return true if less than 32 or equals 127


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiNumeric
param_types_key: char
signature_text: public static boolean isAsciiNumeric(char ch)
comment:
Checks whether the character is ASCII 7 bit numeric.
CharUtils.isAsciiNumeric('a')  = false    CharUtils.isAsciiNumeric('A')  = false    CharUtils.isAsciiNumeric('3')  = true    CharUtils.isAsciiNumeric('-')  = false    CharUtils.isAsciiNumeric('\n') = false    CharUtils.isAsciiNumeric('©') = false
@param `ch` the character to check
@return true if between 48 and 57 inclusive


class_name: kd.bos.dataentity.utils.CharUtils
method_name: isAsciiPrintable
param_types_key: char
signature_text: public static boolean isAsciiPrintable(char ch)
comment:
Checks whether the character is ASCII 7 bit printable.
CharUtils.isAsciiPrintable('a')  = true    CharUtils.isAsciiPrintable('A')  = true    CharUtils.isAsciiPrintable('3')  = true    CharUtils.isAsciiPrintable('-')  = true    CharUtils.isAsciiPrintable('\n') = false    CharUtils.isAsciiPrintable('©') = false
@param `ch` the character to check
@return true if between 32 and 126 inclusive


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toChar
param_types_key: Character
signature_text: public static char toChar(Character ch)
comment:
Converts the Character to a char throwing an exception for ` null`.
CharUtils.toChar(' ')  = ' '    CharUtils.toChar('A')  = 'A'    CharUtils.toChar(null) throws IllegalArgumentException
@param `ch` the character to convert
@return the char value of the Character
@throws `IllegalArgumentException` if the Character is null


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toChar
param_types_key: Character,char
signature_text: public static char toChar(Character ch, char defaultValue)
comment:
Converts the Character to a char handling ` null`.
CharUtils.toChar(null, 'X') = 'X'    CharUtils.toChar(' ', 'X')  = ' '    CharUtils.toChar('A', 'X')  = 'A'
@param `ch` the character to convert
@param `defaultValue` the value to use if the Character is null
@return the char value of the Character or the default if null


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toChar
param_types_key: String
signature_text: public static char toChar(String str)
comment:
Converts the String to a char using the first character, throwing an exception on empty Strings.
CharUtils.toChar("A")  = 'A'    CharUtils.toChar("BA") = 'B'    CharUtils.toChar(null) throws IllegalArgumentException    CharUtils.toChar("")   throws IllegalArgumentException
@param `str` the character to convert
@return the char value of the first letter of the String
@throws `IllegalArgumentException` if the String is empty


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toChar
param_types_key: String,char
signature_text: public static char toChar(String str, char defaultValue)
comment:
Converts the String to a char using the first character, defaulting the value on empty Strings.
CharUtils.toChar(null, 'X') = 'X'    CharUtils.toChar("", 'X')   = 'X'    CharUtils.toChar("A", 'X')  = 'A'    CharUtils.toChar("BA", 'X') = 'B'
@param `str` the character to convert
@param `defaultValue` the value to use if the Character is null
@return the char value of the first letter of the String or the default if null


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toCharacterObject
param_types_key: String
signature_text: public static Character toCharacterObject(String str)
comment:
Converts the String to a Character using the first character, returning null for empty Strings.
For ASCII 7 bit characters, this uses a cache that will return the same Character object each time.
CharUtils.toCharacterObject(null) = null    CharUtils.toCharacterObject("")   = null    CharUtils.toCharacterObject("A")  = 'A'    CharUtils.toCharacterObject("BA") = 'B'
@param `str` the character to convert
@return the Character value of the first letter of the String


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toIntValue
param_types_key: char
signature_text: public static int toIntValue(char ch)
comment:
Converts the character to the Integer it represents, throwing an exception if the character is not numeric.
This method coverts the char '1' to the int 1 and so on.
CharUtils.toIntValue('3')  = 3    CharUtils.toIntValue('A')  throws IllegalArgumentException
@param `ch` the character to convert
@return the int value of the character
@throws `IllegalArgumentException` if the character is not ASCII numeric


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toIntValue
param_types_key: char,int
signature_text: public static int toIntValue(char ch, int defaultValue)
comment:
Converts the character to the Integer it represents, throwing an exception if the character is not numeric.
This method coverts the char '1' to the int 1 and so on.
CharUtils.toIntValue('3', -1)  = 3    CharUtils.toIntValue('A', -1)  = -1
@param `ch` the character to convert
@param `defaultValue` the default value to use if the character is not numeric
@return the int value of the character


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toIntValue
param_types_key: Character
signature_text: public static int toIntValue(Character ch)
comment:
Converts the character to the Integer it represents, throwing an exception if the character is not numeric.
This method coverts the char '1' to the int 1 and so on.
CharUtils.toIntValue('3')  = 3    CharUtils.toIntValue(null) throws IllegalArgumentException    CharUtils.toIntValue('A')  throws IllegalArgumentException
@param `ch` the character to convert, not null
@return the int value of the character
@throws `IllegalArgumentException` if the Character is not ASCII numeric or is null


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toIntValue
param_types_key: Character,int
signature_text: public static int toIntValue(Character ch, int defaultValue)
comment:
Converts the character to the Integer it represents, throwing an exception if the character is not numeric.
This method coverts the char '1' to the int 1 and so on.
CharUtils.toIntValue(null, -1) = -1    CharUtils.toIntValue('3', -1)  = 3    CharUtils.toIntValue('A', -1)  = -1
@param `ch` the character to convert
@param `defaultValue` the default value to use if the character is not numeric
@return the int value of the character


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toString
param_types_key: char
signature_text: public static String toString(char ch)
comment:
Converts the character to a String that contains the one character.
For ASCII 7 bit characters, this uses a cache that will return the same String object each time.
CharUtils.toString(' ')  = " "    CharUtils.toString('A')  = "A"
@param `ch` the character to convert
@return a String containing the one specified character


class_name: kd.bos.dataentity.utils.CharUtils
method_name: toString
param_types_key: Character
signature_text: public static String toString(Character ch)
comment:
Converts the character to a String that contains the one character.
For ASCII 7 bit characters, this uses a cache that will return the same String object each time.
If ` null` is passed in, ` null` will be returned.
CharUtils.toString(null) = null    CharUtils.toString(' ')  = " "    CharUtils.toString('A')  = "A"
@param `ch` the character to convert
@return a String containing the one specified character


class_name: kd.bos.dataentity.utils.CharUtils
method_name: unicodeEscaped
param_types_key: char
signature_text: public static String unicodeEscaped(char ch)
comment:
Converts the string to the Unicode format ' '.
This format is the Java source code format.
CharUtils.unicodeEscaped(' ') = " "    CharUtils.unicodeEscaped('A') = "A"
@param `ch` the character to convert
@return the escaped Unicode string


class_name: kd.bos.dataentity.utils.CharUtils
method_name: unicodeEscaped
param_types_key: Character
signature_text: public static String unicodeEscaped(Character ch)
comment:
Converts the string to the Unicode format ' '.
This format is the Java source code format.
If ` null` is passed in, ` null` will be returned.
CharUtils.unicodeEscaped(null) = null    CharUtils.unicodeEscaped(' ')  = " "    CharUtils.unicodeEscaped('A')  = "A"
@param `ch` the character to convert, may be null
@return the escaped Unicode string, null if null input


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: addObjectToArray
param_types_key: Object[],Object
signature_text: public static Object addObjectToArray(A[] array, O obj)
comment:
Append the given object to the given array, returning a new array consisting of the input array contents plus the given object.
@param `array` the array to append to (can be ` null`)
@param `obj` the object to append
@return the new array (of the same component type; never ` null`)


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: caseInsensitiveValueOf
param_types_key: Object[],String
signature_text: public static Enum caseInsensitiveValueOf(E[] enumValues, String constant)
comment:
Case insensitive alternative to String).
@param `<E>` the concrete Enum type
@param `enumValues` the array of all Enum constants in question, usually per Enum.values()
@param `constant` the constant to get the enum value of
@throws `IllegalArgumentException` if the given constant is not found in the given array of enum values. Use String) as a guard to avoid this exception.


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: containsConstant
param_types_key: Enum[],String
signature_text: public static boolean containsConstant(Enum<?>[] enumValues, String constant)
comment:
Check whether the given array of enum constants contains a constant with the given name, ignoring case when determining a match.
@param `enumValues` the enum values to check, typically the product of a call to MyEnum.values()
@param `constant` the constant name to find (must not be null or empty string)
@return whether the constant has been found in the given array


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: containsConstant
param_types_key: Enum[],String,boolean
signature_text:
public static boolean containsConstant(Enum<?>[] enumValues, String constant, boolean caseSensitive)

comment:
Check whether the given array of enum constants contains a constant with the given name.
@param `enumValues` the enum values to check, typically the product of a call to MyEnum.values()
@param `constant` the constant name to find (must not be null or empty string)
@param `caseSensitive` whether case is significant in determining a match
@return whether the constant has been found in the given array


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: containsElement
param_types_key: Object[],Object
signature_text: public static boolean containsElement(Object[] array, Object element)
comment:
Check whether the given array contains the given element.
@param `array` the array to check (may be ` null`, in which case the return value will always be ` false`)
@param `element` the element to check for
@return whether the element has been found in the given array


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: getDisplayString
param_types_key: Object
signature_text: public static String getDisplayString(Object obj)
comment:
Return a content-based String representation if ` obj` is not ` null`; otherwise returns an empty String.
Differs from #nullSafeToString(Object) in that it returns an empty String rather than "null" for a ` null` value.
@see ##nullSafeToString(Object)
@param `obj` the object to build a display String for
@return a display String representation of ` obj`


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: getIdentityHexString
param_types_key: Object
signature_text: public static String getIdentityHexString(Object obj)
comment:
Return a hex String form of an object's identity hash code.
@param `obj` the object
@return the object's identity code in hex notation


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: identityToString
param_types_key: Object
signature_text: public static String identityToString(Object obj)
comment:
Return a String representation of an object's overall identity.
@param `obj` the object (may be ` null`)
@return the object's identity as String representation, or an empty String if the object was ` null`


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: isArray
param_types_key: Object
signature_text: public static boolean isArray(Object obj)
comment:
Determine whether the given object is an array: either an Object array or a primitive array.
@param `obj` the object to check


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: isCheckedException
param_types_key: Throwable
signature_text: public static boolean isCheckedException(Throwable ex)
comment:
Return whether the given throwable is a checked exception: that is, neither a RuntimeException nor an Error.
@see Exception
@see RuntimeException
@see Error
@param `ex` the throwable to check
@return whether the throwable is a checked exception


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: isCompatibleWithThrowsClause
param_types_key: Throwable,Class[]
signature_text: public static boolean isCompatibleWithThrowsClause(Throwable ex, Class<?>[] declaredExceptions)
comment:
Check whether the given exception is compatible with the specified exception types, as declared in a throws clause.
@param `ex` the exception to check
@param `declaredExceptions` the exception types declared in the throws clause
@return whether the given exception is compatible


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: isEmpty
param_types_key: Object[]
signature_text: public static boolean isEmpty(Object[] array)
comment:
Determine whether the given array is empty: i.e. ` null` or of zero length.
@see ##isEmpty(Object)
@param `array` the array to check


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: isEmpty
param_types_key: Object
signature_text: public static boolean isEmpty(Object obj)
comment:
Determine whether the given object is empty.
This method supports the following object types.
* ` Optional`: considered empty if Optional#empty()
* ` Array`: considered empty if its length is zero
* CharSequence: considered empty if its length is zero
* Collection: delegates to Collection#isEmpty()
* Map: delegates to Map#isEmpty()
If the given object is non-null and not one of the aforementioned supported types, this method returns ` false`.
@see kd.bos.dataentity.utils.Optional#isPresent()
@see [ObjectUtils#isEmpty(Object[])#isEmpty(Object[])
@see StringUtils#hasLength(CharSequence)#hasLength(CharSequence)
@see StringUtils#isEmpty(Object)#isEmpty(Object)
@see CollectionUtils#isEmpty(java.util.Collection)#isEmpty(java.util.Collection)
@see CollectionUtils#isEmpty(java.util.Map)#isEmpty(java.util.Map)
@param `obj` the object to check
@return ` true` if the object is ` null` or _empty_


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: nullSafeClassName
param_types_key: Object
signature_text: public static String nullSafeClassName(Object obj)
comment:
Determine the class name for the given object.
Returns ` "null"` if ` obj` is ` null`.
@param `obj` the object to introspect (may be ` null`)
@return the corresponding class name


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: nullSafeEquals
param_types_key: Object,Object
signature_text: public static boolean nullSafeEquals(Object o1, Object o2)
comment:
Determine if the given objects are equal, returning ` true` if both are ` null` or ` false` if only one is ` null`.
Compares arrays with ` Arrays.equals`, performing an equality check based on the array elements rather than the array reference.
@see kd.bos.dataentity.utils.Object#equals(Object)
@see java.util.Arrays#equals
@param `o1` first Object to compare
@param `o2` second Object to compare
@return whether the given objects are equal


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: nullSafeHashCode
param_types_key: Object
signature_text: public static int nullSafeHashCode(Object obj)
comment:
Return as hash code for the given object; typically the value of ` Object#hashCode()`}. If the object is an array, this method will delegate to any of the ` nullSafeHashCode` methods for arrays in this class. If the object is ` null`, this method returns 0.
@see kd.bos.dataentity.utils.Object#hashCode()
@see ##nullSafeHashCode(Object[])
@see ##nullSafeHashCode(boolean[])
@see ##nullSafeHashCode(byte[])
@see ##nullSafeHashCode(char[])
@see ##nullSafeHashCode(double[])
@see ##nullSafeHashCode(float[])
@see ##nullSafeHashCode(int[])
@see ##nullSafeHashCode(long[])
@see ##nullSafeHashCode(short[])


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: nullSafeHashCode
param_types_key: Object[]
signature_text: public static int nullSafeHashCode(Object[] array)
comment:
Return a hash code based on the contents of the specified array. If ` array` is ` null`, this method returns 0.


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: nullSafeToString
param_types_key: Object
signature_text: public static String nullSafeToString(Object obj)
comment:
Return a String representation of the specified Object.
Builds a String representation of the contents in case of an array. Returns ` "null"` if ` obj` is ` null`.
@param `obj` the object to build a String representation for
@return a String representation of ` obj`


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: nullSafeToString
param_types_key: Object[]
signature_text: public static String nullSafeToString(Object[] array)
comment:
Return a String representation of the contents of the specified array.
The String representation consists of a list of the array's elements, enclosed in curly braces (` "{}"`). Adjacent elements are separated by the characters ` ", "` (a comma followed by a space). Returns ` "null"` if ` array` is ` null`.
@param `array` the array to build a String representation for
@return a String representation of ` array`


class_name: kd.bos.dataentity.utils.ObjectUtils
method_name: toObjectArray
param_types_key: Object
signature_text: public static Object[] toObjectArray(Object source)
comment:
Convert the given array (which may be a primitive array) to an object array (if necessary of primitive wrapper objects).
A ` null` source value will be converted to an empty Object array.
@param `source` the (potentially primitive) array
@return the corresponding object array (never ` null`)
@throws `IllegalArgumentException` if the parameter is not an array


class_name: kd.bos.dataentity.utils.OrmUtils
method_name: DataEntityWalker
param_types_key: Collection,IDataEntityType,DataEntityWalkerListner,boolean
signature_text:
public static void DataEntityWalker(java.util.Collection<? extends Object> dataEntities, IDataEntityType dt, kd.bos.dataentity.entity.DataEntityWalkerListner callback, boolean onlyDbProperty)

comment:
搜索实体中各个层级的所有数据
@param `dataEntities` 要搜索的实体
@param `dt` 根实体结构
@param `callback` 当搜索到某个级别时发生的回调
@param `onlyDbProperty` 是否仅搜索数据库使用的属性


class_name: kd.bos.dataentity.utils.OrmUtils
method_name: clone
param_types_key: IDataEntityBase,boolean,boolean
signature_text:
public static Object clone(IDataEntityBase dataEntity, boolean onlyDbProperty, boolean clearPrimaryKeyValue)

comment:
克隆当前实体的数据成为一个新的数据。注意他不会复制实体上的脏标识信息和快照信息。
@param `dataEntity` 要克隆的实体
@param `onlyDbProperty` 是否仅赋值数据库映射的字段。默认为false
@param `clearPrimaryKeyValue` 是否清除主键的值，默认为false
@return 新的实体对象，将当前的数据复制到了新的实体。


class_name: kd.bos.dataentity.utils.OrmUtils
method_name: clone
param_types_key: Object,IDataEntityType,boolean,boolean
signature_text:
public static Object clone(Object dataEntity, IDataEntityType dt, boolean onlyDbProperty, boolean clearPrimaryKeyValue)

comment:
克隆当前实体的数据成为一个新的数据。注意他不会复制实体上的脏标识信息和快照信息。
@param `dataEntity` 要克隆的实体
@param `dt` 当前实体的类型，不能为空。
@param `onlyDbProperty` 是否仅赋值数据库映射的字段。默认为false
@param `clearPrimaryKeyValue` 是否清除主键的值，默认为false
@return 新的实体对象，将当前的数据复制到了新的实体。


class_name: kd.bos.dataentity.utils.OrmUtils
method_name: sync
param_types_key: List,List,IListSyncFunction,boolean
signature_text:
public static void sync(java.util.List<SourceT> sourceList, java.util.List<TargetT> targetList, kd.bos.dataentity.IListSyncFunction<SourceT, TargetT> syncFunction, boolean callUpdateFuncWhenCreated)

comment:
列表同步操作方法 源的元素如果在目标列表中存在，将更新目标的数据，否则新增； 如果目标列表的元素在源列表中不存在，将从目标列表中删除。
@param `sourceList` 源列表
@param `targetList` 目标列表
@param `syncFunction` 同步处理方法
@param `callUpdateFuncWhenCreated` 默认为true


class_name: kd.bos.dataentity.utils.StringUtils
method_name: <init>
signature_text: public StringUtils()
comment:
` StringUtils` instances should NOT be constructed in standard programming. Instead, the class should be used as ` StringUtils.trim(" foo ");`.
This constructor is public to permit tools that require a JavaBean instance to operate.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: abbreviate
param_types_key: String,int
signature_text: public static String abbreviate(String str, int maxWidth)
comment:
Abbreviates a String using ellipses. This will turn "Now is the time for all good men" into "Now is the time for..."
Specifically:
* If the number of characters in ` str` is less than or equal to ` maxWidth`, return ` str`.
* Else abbreviate it to ` (substring(str, 0, max-3) + "...")`.
* If ` maxWidth` is less than ` 4`, throw an ` IllegalArgumentException`.
* In no case will it return a String of length greater than ` maxWidth`.
StringUtils.abbreviate(null, *)      = null  StringUtils.abbreviate("", 4)        = ""  StringUtils.abbreviate("abcdefg", 6) = "abc..."  StringUtils.abbreviate("abcdefg", 7) = "abcdefg"  StringUtils.abbreviate("abcdefg", 8) = "abcdefg"  StringUtils.abbreviate("abcdefg", 4) = "a..."  StringUtils.abbreviate("abcdefg", 3) = IllegalArgumentException
@param `str` the String to check, may be null
@param `maxWidth` maximum length of result String, must be at least 4
@return abbreviated String, ` null` if null String input
@throws `IllegalArgumentException` if the width is too small


class_name: kd.bos.dataentity.utils.StringUtils
method_name: abbreviate
param_types_key: String,int,int
signature_text: public static String abbreviate(String str, int offset, int maxWidth)
comment:
Abbreviates a String using ellipses. This will turn "Now is the time for all good men" into "...is the time for..."
Works like ` abbreviate(String, int)`, but allows you to specify a "left edge" offset. Note that this left edge is not necessarily going to be the leftmost character in the result, or the first character following the ellipses, but it will appear somewhere in the result.
In no case will it return a String of length greater than ` maxWidth`.
StringUtils.abbreviate(null, *, *)                = null  StringUtils.abbreviate("", 0, 4)                  = ""  StringUtils.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."  StringUtils.abbreviate("abcdefghijklmno", 0, 10)  = "abcdefg..."  StringUtils.abbreviate("abcdefghijklmno", 1, 10)  = "abcdefg..."  StringUtils.abbreviate("abcdefghijklmno", 4, 10)  = "abcdefg..."  StringUtils.abbreviate("abcdefghijklmno", 5, 10)  = "...fghi..."  StringUtils.abbreviate("abcdefghijklmno", 6, 10)  = "...ghij..."  StringUtils.abbreviate("abcdefghijklmno", 8, 10)  = "...ijklmno"  StringUtils.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"  StringUtils.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"  StringUtils.abbreviate("abcdefghij", 0, 3)        = IllegalArgumentException  StringUtils.abbreviate("abcdefghij", 5, 6)        = IllegalArgumentException
@param `str` the String to check, may be null
@param `offset` left edge of source String
@param `maxWidth` maximum length of result String, must be at least 4
@return abbreviated String, ` null` if null String input
@throws `IllegalArgumentException` if the width is too small


class_name: kd.bos.dataentity.utils.StringUtils
method_name: abbreviateMiddle
param_types_key: String,String,int
signature_text: public static String abbreviateMiddle(String str, String middle, int length)
comment:
Abbreviates a String to the length passed, replacing the middle characters with the supplied replacement String.
This abbreviation only occurs if the following criteria is met:
* Neither the String for abbreviation nor the replacement String are null or empty
* The length to truncate to is less than the length of the supplied String
* The length to truncate to is greater than 0
* The abbreviated String will have enough room for the length supplied replacement String and the first and last characters of the supplied String for abbreviation
Otherwise, the returned String will be the same as the supplied String for abbreviation.
StringUtils.abbreviateMiddle(null, null, 0)      = null  StringUtils.abbreviateMiddle("abc", null, 0)      = "abc"  StringUtils.abbreviateMiddle("abc", ".", 0)      = "abc"  StringUtils.abbreviateMiddle("abc", ".", 3)      = "abc"  StringUtils.abbreviateMiddle("abcdef", ".", 4)     = "ab.f"
@param `str` the String to abbreviate, may be null
@param `middle` the String to replace the middle characters with, may be null
@param `length` the length to abbreviate ` str` to.
@return the abbreviated String if the above criteria is met, or the original String supplied for abbreviation.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: appendIfMissing
param_types_key: String,CharSequence,CharSequence[]
signature_text: public static String appendIfMissing(String str, CharSequence suffix, CharSequence[] suffixes)
comment:
Appends the suffix to the end of the string if the string does not already end with any the suffixes.
StringUtils.appendIfMissing(null, null) = null  StringUtils.appendIfMissing("abc", null) = "abc"  StringUtils.appendIfMissing("", "xyz") = "xyz"  StringUtils.appendIfMissing("abc", "xyz") = "abcxyz"  StringUtils.appendIfMissing("abcxyz", "xyz") = "abcxyz"  StringUtils.appendIfMissing("abcXYZ", "xyz") = "abcXYZxyz"
With additional suffixes,
StringUtils.appendIfMissing(null, null, null) = null  StringUtils.appendIfMissing("abc", null, null) = "abc"  StringUtils.appendIfMissing("", "xyz", null) = "xyz"  StringUtils.appendIfMissing("abc", "xyz", new CharSequence[]{null}) = "abcxyz"  StringUtils.appendIfMissing("abc", "xyz", "") = "abc"  StringUtils.appendIfMissing("abc", "xyz", "mno") = "abcxyz"  StringUtils.appendIfMissing("abcxyz", "xyz", "mno") = "abcxyz"  StringUtils.appendIfMissing("abcmno", "xyz", "mno") = "abcmno"  StringUtils.appendIfMissing("abcXYZ", "xyz", "mno") = "abcXYZxyz"  StringUtils.appendIfMissing("abcMNO", "xyz", "mno") = "abcMNOxyz"
@param `str` The string.
@param `suffix` The suffix to append to the end of the string.
@param `suffixes` Additional suffixes that are valid terminators.
@return A new String if suffix was appened, the same string otherwise.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: appendIfMissingIgnoreCase
param_types_key: String,CharSequence,CharSequence[]
signature_text:
public static String appendIfMissingIgnoreCase(String str, CharSequence suffix, CharSequence[] suffixes)

comment:
Appends the suffix to the end of the string if the string does not already end, case insensitive, with any of the suffixes.
StringUtils.appendIfMissingIgnoreCase(null, null) = null  StringUtils.appendIfMissingIgnoreCase("abc", null) = "abc"  StringUtils.appendIfMissingIgnoreCase("", "xyz") = "xyz"  StringUtils.appendIfMissingIgnoreCase("abc", "xyz") = "abcxyz"  StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz") = "abcxyz"  StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz") = "abcXYZ"
With additional suffixes,
StringUtils.appendIfMissingIgnoreCase(null, null, null) = null  StringUtils.appendIfMissingIgnoreCase("abc", null, null) = "abc"  StringUtils.appendIfMissingIgnoreCase("", "xyz", null) = "xyz"  StringUtils.appendIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "abcxyz"  StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "") = "abc"  StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "mno") = "axyz"  StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz", "mno") = "abcxyz"  StringUtils.appendIfMissingIgnoreCase("abcmno", "xyz", "mno") = "abcmno"  StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz", "mno") = "abcXYZ"  StringUtils.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno") = "abcMNO"
@param `str` The string.
@param `suffix` The suffix to append to the end of the string.
@param `suffixes` Additional suffixes that are valid terminators.
@return A new String if suffix was appened, the same string otherwise.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: capitalize
param_types_key: String
signature_text: public static String capitalize(String str)
comment:
Capitalizes a String changing the first letter to title case as per Character#toTitleCase(char). No other letters are changed.
For a word based algorithm, see org.apache.commons.lang3.text.WordUtils#capitalize(String). A ` null` input String returns ` null`.
StringUtils.capitalize(null)  = null  StringUtils.capitalize("")    = ""  StringUtils.capitalize("cat") = "Cat"  StringUtils.capitalize("cAt") = "CAt"
@see org.apache.commons.lang3.text.WordUtils#capitalize(String)
@see ##uncapitalize(String)
@param `str` the String to capitalize, may be null
@return the capitalized String, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: center
param_types_key: String,int
signature_text: public static String center(String str, int size)
comment:
Centers a String in a larger String of size ` size` using the space character (' ').
If the size is less than the String length, the String is returned. A ` null` String returns ` null`. A negative size is treated as zero.
Equivalent to ` center(str, size, " ")`.
StringUtils.center(null, *)   = null  StringUtils.center("", 4)     = "    "  StringUtils.center("ab", -1)  = "ab"  StringUtils.center("ab", 4)   = " ab "  StringUtils.center("abcd", 2) = "abcd"  StringUtils.center("a", 4)    = " a  "
@param `str` the String to center, may be null
@param `size` the int size of new String, negative treated as zero
@return centered String, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: center
param_types_key: String,int,char
signature_text: public static String center(String str, int size, char padChar)
comment:
Centers a String in a larger String of size ` size`. Uses a supplied character as the value to pad the String with.
If the size is less than the String length, the String is returned. A ` null` String returns ` null`. A negative size is treated as zero.
StringUtils.center(null, *, *)     = null  StringUtils.center("", 4, ' ')     = "    "  StringUtils.center("ab", -1, ' ')  = "ab"  StringUtils.center("ab", 4, ' ')   = " ab "  StringUtils.center("abcd", 2, ' ') = "abcd"  StringUtils.center("a", 4, ' ')    = " a  "  StringUtils.center("a", 4, 'y')    = "yayy"
@param `str` the String to center, may be null
@param `size` the int size of new String, negative treated as zero
@param `padChar` the character to pad the new String with
@return centered String, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: center
param_types_key: String,int,String
signature_text: public static String center(String str, int size, String padStr)
comment:
Centers a String in a larger String of size ` size`. Uses a supplied String as the value to pad the String with.
If the size is less than the String length, the String is returned. A ` null` String returns ` null`. A negative size is treated as zero.
StringUtils.center(null, *, *)     = null  StringUtils.center("", 4, " ")     = "    "  StringUtils.center("ab", -1, " ")  = "ab"  StringUtils.center("ab", 4, " ")   = " ab "  StringUtils.center("abcd", 2, " ") = "abcd"  StringUtils.center("a", 4, " ")    = " a  "  StringUtils.center("a", 4, "yz")   = "yayz"  StringUtils.center("abc", 7, null) = "  abc  "  StringUtils.center("abc", 7, "")   = "  abc  "
@param `str` the String to center, may be null
@param `size` the int size of new String, negative treated as zero
@param `padStr` the String to pad the new String with, must not be null or empty
@return centered String, ` null` if null String input
@throws `IllegalArgumentException` if padStr is ` null` or empty


class_name: kd.bos.dataentity.utils.StringUtils
method_name: contains
param_types_key: CharSequence,int
signature_text: public static boolean contains(CharSequence seq, int searchChar)
comment:
Checks if CharSequence contains a search character, handling ` null`. This method uses String#indexOf(int) if possible.
A ` null` or empty ("") CharSequence will return ` false`.
StringUtils.contains(null, *)    = false  StringUtils.contains("", *)      = false  StringUtils.contains("abc", 'a') = true  StringUtils.contains("abc", 'z') = false
@param `seq` the CharSequence to check, may be null
@param `searchChar` the character to find
@return true if the CharSequence contains the search character, false if not or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: contains
param_types_key: CharSequence,CharSequence
signature_text: public static boolean contains(CharSequence seq, CharSequence searchSeq)
comment:
Checks if CharSequence contains a search CharSequence, handling ` null`. This method uses String#indexOf(String) if possible.
A ` null` CharSequence will return ` false`.
StringUtils.contains(null, *)     = false  StringUtils.contains(*, null)     = false  StringUtils.contains("", "")      = true  StringUtils.contains("abc", "")   = true  StringUtils.contains("abc", "a")  = true  StringUtils.contains("abc", "z")  = false
@param `seq` the CharSequence to check, may be null
@param `searchSeq` the CharSequence to find, may be null
@return true if the CharSequence contains the search CharSequence, false if not or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: containsIgnoreCase
param_types_key: CharSequence,CharSequence
signature_text: public static boolean containsIgnoreCase(CharSequence str, CharSequence searchStr)
comment:
Checks if CharSequence contains a search CharSequence irrespective of case, handling ` null`. Case-insensitivity is defined as by String#equalsIgnoreCase(String).
A ` null` CharSequence will return ` false`.
StringUtils.contains(null, *) = false  StringUtils.contains(*, null) = false  StringUtils.contains("", "") = true  StringUtils.contains("abc", "") = true  StringUtils.contains("abc", "a") = true  StringUtils.contains("abc", "z") = false  StringUtils.contains("abc", "A") = true  StringUtils.contains("abc", "Z") = false
@param `str` the CharSequence to check, may be null
@param `searchStr` the CharSequence to find, may be null
@return true if the CharSequence contains the search CharSequence irrespective of case or false if not or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: containsNone
param_types_key: CharSequence,char[]
signature_text: public static boolean containsNone(CharSequence cs, char[] searchChars)
comment:
Checks that the CharSequence does not contain certain characters.
A ` null` CharSequence will return ` true`. A ` null` invalid character array will return ` true`. An empty CharSequence (length()=0) always returns true.
StringUtils.containsNone(null, *)       = true  StringUtils.containsNone(*, null)       = true  StringUtils.containsNone("", *)         = true  StringUtils.containsNone("ab", '')      = true  StringUtils.containsNone("abab", 'xyz') = true  StringUtils.containsNone("ab1", 'xyz')  = true  StringUtils.containsNone("abz", 'xyz')  = false
@param `cs` the CharSequence to check, may be null
@param `searchChars` an array of invalid chars, may be null
@return true if it contains none of the invalid chars, or is null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: containsNone
param_types_key: CharSequence,String
signature_text: public static boolean containsNone(CharSequence cs, String invalidChars)
comment:
Checks that the CharSequence does not contain certain characters.
A ` null` CharSequence will return ` true`. A ` null` invalid character array will return ` true`. An empty String ("") always returns true.
StringUtils.containsNone(null, *)       = true  StringUtils.containsNone(*, null)       = true  StringUtils.containsNone("", *)         = true  StringUtils.containsNone("ab", "")      = true  StringUtils.containsNone("abab", "xyz") = true  StringUtils.containsNone("ab1", "xyz")  = true  StringUtils.containsNone("abz", "xyz")  = false
@param `cs` the CharSequence to check, may be null
@param `invalidChars` a String of invalid chars, may be null
@return true if it contains none of the invalid chars, or is null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: containsWhitespace
param_types_key: CharSequence
signature_text: public static boolean containsWhitespace(CharSequence seq)
comment:
Check whether the given CharSequence contains any whitespace characters.
@see Character#isWhitespace
@param `seq` the CharSequence to check (may be ` null`)
@return ` true` if the CharSequence is not empty and contains at least 1 whitespace character


class_name: kd.bos.dataentity.utils.StringUtils
method_name: countMatches
param_types_key: CharSequence,CharSequence
signature_text: public static int countMatches(CharSequence str, CharSequence sub)
comment:
Counts how many times the substring appears in the larger string.
A ` null` or empty ("") String input returns ` 0`.
StringUtils.countMatches(null, *)       = 0  StringUtils.countMatches("", *)         = 0  StringUtils.countMatches("abba", null)  = 0  StringUtils.countMatches("abba", "")    = 0  StringUtils.countMatches("abba", "a")   = 2  StringUtils.countMatches("abba", "ab")  = 1  StringUtils.countMatches("abba", "xxx") = 0
@param `str` the CharSequence to check, may be null
@param `sub` the substring to count, may be null
@return the number of occurrences, 0 if either CharSequence is ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: countMatches
param_types_key: CharSequence,char
signature_text: public static int countMatches(CharSequence str, char ch)
comment:
Counts how many times the char appears in the given string.
A ` null` or empty ("") String input returns ` 0`.
StringUtils.countMatches(null, *)       = 0  StringUtils.countMatches("", *)         = 0  StringUtils.countMatches("abba", 0)  = 0  StringUtils.countMatches("abba", 'a')   = 2  StringUtils.countMatches("abba", 'b')  = 2  StringUtils.countMatches("abba", 'x') = 0
@param `str` the CharSequence to check, may be null
@param `ch` the char to count
@return the number of occurrences, 0 if the CharSequence is ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: defaultIfBlank
param_types_key: Object,Object
signature_text: public static CharSequence defaultIfBlank(T str, T defaultStr)
comment:
Returns either the passed in CharSequence, or if the CharSequence is whitespace, empty ("") or ` null`, the value of ` defaultStr`.
StringUtils.defaultIfBlank(null, "NULL")  = "NULL"  StringUtils.defaultIfBlank("", "NULL")    = "NULL"  StringUtils.defaultIfBlank(" ", "NULL")   = "NULL"  StringUtils.defaultIfBlank("bat", "NULL") = "bat"  StringUtils.defaultIfBlank("", null)      = null
@see StringUtils#defaultString(String, String)#defaultString(String, String)
@param `<T>` the specific kind of CharSequence
@param `str` the CharSequence to check, may be null
@param `defaultStr` the default CharSequence to return if the input is whitespace, empty ("") or ` null`, may be null
@return the passed in CharSequence, or the default


class_name: kd.bos.dataentity.utils.StringUtils
method_name: defaultIfEmpty
param_types_key: Object,Object
signature_text: public static CharSequence defaultIfEmpty(T str, T defaultStr)
comment:
Returns either the passed in CharSequence, or if the CharSequence is empty or ` null`, the value of ` defaultStr`.
StringUtils.defaultIfEmpty(null, "NULL")  = "NULL"  StringUtils.defaultIfEmpty("", "NULL")    = "NULL"  StringUtils.defaultIfEmpty(" ", "NULL")   = " "  StringUtils.defaultIfEmpty("bat", "NULL") = "bat"  StringUtils.defaultIfEmpty("", null)      = null
@see StringUtils#defaultString(String, String)#defaultString(String, String)
@param `<T>` the specific kind of CharSequence
@param `str` the CharSequence to check, may be null
@param `defaultStr` the default CharSequence to return if the input is empty ("") or ` null`, may be null
@return the passed in CharSequence, or the default


class_name: kd.bos.dataentity.utils.StringUtils
method_name: defaultString
param_types_key: String
signature_text: public static String defaultString(String str)
comment:
Returns either the passed in String, or if the String is ` null`, an empty String ("").
StringUtils.defaultString(null)  = ""  StringUtils.defaultString("")    = ""  StringUtils.defaultString("bat") = "bat"
@see ObjectUtils#toString(Object)#toString(Object)
@see kd.bos.dataentity.utils.String#valueOf(Object)
@param `str` the String to check, may be null
@return the passed in String, or the empty String if it was ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: defaultString
param_types_key: String,String
signature_text: public static String defaultString(String str, String defaultStr)
comment:
Returns either the passed in String, or if the String is ` null`, the value of ` defaultStr`.
StringUtils.defaultString(null, "NULL")  = "NULL"  StringUtils.defaultString("", "NULL")    = ""  StringUtils.defaultString("bat", "NULL") = "bat"
@see ObjectUtils#toString(Object,String)#toString(Object, String)
@see kd.bos.dataentity.utils.String#valueOf(Object)
@param `str` the String to check, may be null
@param `defaultStr` the default String to return if the input is ` null`, may be null
@return the passed in String, or the default if it was ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: deleteWhitespace
param_types_key: String
signature_text: public static String deleteWhitespace(String str)
comment:
Deletes all whitespaces from a String as defined by Character#isWhitespace(char).
StringUtils.deleteWhitespace(null)         = null  StringUtils.deleteWhitespace("")           = ""  StringUtils.deleteWhitespace("abc")        = "abc"  StringUtils.deleteWhitespace("   ab  c  ") = "abc"
@param `str` the String to delete whitespace from, may be null
@return the String without whitespaces, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: difference
param_types_key: String,String
signature_text: public static String difference(String str1, String str2)
comment:
Compares two Strings, and returns the portion where they differ. More precisely, return the remainder of the second String, starting from where it's different from the first. This means that the difference between "abc" and "ab" is the empty String and not "c".
For example, ` difference("i am a machine", "i am a robot") -> "robot"`.
StringUtils.difference(null, null) = null  StringUtils.difference("", "") = ""  StringUtils.difference("", "abc") = "abc"  StringUtils.difference("abc", "") = ""  StringUtils.difference("abc", "abc") = ""  StringUtils.difference("abc", "ab") = ""  StringUtils.difference("ab", "abxyz") = "xyz"  StringUtils.difference("abcde", "abxyz") = "xyz"  StringUtils.difference("abcde", "xyz") = "xyz"
@see ##indexOfDifference(CharSequence,CharSequence)
@param `str1` the first String, may be null
@param `str2` the second String, may be null
@return the portion of str2 where it differs from str1; returns the empty String if they are equal


class_name: kd.bos.dataentity.utils.StringUtils
method_name: endsWith
param_types_key: CharSequence,CharSequence
signature_text: public static boolean endsWith(CharSequence str, CharSequence suffix)
comment:
Check if a CharSequence ends with a specified suffix.
` null`s are handled without exceptions. Two ` null` references are considered to be equal. The comparison is case sensitive.
StringUtils.endsWith(null, null)      = true  StringUtils.endsWith(null, "def")     = false  StringUtils.endsWith("abcdef", null)  = false  StringUtils.endsWith("abcdef", "def") = true  StringUtils.endsWith("ABCDEF", "def") = false  StringUtils.endsWith("ABCDEF", "cde") = false
@see String#endsWith(String)
@param `str` the CharSequence to check, may be null
@param `suffix` the suffix to find, may be null
@return ` true` if the CharSequence ends with the suffix, case sensitive, or both ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: endsWithAny
param_types_key: CharSequence,CharSequence[]
signature_text: public static boolean endsWithAny(CharSequence string, CharSequence[] searchStrings)
comment:
Check if a CharSequence ends with any of an array of specified strings.
StringUtils.endsWithAny(null, null)      = false  StringUtils.endsWithAny(null, new String[] {"abc"})  = false  StringUtils.endsWithAny("abcxyz", null)     = false  StringUtils.endsWithAny("abcxyz", new String[] {""}) = true  StringUtils.endsWithAny("abcxyz", new String[] {"xyz"}) = true  StringUtils.endsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true
@param `string` the CharSequence to check, may be null
@param `searchStrings` the CharSequences to find, may be null or empty
@return ` true` if the CharSequence ends with any of the the prefixes, case insensitive, or both ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: endsWithIgnoreCase
param_types_key: CharSequence,CharSequence
signature_text: public static boolean endsWithIgnoreCase(CharSequence str, CharSequence suffix)
comment:
Case insensitive check if a CharSequence ends with a specified suffix.
` null`s are handled without exceptions. Two ` null` references are considered to be equal. The comparison is case insensitive.
StringUtils.endsWithIgnoreCase(null, null)      = true  StringUtils.endsWithIgnoreCase(null, "def")     = false  StringUtils.endsWithIgnoreCase("abcdef", null)  = false  StringUtils.endsWithIgnoreCase("abcdef", "def") = true  StringUtils.endsWithIgnoreCase("ABCDEF", "def") = true  StringUtils.endsWithIgnoreCase("ABCDEF", "cde") = false
@see String#endsWith(String)
@param `str` the CharSequence to check, may be null
@param `suffix` the suffix to find, may be null
@return ` true` if the CharSequence ends with the suffix, case insensitive, or both ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: equals
param_types_key: CharSequence,CharSequence
signature_text: public static boolean equals(CharSequence cs1, CharSequence cs2)
comment:
Compares two CharSequences, returning ` true` if they represent equal sequences of characters.
` null`s are handled without exceptions. Two ` null` references are considered to be equal. The comparison is case sensitive.
StringUtils.equals(null, null)   = true  StringUtils.equals(null, "abc")  = false  StringUtils.equals("abc", null)  = false  StringUtils.equals("abc", "abc") = true  StringUtils.equals("abc", "ABC") = false
@see kd.bos.dataentity.utils.Object#equals(Object)
@param `cs1` the first CharSequence, may be ` null`
@param `cs2` the second CharSequence, may be ` null`
@return ` true` if the CharSequences are equal (case-sensitive), or both ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: equalsIgnoreCase
param_types_key: CharSequence,CharSequence
signature_text: public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2)
comment:
Compares two CharSequences, returning ` true` if they represent equal sequences of characters, ignoring case.
` null`s are handled without exceptions. Two ` null` references are considered equal. Comparison is case insensitive.
StringUtils.equalsIgnoreCase(null, null)   = true  StringUtils.equalsIgnoreCase(null, "abc")  = false  StringUtils.equalsIgnoreCase("abc", null)  = false  StringUtils.equalsIgnoreCase("abc", "abc") = true  StringUtils.equalsIgnoreCase("abc", "ABC") = true
@param `str1` the first CharSequence, may be null
@param `str2` the second CharSequence, may be null
@return ` true` if the CharSequence are equal, case insensitive, or both ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: getCommonPrefix
param_types_key: String[]
signature_text: public static String getCommonPrefix(String[] strs)
comment:
Compares all Strings in an array and returns the initial sequence of characters that is common to all of them.
For example, `getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) -> "i am a "`
StringUtils.getCommonPrefix(null) = ""  StringUtils.getCommonPrefix(new String[] {}) = ""  StringUtils.getCommonPrefix(new String[] {"abc"}) = "abc"  StringUtils.getCommonPrefix(new String[] {null, null}) = ""  StringUtils.getCommonPrefix(new String[] {"", ""}) = ""  StringUtils.getCommonPrefix(new String[] {"", null}) = ""  StringUtils.getCommonPrefix(new String[] {"abc", null, null}) = ""  StringUtils.getCommonPrefix(new String[] {null, null, "abc"}) = ""  StringUtils.getCommonPrefix(new String[] {"", "abc"}) = ""  StringUtils.getCommonPrefix(new String[] {"abc", ""}) = ""  StringUtils.getCommonPrefix(new String[] {"abc", "abc"}) = "abc"  StringUtils.getCommonPrefix(new String[] {"abc", "a"}) = "a"  StringUtils.getCommonPrefix(new String[] {"ab", "abxyz"}) = "ab"  StringUtils.getCommonPrefix(new String[] {"abcde", "abxyz"}) = "ab"  StringUtils.getCommonPrefix(new String[] {"abcde", "xyz"}) = ""  StringUtils.getCommonPrefix(new String[] {"xyz", "abcde"}) = ""  StringUtils.getCommonPrefix(new String[] {"i am a machine", "i am a robot"}) = "i am a "
@param `strs` array of String objects, entries may be null
@return the initial sequence of characters that are common to all Strings in the array; empty String if the array is null, the elements are all null or if there is no common prefix.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: getFuzzyDistance
param_types_key: CharSequence,CharSequence,Locale
signature_text: public static int getFuzzyDistance(CharSequence term, CharSequence query, java.util.Locale locale)
comment:
Find the Fuzzy Distance which indicates the similarity score between two Strings.
This string matching algorithm is similar to the algorithms of editors such as Sublime Text, TextMate, Atom and others. One point is given for every matched character. Subsequent matches yield two bonus points. A higher score indicates a higher similarity.
StringUtils.getFuzzyDistance(null, null, null)                                    = IllegalArgumentException  StringUtils.getFuzzyDistance("", "", Locale.ENGLISH)                              = 0  StringUtils.getFuzzyDistance("Workshop", "b", Locale.ENGLISH)                     = 0  StringUtils.getFuzzyDistance("Room", "o", Locale.ENGLISH)                         = 1  StringUtils.getFuzzyDistance("Workshop", "w", Locale.ENGLISH)                     = 1  StringUtils.getFuzzyDistance("Workshop", "ws", Locale.ENGLISH)                    = 2  StringUtils.getFuzzyDistance("Workshop", "wo", Locale.ENGLISH)                    = 4  StringUtils.getFuzzyDistance("Apache Software Foundation", "asf", Locale.ENGLISH) = 3
@param `term` a full term that should be matched against, must not be null
@param `query` the query that will be matched against a term, must not be null
@param `locale` This string matching logic is case insensitive. A locale is necessary to normalize both Strings to lower case.
@return result score
@throws `IllegalArgumentException` if either String input ` null` or Locale input ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: getJaroWinklerDistance
param_types_key: CharSequence,CharSequence
signature_text: public static double getJaroWinklerDistance(CharSequence first, CharSequence second)
comment:
Find the Jaro Winkler Distance which indicates the similarity score between two Strings.
The Jaro measure is the weighted sum of percentage of matched characters from each file and transposed characters. Winkler increased this measure for matching initial characters.
This implementation is based on the Jaro Winkler similarity algorithm from <http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance>.
StringUtils.getJaroWinklerDistance(null, null)          = IllegalArgumentException  StringUtils.getJaroWinklerDistance("","")               = 0.0  StringUtils.getJaroWinklerDistance("","a")              = 0.0  StringUtils.getJaroWinklerDistance("aaapppp", "")       = 0.0  StringUtils.getJaroWinklerDistance("frog", "fog")       = 0.93  StringUtils.getJaroWinklerDistance("fly", "ant")        = 0.0  StringUtils.getJaroWinklerDistance("elephant", "hippo") = 0.44  StringUtils.getJaroWinklerDistance("hippo", "elephant") = 0.44  StringUtils.getJaroWinklerDistance("hippo", "zzzzzzzz") = 0.0  StringUtils.getJaroWinklerDistance("hello", "hallo")    = 0.88  StringUtils.getJaroWinklerDistance("ABC Corporation", "ABC Corp") = 0.91  StringUtils.getJaroWinklerDistance("D N H Enterprises Inc", "D & H Enterprises, Inc.") = 0.93  StringUtils.getJaroWinklerDistance("My Gym Children's Fitness Center", "My Gym. Childrens Fitness") = 0.94  StringUtils.getJaroWinklerDistance("PENNSYLVANIA", "PENNCISYLVNIA")    = 0.9
@param `first` the first String, must not be null
@param `second` the second String, must not be null
@return result distance
@throws `IllegalArgumentException` if either String input ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: getLevenshteinDistance
param_types_key: CharSequence,CharSequence
signature_text: public static int getLevenshteinDistance(CharSequence s, CharSequence t)
comment:
Find the Levenshtein distance between two Strings.
This is the number of changes needed to change one String into another, where each change is a single character modification (deletion, insertion or substitution).
The previous implementation of the Levenshtein distance algorithm was from <http://www.merriampark.com/ld.htm>
Chas Emerick has written an implementation in Java, which avoids an OutOfMemoryError which can occur when my Java implementation is used with very large strings. This implementation of the Levenshtein distance algorithm is from <http://www.merriampark.com/ldjava.htm>
StringUtils.getLevenshteinDistance(null, *)             = IllegalArgumentException  StringUtils.getLevenshteinDistance(*, null)             = IllegalArgumentException  StringUtils.getLevenshteinDistance("","")               = 0  StringUtils.getLevenshteinDistance("","a")              = 1  StringUtils.getLevenshteinDistance("aaapppp", "")       = 7  StringUtils.getLevenshteinDistance("frog", "fog")       = 1  StringUtils.getLevenshteinDistance("fly", "ant")        = 3  StringUtils.getLevenshteinDistance("elephant", "hippo") = 7  StringUtils.getLevenshteinDistance("hippo", "elephant") = 7  StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz") = 8  StringUtils.getLevenshteinDistance("hello", "hallo")    = 1
@param `s` the first String, must not be null
@param `t` the second String, must not be null
@return result distance
@throws `IllegalArgumentException` if either String input ` null`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: getLevenshteinDistance
param_types_key: CharSequence,CharSequence,int
signature_text: public static int getLevenshteinDistance(CharSequence s, CharSequence t, int threshold)
comment:
Find the Levenshtein distance between two Strings if it's less than or equal to a given threshold.
This is the number of changes needed to change one String into another, where each change is a single character modification (deletion, insertion or substitution).
This implementation follows from Algorithms on Strings, Trees and Sequences by Dan Gusfield and Chas Emerick's implementation of the Levenshtein distance algorithm from <http://www.merriampark.com/ld.htm>
StringUtils.getLevenshteinDistance(null, *, *)             = IllegalArgumentException  StringUtils.getLevenshteinDistance(*, null, *)             = IllegalArgumentException  StringUtils.getLevenshteinDistance(*, *, -1)               = IllegalArgumentException  StringUtils.getLevenshteinDistance("","", 0)               = 0  StringUtils.getLevenshteinDistance("aaapppp", "", 8)       = 7  StringUtils.getLevenshteinDistance("aaapppp", "", 7)       = 7  StringUtils.getLevenshteinDistance("aaapppp", "", 6))      = -1  StringUtils.getLevenshteinDistance("elephant", "hippo", 7) = 7  StringUtils.getLevenshteinDistance("elephant", "hippo", 6) = -1  StringUtils.getLevenshteinDistance("hippo", "elephant", 7) = 7  StringUtils.getLevenshteinDistance("hippo", "elephant", 6) = -1
@param `s` the first String, must not be null
@param `t` the second String, must not be null
@param `threshold` the target threshold, must not be negative
@return result distance, or ` -1` if the distance would be greater than the threshold
@throws `IllegalArgumentException` if either String input ` null` or negative threshold


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOf
param_types_key: CharSequence,int
signature_text: public static int indexOf(CharSequence seq, int searchChar)
comment:
Finds the first index within a CharSequence, handling ` null`. This method uses int) if possible.
A ` null` or empty ("") CharSequence will return ` INDEX_NOT_FOUND (-1)`.
StringUtils.indexOf(null, *)         = -1  StringUtils.indexOf("", *)           = -1  StringUtils.indexOf("aabaabaa", 'a') = 0  StringUtils.indexOf("aabaabaa", 'b') = 2
@param `seq` the CharSequence to check, may be null
@param `searchChar` the character to find
@return the first index of the search character, -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOf
param_types_key: CharSequence,int,int
signature_text: public static int indexOf(CharSequence seq, int searchChar, int startPos)
comment:
Finds the first index within a CharSequence from a start position, handling ` null`. This method uses int) if possible.
A ` null` or empty ("") CharSequence will return ` (INDEX_NOT_FOUND) -1`. A negative start position is treated as zero. A start position greater than the string length returns ` -1`.
StringUtils.indexOf(null, *, *)          = -1  StringUtils.indexOf("", *, *)            = -1  StringUtils.indexOf("aabaabaa", 'b', 0)  = 2  StringUtils.indexOf("aabaabaa", 'b', 3)  = 5  StringUtils.indexOf("aabaabaa", 'b', 9)  = -1  StringUtils.indexOf("aabaabaa", 'b', -1) = 2
@param `seq` the CharSequence to check, may be null
@param `searchChar` the character to find
@param `startPos` the start position, negative treated as zero
@return the first index of the search character (always ≥ startPos), -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOf
param_types_key: CharSequence,CharSequence
signature_text: public static int indexOf(CharSequence seq, CharSequence searchSeq)
comment:
Finds the first index within a CharSequence, handling ` null`. This method uses int) if possible.
A ` null` CharSequence will return ` -1`.
StringUtils.indexOf(null, *)          = -1  StringUtils.indexOf(*, null)          = -1  StringUtils.indexOf("", "")           = 0  StringUtils.indexOf("", *)            = -1 (except when * = "")  StringUtils.indexOf("aabaabaa", "a")  = 0  StringUtils.indexOf("aabaabaa", "b")  = 2  StringUtils.indexOf("aabaabaa", "ab") = 1  StringUtils.indexOf("aabaabaa", "")   = 0
@param `seq` the CharSequence to check, may be null
@param `searchSeq` the CharSequence to find, may be null
@return the first index of the search CharSequence, -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOf
param_types_key: CharSequence,CharSequence,int
signature_text: public static int indexOf(CharSequence seq, CharSequence searchSeq, int startPos)
comment:
Finds the first index within a CharSequence, handling ` null`. This method uses int) if possible.
A ` null` CharSequence will return ` -1`. A negative start position is treated as zero. An empty ("") search CharSequence always matches. A start position greater than the string length only matches an empty search CharSequence.
StringUtils.indexOf(null, *, *)          = -1  StringUtils.indexOf(*, null, *)          = -1  StringUtils.indexOf("", "", 0)           = 0  StringUtils.indexOf("", *, 0)            = -1 (except when * = "")  StringUtils.indexOf("aabaabaa", "a", 0)  = 0  StringUtils.indexOf("aabaabaa", "b", 0)  = 2  StringUtils.indexOf("aabaabaa", "ab", 0) = 1  StringUtils.indexOf("aabaabaa", "b", 3)  = 5  StringUtils.indexOf("aabaabaa", "b", 9)  = -1  StringUtils.indexOf("aabaabaa", "b", -1) = 2  StringUtils.indexOf("aabaabaa", "", 2)   = 2  StringUtils.indexOf("abc", "", 9)        = 3
@param `seq` the CharSequence to check, may be null
@param `searchSeq` the CharSequence to find, may be null
@param `startPos` the start position, negative treated as zero
@return the first index of the search CharSequence (always ≥ startPos), -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOfAny
param_types_key: CharSequence,CharSequence[]
signature_text: public static int indexOfAny(CharSequence str, CharSequence[] searchStrs)
comment:
Find the first index of any of a set of potential substrings.
A ` null` CharSequence will return ` -1`. A ` null` or zero length search array will return ` -1`. A ` null` search array entry will be ignored, but a search array containing "" will return ` 0` if ` str` is not null. This method uses String#indexOf(String) if possible.
StringUtils.indexOfAny(null, *)                     = -1  StringUtils.indexOfAny(*, null)                     = -1  StringUtils.indexOfAny(*, [])                       = -1  StringUtils.indexOfAny("zzabyycdxx", ["ab","cd"])   = 2  StringUtils.indexOfAny("zzabyycdxx", ["cd","ab"])   = 2  StringUtils.indexOfAny("zzabyycdxx", ["mn","op"])   = -1  StringUtils.indexOfAny("zzabyycdxx", ["zab","aby"]) = 1  StringUtils.indexOfAny("zzabyycdxx", [""])          = 0  StringUtils.indexOfAny("", [""])                    = 0  StringUtils.indexOfAny("", ["a"])                   = -1
@param `str` the CharSequence to check, may be null
@param `searchStrs` the CharSequences to search for, may be null
@return the first index of any of the searchStrs in str, -1 if no match


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOfAnyBut
param_types_key: CharSequence,CharSequence
signature_text: public static int indexOfAnyBut(CharSequence seq, CharSequence searchChars)
comment:
Search a CharSequence to find the first index of any character not in the given set of characters.
A ` null` CharSequence will return ` -1`. A ` null` or empty search string will return ` -1`.
StringUtils.indexOfAnyBut(null, *)            = -1  StringUtils.indexOfAnyBut("", *)              = -1  StringUtils.indexOfAnyBut(*, null)            = -1  StringUtils.indexOfAnyBut(*, "")              = -1  StringUtils.indexOfAnyBut("zzabyycdxx", "za") = 3  StringUtils.indexOfAnyBut("zzabyycdxx", "")   = -1  StringUtils.indexOfAnyBut("aba","ab")         = -1
@param `seq` the CharSequence to check, may be null
@param `searchChars` the chars to search for, may be null
@return the index of any of the chars, -1 if no match or null input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOfDifference
param_types_key: CharSequence,CharSequence
signature_text: public static int indexOfDifference(CharSequence cs1, CharSequence cs2)
comment:
Compares two CharSequences, and returns the index at which the CharSequences begin to differ.
For example, ` indexOfDifference("i am a machine", "i am a robot") -> 7`
StringUtils.indexOfDifference(null, null) = -1  StringUtils.indexOfDifference("", "") = -1  StringUtils.indexOfDifference("", "abc") = 0  StringUtils.indexOfDifference("abc", "") = 0  StringUtils.indexOfDifference("abc", "abc") = -1  StringUtils.indexOfDifference("ab", "abxyz") = 2  StringUtils.indexOfDifference("abcde", "abxyz") = 2  StringUtils.indexOfDifference("abcde", "xyz") = 0
@param `cs1` the first CharSequence, may be null
@param `cs2` the second CharSequence, may be null
@return the index where cs1 and cs2 begin to differ; -1 if they are equal


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOfDifference
param_types_key: CharSequence[]
signature_text: public static int indexOfDifference(CharSequence[] css)
comment:
Compares all CharSequences in an array and returns the index at which the CharSequences begin to differ.
For example, `indexOfDifference(new String[] {"i am a machine", "i am a robot"}) -> 7`
StringUtils.indexOfDifference(null) = -1  StringUtils.indexOfDifference(new String[] {}) = -1  StringUtils.indexOfDifference(new String[] {"abc"}) = -1  StringUtils.indexOfDifference(new String[] {null, null}) = -1  StringUtils.indexOfDifference(new String[] {"", ""}) = -1  StringUtils.indexOfDifference(new String[] {"", null}) = 0  StringUtils.indexOfDifference(new String[] {"abc", null, null}) = 0  StringUtils.indexOfDifference(new String[] {null, null, "abc"}) = 0  StringUtils.indexOfDifference(new String[] {"", "abc"}) = 0  StringUtils.indexOfDifference(new String[] {"abc", ""}) = 0  StringUtils.indexOfDifference(new String[] {"abc", "abc"}) = -1  StringUtils.indexOfDifference(new String[] {"abc", "a"}) = 1  StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}) = 2  StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}) = 2  StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}) = 0  StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}) = 0  StringUtils.indexOfDifference(new String[] {"i am a machine", "i am a robot"}) = 7
@param `css` array of CharSequences, entries may be null
@return the index where the strings begin to differ; -1 if they are all equal


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOfIgnoreCase
param_types_key: CharSequence,CharSequence
signature_text: public static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr)
comment:
Case in-sensitive find of the first index within a CharSequence.
A ` null` CharSequence will return ` -1`. A negative start position is treated as zero. An empty ("") search CharSequence always matches. A start position greater than the string length only matches an empty search CharSequence.
StringUtils.indexOfIgnoreCase(null, *)          = -1  StringUtils.indexOfIgnoreCase(*, null)          = -1  StringUtils.indexOfIgnoreCase("", "")           = 0  StringUtils.indexOfIgnoreCase("aabaabaa", "a")  = 0  StringUtils.indexOfIgnoreCase("aabaabaa", "b")  = 2  StringUtils.indexOfIgnoreCase("aabaabaa", "ab") = 1
@param `str` the CharSequence to check, may be null
@param `searchStr` the CharSequence to find, may be null
@return the first index of the search CharSequence, -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: indexOfIgnoreCase
param_types_key: CharSequence,CharSequence,int
signature_text: public static int indexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)
comment:
Case in-sensitive find of the first index within a CharSequence from the specified position.
A ` null` CharSequence will return ` -1`. A negative start position is treated as zero. An empty ("") search CharSequence always matches. A start position greater than the string length only matches an empty search CharSequence.
StringUtils.indexOfIgnoreCase(null, *, *)          = -1  StringUtils.indexOfIgnoreCase(*, null, *)          = -1  StringUtils.indexOfIgnoreCase("", "", 0)           = 0  StringUtils.indexOfIgnoreCase("aabaabaa", "A", 0)  = 0  StringUtils.indexOfIgnoreCase("aabaabaa", "B", 0)  = 2  StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0) = 1  StringUtils.indexOfIgnoreCase("aabaabaa", "B", 3)  = 5  StringUtils.indexOfIgnoreCase("aabaabaa", "B", 9)  = -1  StringUtils.indexOfIgnoreCase("aabaabaa", "B", -1) = 2  StringUtils.indexOfIgnoreCase("aabaabaa", "", 2)   = 2  StringUtils.indexOfIgnoreCase("abc", "", 9)        = 3
@param `str` the CharSequence to check, may be null
@param `searchStr` the CharSequence to find, may be null
@param `startPos` the start position, negative treated as zero
@return the first index of the search CharSequence (always ≥ startPos), -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAllLowerCase
param_types_key: CharSequence
signature_text: public static boolean isAllLowerCase(CharSequence cs)
comment:
Checks if the CharSequence contains only lowercase characters.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` false`.
StringUtils.isAllLowerCase(null)   = false  StringUtils.isAllLowerCase("")     = false  StringUtils.isAllLowerCase("  ")   = false  StringUtils.isAllLowerCase("abc")  = true  StringUtils.isAllLowerCase("abC")  = false  StringUtils.isAllLowerCase("ab c") = false  StringUtils.isAllLowerCase("ab1c") = false  StringUtils.isAllLowerCase("ab/c") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains lowercase characters, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAllUpperCase
param_types_key: CharSequence
signature_text: public static boolean isAllUpperCase(CharSequence cs)
comment:
Checks if the CharSequence contains only uppercase characters.
` null` will return ` false`. An empty String (length()=0) will return ` false`.
StringUtils.isAllUpperCase(null)   = false  StringUtils.isAllUpperCase("")     = false  StringUtils.isAllUpperCase("  ")   = false  StringUtils.isAllUpperCase("ABC")  = true  StringUtils.isAllUpperCase("aBC")  = false  StringUtils.isAllUpperCase("A C")  = false  StringUtils.isAllUpperCase("A1C")  = false  StringUtils.isAllUpperCase("A/C")  = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains uppercase characters, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAlpha
param_types_key: CharSequence
signature_text: public static boolean isAlpha(CharSequence cs)
comment:
Checks if the CharSequence contains only Unicode letters.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` false`.
StringUtils.isAlpha(null)   = false  StringUtils.isAlpha("")     = false  StringUtils.isAlpha("  ")   = false  StringUtils.isAlpha("abc")  = true  StringUtils.isAlpha("ab2c") = false  StringUtils.isAlpha("ab-c") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains letters, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAlphaSpace
param_types_key: CharSequence
signature_text: public static boolean isAlphaSpace(CharSequence cs)
comment:
Checks if the CharSequence contains only Unicode letters and space (' ').
` null` will return ` false` An empty CharSequence (length()=0) will return ` true`.
StringUtils.isAlphaSpace(null)   = false  StringUtils.isAlphaSpace("")     = true  StringUtils.isAlphaSpace("  ")   = true  StringUtils.isAlphaSpace("abc")  = true  StringUtils.isAlphaSpace("ab c") = true  StringUtils.isAlphaSpace("ab2c") = false  StringUtils.isAlphaSpace("ab-c") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains letters and space, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAlphanumeric
param_types_key: CharSequence
signature_text: public static boolean isAlphanumeric(CharSequence cs)
comment:
Checks if the CharSequence contains only Unicode letters or digits.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` false`.
StringUtils.isAlphanumeric(null)   = false  StringUtils.isAlphanumeric("")     = false  StringUtils.isAlphanumeric("  ")   = false  StringUtils.isAlphanumeric("abc")  = true  StringUtils.isAlphanumeric("ab c") = false  StringUtils.isAlphanumeric("ab2c") = true  StringUtils.isAlphanumeric("ab-c") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains letters or digits, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAlphanumericSpace
param_types_key: CharSequence
signature_text: public static boolean isAlphanumericSpace(CharSequence cs)
comment:
Checks if the CharSequence contains only Unicode letters, digits or space (` ' '`).
` null` will return ` false`. An empty CharSequence (length()=0) will return ` true`.
StringUtils.isAlphanumericSpace(null)   = false  StringUtils.isAlphanumericSpace("")     = true  StringUtils.isAlphanumericSpace("  ")   = true  StringUtils.isAlphanumericSpace("abc")  = true  StringUtils.isAlphanumericSpace("ab c") = true  StringUtils.isAlphanumericSpace("ab2c") = true  StringUtils.isAlphanumericSpace("ab-c") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains letters, digits or space, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isAsciiPrintable
param_types_key: CharSequence
signature_text: public static boolean isAsciiPrintable(CharSequence cs)
comment:
Checks if the CharSequence contains only ASCII printable characters.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` true`.
StringUtils.isAsciiPrintable(null)     = false  StringUtils.isAsciiPrintable("")       = true  StringUtils.isAsciiPrintable(" ")      = true  StringUtils.isAsciiPrintable("Ceki")   = true  StringUtils.isAsciiPrintable("ab2c")   = true  StringUtils.isAsciiPrintable("!ab-c~") = true  StringUtils.isAsciiPrintable(" ") = true  StringUtils.isAsciiPrintable("!") = true  StringUtils.isAsciiPrintable("~") = true  StringUtils.isAsciiPrintable("") = false  StringUtils.isAsciiPrintable("Ceki Gülcü") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if every character is in the range 32 thru 126


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isBlank
param_types_key: CharSequence
signature_text: public static boolean isBlank(CharSequence cs)
comment:
Checks if a CharSequence is whitespace, empty ("") or null.
StringUtils.isBlank(null)      = true  StringUtils.isBlank("")        = true  StringUtils.isBlank(" ")       = true  StringUtils.isBlank("bob")     = false  StringUtils.isBlank("  bob  ") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if the CharSequence is null, empty or whitespace


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isBlank
param_types_key: Object
signature_text: public static boolean isBlank(Object cs)
comment:
检查目标对象是否为空字符串或null Iterable/Map 对象返回false check object==null or isBlack(object.toString())
@param `cs`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isEmpty
param_types_key: CharSequence
signature_text: public static boolean isEmpty(CharSequence cs)
comment:
Checks if a CharSequence is empty ("") or null.
StringUtils.isEmpty(null)      = true  StringUtils.isEmpty("")        = true  StringUtils.isEmpty(" ")       = false  StringUtils.isEmpty("bob")     = false  StringUtils.isEmpty("  bob  ") = false
NOTE: This method changed in Lang version 2.0. It no longer trims the CharSequence. That functionality is available in isBlank().
@param `cs` the CharSequence to check, may be null
@return ` true` if the CharSequence is empty or null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isNotBlank
param_types_key: CharSequence
signature_text: public static boolean isNotBlank(CharSequence cs)
comment:
Checks if a CharSequence is not empty (""), not null and not whitespace only.
StringUtils.isNotBlank(null)      = false  StringUtils.isNotBlank("")        = false  StringUtils.isNotBlank(" ")       = false  StringUtils.isNotBlank("bob")     = true  StringUtils.isNotBlank("  bob  ") = true
@param `cs` the CharSequence to check, may be null
@return ` true` if the CharSequence is not empty and not null and not whitespace


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isNotEmpty
param_types_key: CharSequence
signature_text: public static boolean isNotEmpty(CharSequence cs)
comment:
Checks if a CharSequence is not empty ("") and not null.
StringUtils.isNotEmpty(null)      = false  StringUtils.isNotEmpty("")        = false  StringUtils.isNotEmpty(" ")       = true  StringUtils.isNotEmpty("bob")     = true  StringUtils.isNotEmpty("  bob  ") = true
@param `cs` the CharSequence to check, may be null
@return ` true` if the CharSequence is not empty and not null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isNumeric
param_types_key: CharSequence
signature_text: public static boolean isNumeric(CharSequence cs)
comment:
Checks if the CharSequence contains only Unicode digits. A decimal point is not a Unicode digit and returns false.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` false`.
Note that the method does not allow for a leading sign, either positive or negative. Also, if a String passes the numeric test, it may still generate a NumberFormatException when parsed by Integer.parseInt or Long.parseLong, e.g. if the value is outside the range for int or long respectively.
StringUtils.isNumeric(null)   = false  StringUtils.isNumeric("")     = false  StringUtils.isNumeric("  ")   = false  StringUtils.isNumeric("123")  = true  StringUtils.isNumeric("१२३")  = true  StringUtils.isNumeric("12 3") = false  StringUtils.isNumeric("ab2c") = false  StringUtils.isNumeric("12-3") = false  StringUtils.isNumeric("12.3") = false  StringUtils.isNumeric("-123") = false  StringUtils.isNumeric("+123") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains digits, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isNumericSpace
param_types_key: CharSequence
signature_text: public static boolean isNumericSpace(CharSequence cs)
comment:
Checks if the CharSequence contains only Unicode digits or space (` ' '`). A decimal point is not a Unicode digit and returns false.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` true`.
StringUtils.isNumericSpace(null)   = false  StringUtils.isNumericSpace("")     = true  StringUtils.isNumericSpace("  ")   = true  StringUtils.isNumericSpace("123")  = true  StringUtils.isNumericSpace("12 3") = true  StringUtils.isNumeric("१२३")  = true  StringUtils.isNumeric("१२ ३")  = true  StringUtils.isNumericSpace("ab2c") = false  StringUtils.isNumericSpace("12-3") = false  StringUtils.isNumericSpace("12.3") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains digits or space, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: isWhitespace
param_types_key: CharSequence
signature_text: public static boolean isWhitespace(CharSequence cs)
comment:
Checks if the CharSequence contains only whitespace.
` null` will return ` false`. An empty CharSequence (length()=0) will return ` true`.
StringUtils.isWhitespace(null)   = false  StringUtils.isWhitespace("")     = true  StringUtils.isWhitespace("  ")   = true  StringUtils.isWhitespace("abc")  = false  StringUtils.isWhitespace("ab2c") = false  StringUtils.isWhitespace("ab-c") = false
@param `cs` the CharSequence to check, may be null
@return ` true` if only contains whitespace, and is non-null


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Object[]
signature_text: public static String join(T[] elements)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No separator is added to the joined String. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null)            = null  StringUtils.join([])              = ""  StringUtils.join([null])          = ""  StringUtils.join(["a", "b", "c"]) = "abc"  StringUtils.join([null, "", "a"]) = "a"
@param `<T>` the specific type of values to join together
@param `elements` the values to join together, may be null
@return the joined String, ` null` if null array input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Object[],char
signature_text: public static String join(Object[] array, char separator)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *)               = null  StringUtils.join([], *)                 = ""  StringUtils.join([null], *)             = ""  StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"  StringUtils.join(["a", "b", "c"], null) = "abc"  StringUtils.join([null, "", "a"], ';')  = ";;a"
@param `array` the array of values to join together, may be null
@param `separator` the separator character to use
@return the joined String, ` null` if null array input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: long[],char
signature_text: public static String join(long[] array, char separator)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *)               = null  StringUtils.join([], *)                 = ""  StringUtils.join([null], *)             = ""  StringUtils.join([1, 2, 3], ';')  = "1;2;3"  StringUtils.join([1, 2, 3], null) = "123"
@param `array` ` the array of values to join together, may be null
@param `separator` ` the separator character to use
@return the joined String, ` null` if null array input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Object[],char,int,int
signature_text: public static String join(Object[] array, char separator, int startIndex, int endIndex)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *)               = null  StringUtils.join([], *)                 = ""  StringUtils.join([null], *)             = ""  StringUtils.join(["a", "b", "c"], ';')  = "a;b;c"  StringUtils.join(["a", "b", "c"], null) = "abc"  StringUtils.join([null, "", "a"], ';')  = ";;a"
@param `array` the array of values to join together, may be null
@param `separator` the separator character to use
@param `startIndex` the first index to start joining from. It is an error to pass in an end index past the end of the array
@param `endIndex` the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
@return the joined String, ` null` if null array input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: long[],char,int,int
signature_text: public static String join(long[] array, char separator, int startIndex, int endIndex)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *)               = null  StringUtils.join([], *)                 = ""  StringUtils.join([null], *)             = ""  StringUtils.join([1, 2, 3], ';')  = "1;2;3"  StringUtils.join([1, 2, 3], null) = "123"
@param `array` ` the array of values to join together, may be null
@param `separator` ` the separator character to use
@param `startIndex` ` the first index to start joining from. It is an error to pass in an end index past the end of the array
@param `endIndex` ` the index to stop joining from (exclusive). It is an error to pass in an end index past the end of the array
@return the joined String, ` null` if null array input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Object[],String
signature_text: public static String join(Object[] array, String separator)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. A ` null` separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *)                = null  StringUtils.join([], *)                  = ""  StringUtils.join([null], *)              = ""  StringUtils.join(["a", "b", "c"], "--")  = "a--b--c"  StringUtils.join(["a", "b", "c"], null)  = "abc"  StringUtils.join(["a", "b", "c"], "")    = "abc"  StringUtils.join([null, "", "a"], ',')   = ",,a"
@param `array` the array of values to join together, may be null
@param `separator` the separator character to use, null treated as ""
@return the joined String, ` null` if null array input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Object[],String,int,int
signature_text: public static String join(Object[] array, String separator, int startIndex, int endIndex)
comment:
Joins the elements of the provided array into a single String containing the provided list of elements.
No delimiter is added before or after the list. A ` null` separator is the same as an empty String (""). Null objects or empty strings within the array are represented by empty strings.
StringUtils.join(null, *, *, *)                = null  StringUtils.join([], *, *, *)                  = ""  StringUtils.join([null], *, *, *)              = ""  StringUtils.join(["a", "b", "c"], "--", 0, 3)  = "a--b--c"  StringUtils.join(["a", "b", "c"], "--", 1, 3)  = "b--c"  StringUtils.join(["a", "b", "c"], "--", 2, 3)  = "c"  StringUtils.join(["a", "b", "c"], "--", 2, 2)  = ""  StringUtils.join(["a", "b", "c"], null, 0, 3)  = "abc"  StringUtils.join(["a", "b", "c"], "", 0, 3)    = "abc"  StringUtils.join([null, "", "a"], ',', 0, 3)   = ",,a"
@param `array` the array of values to join together, may be null
@param `separator` the separator character to use, null treated as ""
@param `startIndex` the first index to start joining from.
@param `endIndex` the index to stop joining from (exclusive).
@return the joined String, ` null` if null array input; or the empty string if ` endIndex - startIndex <= 0`. The number of joined entries is given by ` endIndex - startIndex`
@throws `ArrayIndexOutOfBoundsException` ife ` startIndex < 0` or ` startIndex >= array.length()` or ` endIndex < 0` or ` endIndex > array.length()`


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Iterable,char
signature_text: public static String join(Iterable<?> iterable, char separator)
comment:
Joins the elements of the provided ` Iterable` into a single String containing the provided elements.
No delimiter is added before or after the list. Null objects or empty strings within the iteration are represented by empty strings.
See the examples here: #join(Object[],char).
@param `iterable` the ` Iterable` providing the values to join together, may be null
@param `separator` the separator character to use
@return the joined String, ` null` if null iterator input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: join
param_types_key: Iterable,String
signature_text: public static String join(Iterable<?> iterable, String separator)
comment:
Joins the elements of the provided ` Iterable` into a single String containing the provided elements.
No delimiter is added before or after the list. A ` null` separator is the same as an empty String ("").
See the examples here: #join(Object[],String).
@param `iterable` the ` Iterable` providing the values to join together, may be null
@param `separator` the separator character to use, null treated as ""
@return the joined String, ` null` if null iterator input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOf
param_types_key: CharSequence,int
signature_text: public static int lastIndexOf(CharSequence seq, int searchChar)
comment:
Finds the last index within a CharSequence, handling ` null`. This method uses String#lastIndexOf(int) if possible.
A ` null` or empty ("") CharSequence will return ` -1`.
StringUtils.lastIndexOf(null, *)         = -1  StringUtils.lastIndexOf("", *)           = -1  StringUtils.lastIndexOf("aabaabaa", 'a') = 7  StringUtils.lastIndexOf("aabaabaa", 'b') = 5
@param `seq` the CharSequence to check, may be null
@param `searchChar` the character to find
@return the last index of the search character, -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOf
param_types_key: CharSequence,int,int
signature_text: public static int lastIndexOf(CharSequence seq, int searchChar, int startPos)
comment:
Finds the last index within a CharSequence from a start position, handling ` null`. This method uses int) if possible.
A ` null` or empty ("") CharSequence will return ` -1`. A negative start position returns ` -1`. A start position greater than the string length searches the whole string. The search starts at the startPos and works backwards; matches starting after the start position are ignored.
StringUtils.lastIndexOf(null, *, *)          = -1  StringUtils.lastIndexOf("", *,  *)           = -1  StringUtils.lastIndexOf("aabaabaa", 'b', 8)  = 5  StringUtils.lastIndexOf("aabaabaa", 'b', 4)  = 2  StringUtils.lastIndexOf("aabaabaa", 'b', 0)  = -1  StringUtils.lastIndexOf("aabaabaa", 'b', 9)  = 5  StringUtils.lastIndexOf("aabaabaa", 'b', -1) = -1  StringUtils.lastIndexOf("aabaabaa", 'a', 0)  = 0
@param `seq` the CharSequence to check, may be null
@param `searchChar` the character to find
@param `startPos` the start position
@return the last index of the search character (always ≤ startPos), -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOf
param_types_key: CharSequence,CharSequence
signature_text: public static int lastIndexOf(CharSequence seq, CharSequence searchSeq)
comment:
Finds the last index within a CharSequence, handling ` null`. This method uses String#lastIndexOf(String) if possible.
A ` null` CharSequence will return ` -1`.
StringUtils.lastIndexOf(null, *)          = -1  StringUtils.lastIndexOf(*, null)          = -1  StringUtils.lastIndexOf("", "")           = 0  StringUtils.lastIndexOf("aabaabaa", "a")  = 7  StringUtils.lastIndexOf("aabaabaa", "b")  = 5  StringUtils.lastIndexOf("aabaabaa", "ab") = 4  StringUtils.lastIndexOf("aabaabaa", "")   = 8
@param `seq` the CharSequence to check, may be null
@param `searchSeq` the CharSequence to find, may be null
@return the last index of the search String, -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOf
param_types_key: CharSequence,CharSequence,int
signature_text: public static int lastIndexOf(CharSequence seq, CharSequence searchSeq, int startPos)
comment:
Finds the last index within a CharSequence, handling ` null`. This method uses int) if possible.
A ` null` CharSequence will return ` -1`. A negative start position returns ` -1`. An empty ("") search CharSequence always matches unless the start position is negative. A start position greater than the string length searches the whole string. The search starts at the startPos and works backwards; matches starting after the start position are ignored.
StringUtils.lastIndexOf(null, *, *)          = -1  StringUtils.lastIndexOf(*, null, *)          = -1  StringUtils.lastIndexOf("aabaabaa", "a", 8)  = 7  StringUtils.lastIndexOf("aabaabaa", "b", 8)  = 5  StringUtils.lastIndexOf("aabaabaa", "ab", 8) = 4  StringUtils.lastIndexOf("aabaabaa", "b", 9)  = 5  StringUtils.lastIndexOf("aabaabaa", "b", -1) = -1  StringUtils.lastIndexOf("aabaabaa", "a", 0)  = 0  StringUtils.lastIndexOf("aabaabaa", "b", 0)  = -1  StringUtils.lastIndexOf("aabaabaa", "b", 1)  = -1  StringUtils.lastIndexOf("aabaabaa", "b", 2)  = 2  StringUtils.lastIndexOf("aabaabaa", "ba", 2)  = -1  StringUtils.lastIndexOf("aabaabaa", "ba", 2)  = 2
@param `seq` the CharSequence to check, may be null
@param `searchSeq` the CharSequence to find, may be null
@param `startPos` the start position, negative treated as zero
@return the last index of the search CharSequence (always ≤ startPos), -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOfAny
param_types_key: CharSequence,CharSequence[]
signature_text: public static int lastIndexOfAny(CharSequence str, CharSequence[] searchStrs)
comment:
Find the latest index of any of a set of potential substrings.
A ` null` CharSequence will return ` -1`. A ` null` search array will return ` -1`. A ` null` or zero length search array entry will be ignored, but a search array containing "" will return the length of ` str` if ` str` is not null. This method uses String#indexOf(String) if possible
StringUtils.lastIndexOfAny(null, *)                   = -1  StringUtils.lastIndexOfAny(*, null)                   = -1  StringUtils.lastIndexOfAny(*, [])                     = -1  StringUtils.lastIndexOfAny(*, [null])                 = -1  StringUtils.lastIndexOfAny("zzabyycdxx", ["ab","cd"]) = 6  StringUtils.lastIndexOfAny("zzabyycdxx", ["cd","ab"]) = 6  StringUtils.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1  StringUtils.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1  StringUtils.lastIndexOfAny("zzabyycdxx", ["mn",""])   = 10
@param `str` the CharSequence to check, may be null
@param `searchStrs` the CharSequences to search for, may be null
@return the last index of any of the CharSequences, -1 if no match


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOfIgnoreCase
param_types_key: CharSequence,CharSequence
signature_text: public static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr)
comment:
Case in-sensitive find of the last index within a CharSequence.
A ` null` CharSequence will return ` -1`. A negative start position returns ` -1`. An empty ("") search CharSequence always matches unless the start position is negative. A start position greater than the string length searches the whole string.
StringUtils.lastIndexOfIgnoreCase(null, *)          = -1  StringUtils.lastIndexOfIgnoreCase(*, null)          = -1  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A")  = 7  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B")  = 5  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB") = 4
@param `str` the CharSequence to check, may be null
@param `searchStr` the CharSequence to find, may be null
@return the first index of the search CharSequence, -1 if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastIndexOfIgnoreCase
param_types_key: CharSequence,CharSequence,int
signature_text: public static int lastIndexOfIgnoreCase(CharSequence str, CharSequence searchStr, int startPos)
comment:
Case in-sensitive find of the last index within a CharSequence from the specified position.
A ` null` CharSequence will return ` -1`. A negative start position returns ` -1`. An empty ("") search CharSequence always matches unless the start position is negative. A start position greater than the string length searches the whole string. The search starts at the startPos and works backwards; matches starting after the start position are ignored.
StringUtils.lastIndexOfIgnoreCase(null, *, *)          = -1  StringUtils.lastIndexOfIgnoreCase(*, null, *)          = -1  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8)  = 7  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8)  = 5  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8) = 4  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9)  = 5  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1) = -1  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0)  = 0  StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0)  = -1
@param `str` the CharSequence to check, may be null
@param `searchStr` the CharSequence to find, may be null
@param `startPos` the start position
@return the last index of the search CharSequence (always ≤ startPos), -1 if no match or ` null` input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lastOrdinalIndexOf
param_types_key: CharSequence,CharSequence,int
signature_text: public static int lastOrdinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)
comment:
Finds the n-th last index within a String, handling ` null`. This method uses String#lastIndexOf(String).
A ` null` String will return ` -1`.
StringUtils.lastOrdinalIndexOf(null, *, *)          = -1  StringUtils.lastOrdinalIndexOf(*, null, *)          = -1  StringUtils.lastOrdinalIndexOf("", "", *)           = 0  StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1)  = 7  StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2)  = 6  StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1)  = 5  StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2)  = 2  StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) = 4  StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) = 1  StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1)   = 8  StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2)   = 8
Note that 'tail(CharSequence str, int n)' may be implemented as:
str.substring(lastOrdinalIndexOf(str, "\n", n) + 1)
@param `str` the CharSequence to check, may be null
@param `searchStr` the CharSequence to find, may be null
@param `ordinal` the n-th last ` searchStr` to find
@return the n-th last index of the search CharSequence, ` -1` (` INDEX_NOT_FOUND`) if no match or ` null` string input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: left
param_types_key: String,int
signature_text: public static String left(String str, int len)
comment:
Gets the leftmost ` len` characters of a String.
If ` len` characters are not available, or the String is ` null`, the String will be returned without an exception. An empty String is returned if len is negative.
StringUtils.left(null, *)    = null  StringUtils.left(*, -ve)     = ""  StringUtils.left("", *)      = ""  StringUtils.left("abc", 0)   = ""  StringUtils.left("abc", 2)   = "ab"  StringUtils.left("abc", 4)   = "abc"
@param `str` the String to get the leftmost characters from, may be null
@param `len` the length of the required String
@return the leftmost characters, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: leftPad
param_types_key: String,int
signature_text: public static String leftPad(String str, int size)
comment:
Left pad a String with spaces (' ').
The String is padded to the size of ` size`.
StringUtils.leftPad(null, *)   = null  StringUtils.leftPad("", 3)     = "   "  StringUtils.leftPad("bat", 3)  = "bat"  StringUtils.leftPad("bat", 5)  = "  bat"  StringUtils.leftPad("bat", 1)  = "bat"  StringUtils.leftPad("bat", -1) = "bat"
@param `str` the String to pad out, may be null
@param `size` the size to pad to
@return left padded String or original String if no padding is necessary, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: leftPad
param_types_key: String,int,char
signature_text: public static String leftPad(String str, int size, char padChar)
comment:
Left pad a String with a specified character.
Pad to a size of ` size`.
StringUtils.leftPad(null, *, *)     = null  StringUtils.leftPad("", 3, 'z')     = "zzz"  StringUtils.leftPad("bat", 3, 'z')  = "bat"  StringUtils.leftPad("bat", 5, 'z')  = "zzbat"  StringUtils.leftPad("bat", 1, 'z')  = "bat"  StringUtils.leftPad("bat", -1, 'z') = "bat"
@param `str` the String to pad out, may be null
@param `size` the size to pad to
@param `padChar` the character to pad with
@return left padded String or original String if no padding is necessary, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: leftPad
param_types_key: String,int,String
signature_text: public static String leftPad(String str, int size, String padStr)
comment:
Left pad a String with a specified String.
Pad to a size of ` size`.
StringUtils.leftPad(null, *, *)      = null  StringUtils.leftPad("", 3, "z")      = "zzz"  StringUtils.leftPad("bat", 3, "yz")  = "bat"  StringUtils.leftPad("bat", 5, "yz")  = "yzbat"  StringUtils.leftPad("bat", 8, "yz")  = "yzyzybat"  StringUtils.leftPad("bat", 1, "yz")  = "bat"  StringUtils.leftPad("bat", -1, "yz") = "bat"  StringUtils.leftPad("bat", 5, null)  = "  bat"  StringUtils.leftPad("bat", 5, "")    = "  bat"
@param `str` the String to pad out, may be null
@param `size` the size to pad to
@param `padStr` the String to pad with, null or empty treated as single space
@return left padded String or original String if no padding is necessary, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: length
param_types_key: CharSequence
signature_text: public static int length(CharSequence cs)
comment:
Gets a CharSequence length or ` 0` if the CharSequence is ` null`.
@param `cs` ` a CharSequence or ` null`
@return CharSequence length or ` 0` if the CharSequence is ` null`.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lowerCase
param_types_key: String
signature_text: public static String lowerCase(String str)
comment:
Converts a String to lower case as per String#toLowerCase().
A ` null` input String returns ` null`.
StringUtils.lowerCase(null)  = null  StringUtils.lowerCase("")    = ""  StringUtils.lowerCase("aBc") = "abc"
**Note:** As described in the documentation for String#toLowerCase(), the result of this method is affected by the current locale. For platform-independent case transformations, the method Locale) should be used with a specific locale (e.g. Locale#ENGLISH).
@param `str` the String to lower case, may be null
@return the lower cased String, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: lowerCase
param_types_key: String,Locale
signature_text: public static String lowerCase(String str, java.util.Locale locale)
comment:
Converts a String to lower case as per String#toLowerCase(Locale).
A ` null` input String returns ` null`.
StringUtils.lowerCase(null, Locale.ENGLISH)  = null  StringUtils.lowerCase("", Locale.ENGLISH)    = ""  StringUtils.lowerCase("aBc", Locale.ENGLISH) = "abc"
@param `str` the String to lower case, may be null
@param `locale` the locale that defines the case transformation rules, must not be null
@return the lower cased String, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: mid
param_types_key: String,int,int
signature_text: public static String mid(String str, int pos, int len)
comment:
Gets ` len` characters from the middle of a String.
If ` len` characters are not available, the remainder of the String will be returned without an exception. If the String is ` null`, ` null` will be returned. An empty String is returned if len is negative or exceeds the length of ` str`.
StringUtils.mid(null, *, *)    = null  StringUtils.mid(*, *, -ve)     = ""  StringUtils.mid("", 0, *)      = ""  StringUtils.mid("abc", 0, 2)   = "ab"  StringUtils.mid("abc", 0, 4)   = "abc"  StringUtils.mid("abc", 2, 4)   = "c"  StringUtils.mid("abc", 4, 2)   = ""  StringUtils.mid("abc", -2, 2)  = "ab"
@param `str` the String to get the characters from, may be null
@param `pos` the position to start from, negative treated as zero
@param `len` the length of the required String
@return the middle characters, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: normalizeSpace
param_types_key: String
signature_text: public static String normalizeSpace(String str)
comment:
Similar to [ The function returns the argument string with whitespace normalized by using `<a href='javascript:scrollToAnchor("trim--")'>#trim(String)</a>` to remove leading and trailing whitespace and then replacing sequences of whitespace characters by a single space.  In XML Whitespace characters are the same as those allowed by the [ Java's regexp pattern \s defines whitespace as [ \t\n\x0B\f\r[] For reference:
* \x0B = vertical tab
* \f = #xC = form feed
* #x20 = space
* #x9 = \t
* #xA = \n
* #xD = \r
The difference is that Java's whitespace includes vertical tab and form feed, which this functional will also normalize. Additionally `<a href='javascript:scrollToAnchor("trim--")'>#trim(String)</a>` removes control characters (char <= 32) from both ends of this String. ](http://www.w3.org/TR/REC-xml/#NT-S)@param `str` the source String to normalize whitespaces from, may be null@return the modified string with whitespace normalized, ` null` if null String input@see kd.bos.dataentity.utils.Pattern@see ##trim(String)@see <a href="http://www.w3.org/TR/xpath/#function-normalize-space">http://www.w3.org/TR/xpath/#function-normalize-space</a>ordinalIndexOf`public static int ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)`Finds the n-th index within a CharSequence, handling ` null`. This method uses String#indexOf(String) if possible.A ` null` CharSequence will return ` -1`.
StringUtils.ordinalIndexOf(null, *, *)          = -1  StringUtils.ordinalIndexOf(*, null, *)          = -1  StringUtils.ordinalIndexOf("", "", *)           = 0  StringUtils.ordinalIndexOf("aabaabaa", "a", 1)  = 0  StringUtils.ordinalIndexOf("aabaabaa", "a", 2)  = 1  StringUtils.ordinalIndexOf("aabaabaa", "b", 1)  = 2  StringUtils.ordinalIndexOf("aabaabaa", "b", 2)  = 5  StringUtils.ordinalIndexOf("aabaabaa", "ab", 1) = 1  StringUtils.ordinalIndexOf("aabaabaa", "ab", 2) = 4  StringUtils.ordinalIndexOf("aabaabaa", "", 1)   = 0  StringUtils.ordinalIndexOf("aabaabaa", "", 2)   = 0
Note that 'head(CharSequence str, int n)' may be implemented as:
str.substring(0, lastOrdinalIndexOf(str, "\n", n))
StringUtils.overlay(null, *, *, *)            = null  StringUtils.overlay("", "abc", 0, 0)          = "abc"  StringUtils.overlay("abcdef", null, 2, 4)     = "abef"  StringUtils.overlay("abcdef", "", 2, 4)       = "abef"  StringUtils.overlay("abcdef", "", 4, 2)       = "abef"  StringUtils.overlay("abcdef", "zzzz", 2, 4)   = "abzzzzef"  StringUtils.overlay("abcdef", "zzzz", 4, 2)   = "abzzzzef"  StringUtils.overlay("abcdef", "zzzz", -1, 4)  = "zzzzef"  StringUtils.overlay("abcdef", "zzzz", 2, 8)   = "abzzzz"  StringUtils.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"  StringUtils.overlay("abcdef", "zzzz", 8, 10)  = "abcdefzzzz"
StringUtils.prependIfMissing(null, null) = null  StringUtils.prependIfMissing("abc", null) = "abc"  StringUtils.prependIfMissing("", "xyz") = "xyz"  StringUtils.prependIfMissing("abc", "xyz") = "xyzabc"  StringUtils.prependIfMissing("xyzabc", "xyz") = "xyzabc"  StringUtils.prependIfMissing("XYZabc", "xyz") = "xyzXYZabc"
With additional prefixes,
StringUtils.prependIfMissing(null, null, null) = null  StringUtils.prependIfMissing("abc", null, null) = "abc"  StringUtils.prependIfMissing("", "xyz", null) = "xyz"  StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null}) = "xyzabc"  StringUtils.prependIfMissing("abc", "xyz", "") = "abc"  StringUtils.prependIfMissing("abc", "xyz", "mno") = "xyzabc"  StringUtils.prependIfMissing("xyzabc", "xyz", "mno") = "xyzabc"  StringUtils.prependIfMissing("mnoabc", "xyz", "mno") = "mnoabc"  StringUtils.prependIfMissing("XYZabc", "xyz", "mno") = "xyzXYZabc"  StringUtils.prependIfMissing("MNOabc", "xyz", "mno") = "xyzMNOabc"
StringUtils.prependIfMissingIgnoreCase(null, null) = null  StringUtils.prependIfMissingIgnoreCase("abc", null) = "abc"  StringUtils.prependIfMissingIgnoreCase("", "xyz") = "xyz"  StringUtils.prependIfMissingIgnoreCase("abc", "xyz") = "xyzabc"  StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz") = "xyzabc"  StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz") = "XYZabc"
With additional prefixes,
StringUtils.prependIfMissingIgnoreCase(null, null, null) = null  StringUtils.prependIfMissingIgnoreCase("abc", null, null) = "abc"  StringUtils.prependIfMissingIgnoreCase("", "xyz", null) = "xyz"  StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}) = "xyzabc"  StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "") = "abc"  StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno") = "xyzabc"  StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno") = "xyzabc"  StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno") = "mnoabc"  StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno") = "XYZabc"  StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno") = "MNOabc"
StringUtils.remove(null, *)        = null  StringUtils.remove("", *)          = ""  StringUtils.remove(*, null)        = *  StringUtils.remove(*, "")          = *  StringUtils.remove("queued", "ue") = "qd"  StringUtils.remove("queued", "zz") = "queued"
StringUtils.remove(null, *)       = null  StringUtils.remove("", *)         = ""  StringUtils.remove("queued", 'u') = "qeed"  StringUtils.remove("queued", 'z') = "queued"
StringUtils.removeEnd(null, *)      = null  StringUtils.removeEnd("", *)        = ""  StringUtils.removeEnd(*, null)      = *  StringUtils.removeEnd("www.domain.com", ".com.")  = "www.domain.com"  StringUtils.removeEnd("www.domain.com", ".com")   = "www.domain"  StringUtils.removeEnd("www.domain.com", "domain") = "www.domain.com"  StringUtils.removeEnd("abc", "")    = "abc"
StringUtils.removeEndIgnoreCase(null, *)      = null  StringUtils.removeEndIgnoreCase("", *)        = ""  StringUtils.removeEndIgnoreCase(*, null)      = *  StringUtils.removeEndIgnoreCase("www.domain.com", ".com.")  = "www.domain.com"  StringUtils.removeEndIgnoreCase("www.domain.com", ".com")   = "www.domain"  StringUtils.removeEndIgnoreCase("www.domain.com", "domain") = "www.domain.com"  StringUtils.removeEndIgnoreCase("abc", "")    = "abc"  StringUtils.removeEndIgnoreCase("www.domain.com", ".COM") = "www.domain")  StringUtils.removeEndIgnoreCase("www.domain.COM", ".com") = "www.domain")
StringUtils.removeStart(null, *)      = null  StringUtils.removeStart("", *)        = ""  StringUtils.removeStart(*, null)      = *  StringUtils.removeStart("www.domain.com", "www.")   = "domain.com"  StringUtils.removeStart("domain.com", "www.")       = "domain.com"  StringUtils.removeStart("www.domain.com", "domain") = "www.domain.com"  StringUtils.removeStart("abc", "")    = "abc"
StringUtils.removeStartIgnoreCase(null, *)      = null  StringUtils.removeStartIgnoreCase("", *)        = ""  StringUtils.removeStartIgnoreCase(*, null)      = *  StringUtils.removeStartIgnoreCase("www.domain.com", "www.")   = "domain.com"  StringUtils.removeStartIgnoreCase("www.domain.com", "WWW.")   = "domain.com"  StringUtils.removeStartIgnoreCase("domain.com", "www.")       = "domain.com"  StringUtils.removeStartIgnoreCase("www.domain.com", "domain") = "www.domain.com"  StringUtils.removeStartIgnoreCase("abc", "")    = "abc"
StringUtils.repeat(null, 2) = null  StringUtils.repeat("", 0)   = ""  StringUtils.repeat("", 2)   = ""  StringUtils.repeat("a", 3)  = "aaa"  StringUtils.repeat("ab", 2) = "abab"  StringUtils.repeat("a", -2) = ""
StringUtils.repeat(null, null, 2) = null  StringUtils.repeat(null, "x", 2)  = null  StringUtils.repeat("", null, 0)   = ""  StringUtils.repeat("", "", 2)     = ""  StringUtils.repeat("", "x", 3)    = "xxx"  StringUtils.repeat("?", ", ", 3)  = "?, ?, ?"
StringUtils.repeat('e', 0)  = ""  StringUtils.repeat('e', 3)  = "eee"  StringUtils.repeat('e', -2) = ""
Note: this method doesn't not support padding with [Unicode Supplementary Characters](http://www.unicode.org/glossary/#supplementary_character) as they require a pair of ` char`s to be represented. If you are needing to support full I18N of your applications consider using int) instead. @param `ch` character to repeat@param `repeat` number of times to repeat char, negative treated as zero@return String with repeated character@see ##repeat(String, int)replace`public static String replace(String text, String searchString, String replacement)`Replaces all occurrences of a String within another String.A ` null` reference passed to this method is a no-op.
StringUtils.replace(null, *, *)        = null  StringUtils.replace("", *, *)          = ""  StringUtils.replace("any", null, *)    = "any"  StringUtils.replace("any", *, null)    = "any"  StringUtils.replace("any", "", *)      = "any"  StringUtils.replace("aba", "a", null)  = "aba"  StringUtils.replace("aba", "a", "")    = "b"  StringUtils.replace("aba", "a", "z")   = "zbz"
StringUtils.replace(null, *, *, *)         = null  StringUtils.replace("", *, *, *)           = ""  StringUtils.replace("any", null, *, *)     = "any"  StringUtils.replace("any", *, null, *)     = "any"  StringUtils.replace("any", "", *, *)       = "any"  StringUtils.replace("any", *, *, 0)        = "any"  StringUtils.replace("abaa", "a", null, -1) = "abaa"  StringUtils.replace("abaa", "a", "", -1)   = "b"  StringUtils.replace("abaa", "a", "z", 0)   = "abaa"  StringUtils.replace("abaa", "a", "z", 1)   = "zbaa"  StringUtils.replace("abaa", "a", "z", 2)   = "zbza"  StringUtils.replace("abaa", "a", "z", -1)  = "zbzz"
StringUtils.replaceChars(null, *, *)        = null  StringUtils.replaceChars("", *, *)          = ""  StringUtils.replaceChars("abcba", 'b', 'y') = "aycya"  StringUtils.replaceChars("abcba", 'z', 'y') = "abcba"
StringUtils.replaceChars(null, *, *)           = null  StringUtils.replaceChars("", *, *)             = ""  StringUtils.replaceChars("abc", null, *)       = "abc"  StringUtils.replaceChars("abc", "", *)         = "abc"  StringUtils.replaceChars("abc", "b", null)     = "ac"  StringUtils.replaceChars("abc", "b", "")       = "ac"  StringUtils.replaceChars("abcba", "bc", "yz")  = "ayzya"  StringUtils.replaceChars("abcba", "bc", "y")   = "ayya"  StringUtils.replaceChars("abcba", "bc", "yzx") = "ayzya"
StringUtils.replaceEach(null, *, *)        = null   StringUtils.replaceEach("", *, *)          = ""   StringUtils.replaceEach("aba", null, null) = "aba"   StringUtils.replaceEach("aba", new String[0], null) = "aba"   StringUtils.replaceEach("aba", null, new String[0]) = "aba"   StringUtils.replaceEach("aba", new String[]{"a"}, null)  = "aba"   StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""})  = "b"   StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"})  = "aba"   StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"})  = "wcte"   (example of how it does not repeat)   StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"})  = "dcte"
StringUtils.replaceEachRepeatedly(null, *, *) = null   StringUtils.replaceEachRepeatedly("", *, *) = ""   StringUtils.replaceEachRepeatedly("aba", null, null) = "aba"   StringUtils.replaceEachRepeatedly("aba", new String[0], null) = "aba"   StringUtils.replaceEachRepeatedly("aba", null, new String[0]) = "aba"   StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, null) = "aba"   StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, new String[]{""}) = "b"   StringUtils.replaceEachRepeatedly("aba", new String[]{null}, new String[]{"a"}) = "aba"   StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}) = "wcte"   (example of how it repeats)   StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}) = "tcte"   StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"}) = IllegalStateException
StringUtils.replaceOnce(null, *, *)        = null  StringUtils.replaceOnce("", *, *)          = ""  StringUtils.replaceOnce("any", null, *)    = "any"  StringUtils.replaceOnce("any", *, null)    = "any"  StringUtils.replaceOnce("any", "", *)      = "any"  StringUtils.replaceOnce("aba", "a", null)  = "aba"  StringUtils.replaceOnce("aba", "a", "")    = "ba"  StringUtils.replaceOnce("aba", "a", "z")   = "zba"
* ` source.replaceAll("(?s)" + regex, replacement)`
* ` Pattern.compile(regex, Pattern.DOTALL).matcher(source).replaceAll(replacement)`
StringUtils.reverse(null)  = null  StringUtils.reverse("")    = ""  StringUtils.reverse("bat") = "tab"
StringUtils.right(null, *)    = null  StringUtils.right(*, -ve)     = ""  StringUtils.right("", *)      = ""  StringUtils.right("abc", 0)   = ""  StringUtils.right("abc", 2)   = "bc"  StringUtils.right("abc", 4)   = "abc"
StringUtils.rightPad(null, *)   = null  StringUtils.rightPad("", 3)     = "   "  StringUtils.rightPad("bat", 3)  = "bat"  StringUtils.rightPad("bat", 5)  = "bat  "  StringUtils.rightPad("bat", 1)  = "bat"  StringUtils.rightPad("bat", -1) = "bat"
StringUtils.rightPad(null, *, *)     = null  StringUtils.rightPad("", 3, 'z')     = "zzz"  StringUtils.rightPad("bat", 3, 'z')  = "bat"  StringUtils.rightPad("bat", 5, 'z')  = "batzz"  StringUtils.rightPad("bat", 1, 'z')  = "bat"  StringUtils.rightPad("bat", -1, 'z') = "bat"
StringUtils.rightPad(null, *, *)      = null  StringUtils.rightPad("", 3, "z")      = "zzz"  StringUtils.rightPad("bat", 3, "yz")  = "bat"  StringUtils.rightPad("bat", 5, "yz")  = "batyz"  StringUtils.rightPad("bat", 8, "yz")  = "batyzyzy"  StringUtils.rightPad("bat", 1, "yz")  = "bat"  StringUtils.rightPad("bat", -1, "yz") = "bat"  StringUtils.rightPad("bat", 5, null)  = "bat  "  StringUtils.rightPad("bat", 5, "")    = "bat  "
StringUtils.split(null)       = null  StringUtils.split("")         = []  StringUtils.split("abc def")  = ["abc", "def"]  StringUtils.split("abc  def") = ["abc", "def"]  StringUtils.split(" abc ")    = ["abc"]
StringUtils.split(null, *)         = null  StringUtils.split("", *)           = []  StringUtils.split("abc def", null) = ["abc", "def"]  StringUtils.split("abc def", " ")  = ["abc", "def"]  StringUtils.split("abc  def", " ") = ["abc", "def"]  StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
StringUtils.split(null, *, *)            = null  StringUtils.split("", *, *)              = []  StringUtils.split("ab cd ef", null, 0)   = ["ab", "cd", "ef"]  StringUtils.split("ab   cd ef", null, 0) = ["ab", "cd", "ef"]  StringUtils.split("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]  StringUtils.split("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]
StringUtils.splitByCharacterType(null)         = null  StringUtils.splitByCharacterType("")           = []  StringUtils.splitByCharacterType("ab de fg")   = ["ab", " ", "de", " ", "fg"]  StringUtils.splitByCharacterType("ab   de fg") = ["ab", "   ", "de", " ", "fg"]  StringUtils.splitByCharacterType("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]  StringUtils.splitByCharacterType("number5")    = ["number", "5"]  StringUtils.splitByCharacterType("fooBar")     = ["foo", "B", "ar"]  StringUtils.splitByCharacterType("foo200Bar")  = ["foo", "200", "B", "ar"]  StringUtils.splitByCharacterType("ASFRules")   = ["ASFR", "ules"]
StringUtils.splitByCharacterTypeCamelCase(null)         = null  StringUtils.splitByCharacterTypeCamelCase("")           = []  StringUtils.splitByCharacterTypeCamelCase("ab de fg")   = ["ab", " ", "de", " ", "fg"]  StringUtils.splitByCharacterTypeCamelCase("ab   de fg") = ["ab", "   ", "de", " ", "fg"]  StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef")   = ["ab", ":", "cd", ":", "ef"]  StringUtils.splitByCharacterTypeCamelCase("number5")    = ["number", "5"]  StringUtils.splitByCharacterTypeCamelCase("fooBar")     = ["foo", "Bar"]  StringUtils.splitByCharacterTypeCamelCase("foo200Bar")  = ["foo", "200", "Bar"]  StringUtils.splitByCharacterTypeCamelCase("ASFRules")   = ["ASF", "Rules"]
StringUtils.splitPreserveAllTokens(null)       = null  StringUtils.splitPreserveAllTokens("")         = []  StringUtils.splitPreserveAllTokens("abc def")  = ["abc", "def"]  StringUtils.splitPreserveAllTokens("abc  def") = ["abc", "", "def"]  StringUtils.splitPreserveAllTokens(" abc ")    = ["", "abc", ""]
StringUtils.splitPreserveAllTokens(null, *)           = null  StringUtils.splitPreserveAllTokens("", *)             = []  StringUtils.splitPreserveAllTokens("abc def", null)   = ["abc", "def"]  StringUtils.splitPreserveAllTokens("abc def", " ")    = ["abc", "def"]  StringUtils.splitPreserveAllTokens("abc  def", " ")   = ["abc", "", def"]  StringUtils.splitPreserveAllTokens("ab:cd:ef", ":")   = ["ab", "cd", "ef"]  StringUtils.splitPreserveAllTokens("ab:cd:ef:", ":")  = ["ab", "cd", "ef", ""]  StringUtils.splitPreserveAllTokens("ab:cd:ef::", ":") = ["ab", "cd", "ef", "", ""]  StringUtils.splitPreserveAllTokens("ab::cd:ef", ":")  = ["ab", "", cd", "ef"]  StringUtils.splitPreserveAllTokens(":cd:ef", ":")     = ["", cd", "ef"]  StringUtils.splitPreserveAllTokens("::cd:ef", ":")    = ["", "", cd", "ef"]  StringUtils.splitPreserveAllTokens(":cd:ef:", ":")    = ["", cd", "ef", ""]
StringUtils.splitPreserveAllTokens(null, *, *)            = null  StringUtils.splitPreserveAllTokens("", *, *)              = []  StringUtils.splitPreserveAllTokens("ab de fg", null, 0)   = ["ab", "cd", "ef"]  StringUtils.splitPreserveAllTokens("ab   de fg", null, 0) = ["ab", "cd", "ef"]  StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 0)    = ["ab", "cd", "ef"]  StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2)    = ["ab", "cd:ef"]  StringUtils.splitPreserveAllTokens("ab   de fg", null, 2) = ["ab", "  de fg"]  StringUtils.splitPreserveAllTokens("ab   de fg", null, 3) = ["ab", "", " de fg"]  StringUtils.splitPreserveAllTokens("ab   de fg", null, 4) = ["ab", "", "", "de fg"]
StringUtils.startsWith(null, null)      = true  StringUtils.startsWith(null, "abc")     = false  StringUtils.startsWith("abcdef", null)  = false  StringUtils.startsWith("abcdef", "abc") = true  StringUtils.startsWith("ABCDEF", "abc") = false
StringUtils.startsWithAny(null, null)      = false  StringUtils.startsWithAny(null, new String[] {"abc"})  = false  StringUtils.startsWithAny("abcxyz", null)     = false  StringUtils.startsWithAny("abcxyz", new String[] {""}) = false  StringUtils.startsWithAny("abcxyz", new String[] {"abc"}) = true  StringUtils.startsWithAny("abcxyz", new String[] {null, "xyz", "abc"}) = true
StringUtils.startsWithIgnoreCase(null, null)      = true  StringUtils.startsWithIgnoreCase(null, "abc")     = false  StringUtils.startsWithIgnoreCase("abcdef", null)  = false  StringUtils.startsWithIgnoreCase("abcdef", "abc") = true  StringUtils.startsWithIgnoreCase("ABCDEF", "abc") = true
StringUtils.strip(null)     = null  StringUtils.strip("")       = ""  StringUtils.strip("   ")    = ""  StringUtils.strip("abc")    = "abc"  StringUtils.strip("  abc")  = "abc"  StringUtils.strip("abc  ")  = "abc"  StringUtils.strip(" abc ")  = "abc"  StringUtils.strip(" ab c ") = "ab c"
StringUtils.strip(null, *)          = null  StringUtils.strip("", *)            = ""  StringUtils.strip("abc", null)      = "abc"  StringUtils.strip("  abc", null)    = "abc"  StringUtils.strip("abc  ", null)    = "abc"  StringUtils.strip(" abc ", null)    = "abc"  StringUtils.strip("  abcyx", "xyz") = "  abc"
StringUtils.stripAccents(null)                = null  StringUtils.stripAccents("")                  = ""  StringUtils.stripAccents("control")           = "control"  StringUtils.stripAccents("éclair")     = "eclair"
StringUtils.stripAll(null)             = null  StringUtils.stripAll([])               = []  StringUtils.stripAll(["abc", "  abc"]) = ["abc", "abc"]  StringUtils.stripAll(["abc  ", null])  = ["abc", null]
StringUtils.stripAll(null, *)                = null  StringUtils.stripAll([], *)                  = []  StringUtils.stripAll(["abc", "  abc"], null) = ["abc", "abc"]  StringUtils.stripAll(["abc  ", null], null)  = ["abc", null[]  StringUtils.stripAll(["abc  ", null], "yz")  = ["abc  ", null[]  StringUtils.stripAll(["yabcz", null], "yz")  = ["abc", null]
StringUtils.stripEnd(null, *)          = null  StringUtils.stripEnd("", *)            = ""  StringUtils.stripEnd("abc", "")        = "abc"  StringUtils.stripEnd("abc", null)      = "abc"  StringUtils.stripEnd("  abc", null)    = "  abc"  StringUtils.stripEnd("abc  ", null)    = "abc"  StringUtils.stripEnd(" abc ", null)    = " abc"  StringUtils.stripEnd("  abcyx", "xyz") = "  abc"  StringUtils.stripEnd("120.00", ".0")   = "12"
StringUtils.stripStart(null, *)          = null  StringUtils.stripStart("", *)            = ""  StringUtils.stripStart("abc", "")        = "abc"  StringUtils.stripStart("abc", null)      = "abc"  StringUtils.stripStart("  abc", null)    = "abc"  StringUtils.stripStart("abc  ", null)    = "abc  "  StringUtils.stripStart(" abc ", null)    = "abc "  StringUtils.stripStart("yxabc  ", "xyz") = "abc  "
StringUtils.stripToEmpty(null)     = ""  StringUtils.stripToEmpty("")       = ""  StringUtils.stripToEmpty("   ")    = ""  StringUtils.stripToEmpty("abc")    = "abc"  StringUtils.stripToEmpty("  abc")  = "abc"  StringUtils.stripToEmpty("abc  ")  = "abc"  StringUtils.stripToEmpty(" abc ")  = "abc"  StringUtils.stripToEmpty(" ab c ") = "ab c"
StringUtils.stripToNull(null)     = null  StringUtils.stripToNull("")       = null  StringUtils.stripToNull("   ")    = null  StringUtils.stripToNull("abc")    = "abc"  StringUtils.stripToNull("  abc")  = "abc"  StringUtils.stripToNull("abc  ")  = "abc"  StringUtils.stripToNull(" abc ")  = "abc"  StringUtils.stripToNull(" ab c ") = "ab c"
StringUtils.substring(null, *)   = null  StringUtils.substring("", *)     = ""  StringUtils.substring("abc", 0)  = "abc"  StringUtils.substring("abc", 2)  = "c"  StringUtils.substring("abc", 4)  = ""  StringUtils.substring("abc", -2) = "bc"  StringUtils.substring("abc", -4) = "abc"
StringUtils.substring(null, *, *)    = null  StringUtils.substring("", * ,  *)    = "";  StringUtils.substring("abc", 0, 2)   = "ab"  StringUtils.substring("abc", 2, 0)   = ""  StringUtils.substring("abc", 2, 4)   = "c"  StringUtils.substring("abc", 4, 6)   = ""  StringUtils.substring("abc", 2, 2)   = ""  StringUtils.substring("abc", -2, -1) = "b"  StringUtils.substring("abc", -4, 2)  = "ab"
StringUtils.substringAfter(null, *)      = null  StringUtils.substringAfter("", *)        = ""  StringUtils.substringAfter(*, null)      = ""  StringUtils.substringAfter("abc", "a")   = "bc"  StringUtils.substringAfter("abcba", "b") = "cba"  StringUtils.substringAfter("abc", "c")   = ""  StringUtils.substringAfter("abc", "d")   = ""  StringUtils.substringAfter("abc", "")    = "abc"
StringUtils.substringAfterLast(null, *)      = null  StringUtils.substringAfterLast("", *)        = ""  StringUtils.substringAfterLast(*, "")        = ""  StringUtils.substringAfterLast(*, null)      = ""  StringUtils.substringAfterLast("abc", "a")   = "bc"  StringUtils.substringAfterLast("abcba", "b") = "a"  StringUtils.substringAfterLast("abc", "c")   = ""  StringUtils.substringAfterLast("a", "a")     = ""  StringUtils.substringAfterLast("a", "z")     = ""
StringUtils.substringBefore(null, *)      = null  StringUtils.substringBefore("", *)        = ""  StringUtils.substringBefore("abc", "a")   = ""  StringUtils.substringBefore("abcba", "b") = "a"  StringUtils.substringBefore("abc", "c")   = "ab"  StringUtils.substringBefore("abc", "d")   = "abc"  StringUtils.substringBefore("abc", "")    = ""  StringUtils.substringBefore("abc", null)  = "abc"
StringUtils.substringBeforeLast(null, *)      = null  StringUtils.substringBeforeLast("", *)        = ""  StringUtils.substringBeforeLast("abcba", "b") = "abc"  StringUtils.substringBeforeLast("abc", "c")   = "ab"  StringUtils.substringBeforeLast("a", "a")     = ""  StringUtils.substringBeforeLast("a", "z")     = "a"  StringUtils.substringBeforeLast("a", null)    = "a"  StringUtils.substringBeforeLast("a", "")      = "a"
StringUtils.substringBetween(null, *)            = null  StringUtils.substringBetween("", "")             = ""  StringUtils.substringBetween("", "tag")          = null  StringUtils.substringBetween("tagabctag", null)  = null  StringUtils.substringBetween("tagabctag", "")    = ""  StringUtils.substringBetween("tagabctag", "tag") = "abc"
StringUtils.substringBetween("wx[b]yz", "[", "]") = "b"  StringUtils.substringBetween(null, *, *)          = null  StringUtils.substringBetween(*, null, *)          = null  StringUtils.substringBetween(*, *, null)          = null  StringUtils.substringBetween("", "", "")          = ""  StringUtils.substringBetween("", "", "]")         = null  StringUtils.substringBetween("", "[", "]")        = null  StringUtils.substringBetween("yabcz", "", "")     = ""  StringUtils.substringBetween("yabcz", "y", "z")   = "abc"  StringUtils.substringBetween("yabczyabcz", "y", "z")   = "abc"
* Upper case character converts to Lower case
* Title case character converts to Lower case
* Lower case character converts to Upper case
For a word based algorithm, see org.apache.commons.lang3.text.WordUtils#swapCase(String). A ` null` input String returns ` null`.
StringUtils.swapCase(null)                 = null  StringUtils.swapCase("")                   = ""  StringUtils.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
NOTE: This method changed in Lang version 2.0. It no longer performs a word based algorithm. If you only use ASCII, you will notice no change. That functionality is available in org.apache.commons.lang3.text.WordUtils.@param `str` the String to swap case, may be null@return the changed String, ` null` if null String inputtoEncodedString`public static String toEncodedString(byte[] bytes, java.nio.charset.Charset charset)`Converts a `byte[]` to a String using the specified character encoding.@param `bytes ` the byte array to read from@param `charset ` the encoding to use, if null then use the platform default@return a new String@throws `NullPointerException ` if ` bytes` is null~~toString~~ @Deprecated`public static String toString(byte[] bytes, String charsetName) throws java.io.UnsupportedEncodingException`Converts a `byte[]` to a String using the specified character encoding.@deprecated use Charset) instead of String constants in your code@param `bytes ` the byte array to read from@param `charsetName ` the encoding to use, if null then use the platform default@return a new String@throws `UnsupportedEncodingException ` If the named charset is not supported@throws `NullPointerException ` if the input is nulltrim`public static String trim(String str)`Removes control characters (char <= 32) from both ends of this String, handling ` null` by returning ` null`.The String is trimmed using String#trim(). Trim removes start and end characters <= 32. To strip whitespace use #strip(String).To trim your choice of characters, use the String) methods.
StringUtils.trim(null)          = null  StringUtils.trim("")            = ""  StringUtils.trim("     ")       = ""  StringUtils.trim("abc")         = "abc"  StringUtils.trim("    abc    ") = "abc"
StringUtils.trimToEmpty(null)          = ""  StringUtils.trimToEmpty("")            = ""  StringUtils.trimToEmpty("     ")       = ""  StringUtils.trimToEmpty("abc")         = "abc"  StringUtils.trimToEmpty("    abc    ") = "abc"
StringUtils.trimToNull(null)          = null  StringUtils.trimToNull("")            = null  StringUtils.trimToNull("     ")       = null  StringUtils.trimToNull("abc")         = "abc"  StringUtils.trimToNull("    abc    ") = "abc"
StringUtils.uncapitalize(null)  = null  StringUtils.uncapitalize("")    = ""  StringUtils.uncapitalize("Cat") = "cat"  StringUtils.uncapitalize("CAT") = "cAT"
StringUtils.upperCase(null)  = null  StringUtils.upperCase("")    = ""  StringUtils.upperCase("aBc") = "ABC"
**Note:** As described in the documentation for String#toUpperCase(), the result of this method is affected by the current locale. For platform-independent case transformations, the method Locale) should be used with a specific locale (e.g. Locale#ENGLISH).@param `str` the String to upper case, may be null@return the upper cased String, ` null` if null String inputupperCase`public static String upperCase(String str, java.util.Locale locale)`Converts a String to upper case as per String#toUpperCase(Locale).A ` null` input String returns ` null`.
StringUtils.upperCase(null, Locale.ENGLISH)  = null  StringUtils.upperCase("", Locale.ENGLISH)    = ""  StringUtils.upperCase("aBc", Locale.ENGLISH) = "ABC"
StringUtils.wrap(null, *)        = null  StringUtils.wrap("", *)          = ""  StringUtils.wrap("ab", '\0')     = "ab"  StringUtils.wrap("ab", 'x')      = "xabx"  StringUtils.wrap("ab", '\'')     = "'ab'"  StringUtils.wrap("\"ab\"", '\"') = "\"\"ab\"\""
StringUtils.wrap(null, *)         = null  StringUtils.wrap("", *)           = ""  StringUtils.wrap("ab", null)      = "ab"  StringUtils.wrap("ab", "x")       = "xabx"  StringUtils.wrap("ab", "\"")      = "\"ab\""  StringUtils.wrap("\"ab\"", "\"")  = "\"\"ab\"\""  StringUtils.wrap("ab", "'")       = "'ab'"  StringUtils.wrap("'abcd'", "'")   = "''abcd''"  StringUtils.wrap("\"abcd\"", "'") = "'\"abcd\"'"  StringUtils.wrap("'abcd'", "\"")  = "\"'abcd'\""
@param `str` the CharSequence to check, may be null@param `searchStr` the CharSequence to find, may be null@param `ordinal` the n-th ` searchStr` to find@return the n-th index of the search CharSequence, ` -1` (` INDEX_NOT_FOUND`) if no match or ` null` string inputoverlay`public static String overlay(String str, String overlay, int start, int end)`Overlays part of a String with another String.A ` null` string input returns ` null`. A negative index is treated as zero. An index greater than the string length is treated as the string length. The start index is always the smaller of the two indices.
@param `str` the String to do overlaying in, may be null@param `overlay` the String to overlay, may be null@param `start` the position to start overlaying at@param `end` the position to stop overlaying before@return overlayed String, ` null` if null String inputprependIfMissing`public static String prependIfMissing(String str, CharSequence prefix, CharSequence[] prefixes)`Prepends the prefix to the start of the string if the string does not already start with any of the prefixes.
@param `str` The string.@param `prefix` The prefix to prepend to the start of the string.@param `prefixes` Additional prefixes that are valid.@return A new String if prefix was prepended, the same string otherwise.prependIfMissingIgnoreCase`public static String prependIfMissingIgnoreCase(String str, CharSequence prefix, CharSequence[] prefixes)`Prepends the prefix to the start of the string if the string does not already start, case insensitive, with any of the prefixes.
@param `str` The string.@param `prefix` The prefix to prepend to the start of the string.@param `prefixes` Additional prefixes that are valid (optional).@return A new String if prefix was prepended, the same string otherwise.remove`public static String remove(String str, String remove)`Removes all occurrences of a substring from within the source string.A ` null` source string will return ` null`. An empty ("") source string will return the empty string. A ` null` remove string will return the source string. An empty ("") remove string will return the source string.
@param `str` the source String to search, may be null@param `remove` the String to search for and remove, may be null@return the substring with the string removed if found, ` null` if null String inputremove`public static String remove(String str, char remove)`Removes all occurrences of a character from within the source string.A ` null` source string will return ` null`. An empty ("") source string will return the empty string.
@param `str` the source String to search, may be null@param `remove` the char to search for and remove, may be null@return the substring with the char removed if found, ` null` if null String inputremoveEnd`public static String removeEnd(String str, String remove)`Removes a substring only if it is at the end of a source string, otherwise returns the source string.A ` null` source string will return ` null`. An empty ("") source string will return the empty string. A ` null` search string will return the source string.
@param `str` the source String to search, may be null@param `remove` the String to search for and remove, may be null@return the substring with the string removed if found, ` null` if null String inputremoveEndIgnoreCase`public static String removeEndIgnoreCase(String str, String remove)`Case insensitive removal of a substring if it is at the end of a source string, otherwise returns the source string.A ` null` source string will return ` null`. An empty ("") source string will return the empty string. A ` null` search string will return the source string.
@param `str` the source String to search, may be null@param `remove` the String to search for (case insensitive) and remove, may be null@return the substring with the string removed if found, ` null` if null String inputremovePattern`public static String removePattern(String source, String regex)`Removes each substring of the source String that matches the given regular expression using the DOTALL option.@param `source ` the source string@param `regex ` the regular expression to which this string is to be matched@return The resulting ` String`@see kd.bos.dataentity.utils.String#replaceAll(String, String)@see kd.bos.dataentity.utils.Pattern#DOTALLremoveStart`public static String removeStart(String str, String remove)`Removes a substring only if it is at the beginning of a source string, otherwise returns the source string.A ` null` source string will return ` null`. An empty ("") source string will return the empty string. A ` null` search string will return the source string.
@param `str` the source String to search, may be null@param `remove` the String to search for and remove, may be null@return the substring with the string removed if found, ` null` if null String inputremoveStartIgnoreCase`public static String removeStartIgnoreCase(String str, String remove)`Case insensitive removal of a substring if it is at the beginning of a source string, otherwise returns the source string.A ` null` source string will return ` null`. An empty ("") source string will return the empty string. A ` null` search string will return the source string.
@param `str` the source String to search, may be null@param `remove` the String to search for (case insensitive) and remove, may be null@return the substring with the string removed if found, ` null` if null String inputrepeat`public static String repeat(String str, int repeat)`Repeat a String ` repeat` times to form a new String.
@param `str` the String to repeat, may be null@param `repeat` number of times to repeat str, negative treated as zero@return a new String consisting of the original String repeated, ` null` if null String inputrepeat`public static String repeat(String str, String separator, int repeat)`Repeat a String ` repeat` times to form a new String, with a String separator injected each time.
@param `str` the String to repeat, may be null@param `separator` the String to inject, may be null@param `repeat` number of times to repeat str, negative treated as zero@return a new String consisting of the original String repeated, ` null` if null String inputrepeat`public static String repeat(char ch, int repeat)`Returns padding using the specified delimiter repeated to a given length.
@param `text` text to search and replace in, may be null@param `searchString` the String to search for, may be null@param `replacement` the String to replace it with, may be null@return the text with any replacements processed, ` null` if null String input@see ##replace(String text, String searchString, String replacement, int max)replace`public static String replace(String text, String searchString, String replacement, int max)`Replaces a String with another String inside a larger String, for the first ` max` values of the search String.A ` null` reference passed to this method is a no-op.
@param `text` text to search and replace in, may be null@param `searchString` the String to search for, may be null@param `replacement` the String to replace it with, may be null@param `max` maximum number of values to replace, or ` -1` if no maximum@return the text with any replacements processed, ` null` if null String inputreplaceChars`public static String replaceChars(String str, char searchChar, char replaceChar)`Replaces all occurrences of a character in a String with another. This is a null-safe version of char).A ` null` string input returns ` null`. An empty ("") string input returns an empty string.
@param `str` String to replace characters in, may be null@param `searchChar` the character to search for, may be null@param `replaceChar` the character to replace, may be null@return modified String, ` null` if null string inputreplaceChars`public static String replaceChars(String str, String searchChars, String replaceChars)`Replaces multiple characters in a String in one go. This method can also be used to delete characters.For example: `replaceChars("hello", "ho", "jy") = jelly`.A ` null` string input returns ` null`. An empty ("") string input returns an empty string. A null or empty set of search characters returns the input string.The length of the search characters should normally equal the length of the replace characters. If the search characters is longer, then the extra search characters are deleted. If the search characters is shorter, then the extra replace characters are ignored.
@param `str` String to replace characters in, may be null@param `searchChars` a set of characters to search for, may be null@param `replaceChars` a set of characters to replace, may be null@return modified String, ` null` if null string inputreplaceEach`public static String replaceEach(String text, String[] searchList, String[] replacementList)` Replaces all occurrences of Strings within another String.  A ` null` reference passed to this method is a no-op, or if any "search string" or "string to replace" is null, that replace will be ignored. This will not repeat. For repeating replaces, call the overloaded method.
@param `text` ` text to search and replace in, no-op if null@param `searchList ` the Strings to search for, no-op if null@param `replacementList ` the Strings to replace them with, no-op if null@return the text with any replacements processed, ` null` if null String input@throws `IllegalArgumentException ` if the lengths of the arrays are not the same (null is ok, and/or size 0)replaceEachRepeatedly`public static String replaceEachRepeatedly(String text, String[] searchList, String[] replacementList)` Replaces all occurrences of Strings within another String.  A ` null` reference passed to this method is a no-op, or if any "search string" or "string to replace" is null, that replace will be ignored.
@param `text` ` text to search and replace in, no-op if null@param `searchList ` the Strings to search for, no-op if null@param `replacementList ` the Strings to replace them with, no-op if null@return the text with any replacements processed, ` null` if null String input@throws `IllegalStateException ` if the search is repeating and there is an endless loop due to outputs of one being inputs to another@throws `IllegalArgumentException ` if the lengths of the arrays are not the same (null is ok, and/or size 0)replaceOnce`public static String replaceOnce(String text, String searchString, String replacement)`Replaces a String with another String inside a larger String, once.A ` null` reference passed to this method is a no-op.
@param `text` text to search and replace in, may be null@param `searchString` the String to search for, may be null@param `replacement` the String to replace with, may be null@return the text with any replacements processed, ` null` if null String input@see ##replace(String text, String searchString, String replacement, int max)replacePattern`public static String replacePattern(String source, String regex, String replacement)`Replaces each substring of the source String that matches the given regular expression with the given replacement using the Pattern#DOTALL option. DOTALL is also know as single-line mode in Perl. This call is also equivalent to:
@param `source` ` the source string@param `regex ` the regular expression to which this string is to be matched@param `replacement ` the string to be substituted for each match@return The resulting ` String`@see kd.bos.dataentity.utils.String#replaceAll(String, String)@see kd.bos.dataentity.utils.Pattern#DOTALLreverse`public static String reverse(String str)`Reverses a String as per StringBuilder#reverse().A ` null` String returns ` null`.
@param `str` the String to reverse, may be null@return the reversed String, ` null` if null String inputright`public static String right(String str, int len)`Gets the rightmost ` len` characters of a String.If ` len` characters are not available, or the String is ` null`, the String will be returned without an an exception. An empty String is returned if len is negative.
@param `str` the String to get the rightmost characters from, may be null@param `len` the length of the required String@return the rightmost characters, ` null` if null String inputrightPad`public static String rightPad(String str, int size)`Right pad a String with spaces (' ').The String is padded to the size of ` size`.
@param `str` the String to pad out, may be null@param `size` the size to pad to@return right padded String or original String if no padding is necessary, ` null` if null String inputrightPad`public static String rightPad(String str, int size, char padChar)`Right pad a String with a specified character.The String is padded to the size of ` size`.
@param `str` the String to pad out, may be null@param `size` the size to pad to@param `padChar` the character to pad with@return right padded String or original String if no padding is necessary, ` null` if null String inputrightPad`public static String rightPad(String str, int size, String padStr)`Right pad a String with a specified String.The String is padded to the size of ` size`.
@param `str` the String to pad out, may be null@param `size` the size to pad to@param `padStr` the String to pad with, null or empty treated as single space@return right padded String or original String if no padding is necessary, ` null` if null String inputsplit`public static String[] split(String str)`Splits the provided text into an array, using whitespace as the separator. Whitespace is defined by Character#isWhitespace(char).The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.A ` null` input String returns ` null`.
@param `str` the String to parse, may be null@return an array of parsed Strings, ` null` if null String inputsplit`public static String[] split(String str, String separatorChars)`Splits the provided text into an array, separators specified. This is an alternative to using StringTokenizer.The separator is not included in the returned String array. Adjacent separators are treated as one separator. For more control over the split use the StrTokenizer class.A ` null` input String returns ` null`. A ` null` separatorChars splits on whitespace.
@param `str` the String to parse, may be null@param `separatorChars` the characters used as the delimiters, ` null` splits on whitespace@return an array of parsed Strings, ` null` if null String inputsplit`public static String[] split(String str, String separatorChars, int max)`Splits the provided text into an array with a maximum length, separators specified.The separator is not included in the returned String array. Adjacent separators are treated as one separator.A ` null` input String returns ` null`. A ` null` separatorChars splits on whitespace.If more than ` max` delimited substrings are found, the last returned string includes all characters after the first ` max - 1` returned strings (including separator characters).
@param `str` the String to parse, may be null@param `separatorChars` the characters used as the delimiters, ` null` splits on whitespace@param `max` the maximum number of elements to include in the array. A zero or negative value implies no limit@return an array of parsed Strings, ` null` if null String inputsplitByCharacterType`public static String[] splitByCharacterType(String str)`Splits a String by Character type as returned by ` java.lang.Character.getType(char)`. Groups of contiguous characters of the same type are returned as complete tokens.
@param `str` the String to split, may be ` null`@return an array of parsed Strings, ` null` if null String inputsplitByCharacterTypeCamelCase`public static String[] splitByCharacterTypeCamelCase(String str)`Splits a String by Character type as returned by ` java.lang.Character.getType(char)`. Groups of contiguous characters of the same type are returned as complete tokens, with the following exception: the character of type ` Character.UPPERCASE_LETTER`, if any, immediately preceding a token of type ` Character.LOWERCASE_LETTER` will belong to the following token rather than to the preceding, if any, ` Character.UPPERCASE_LETTER` token.
@param `str` the String to split, may be ` null`@return an array of parsed Strings, ` null` if null String inputsplitPreserveAllTokens`public static String[] splitPreserveAllTokens(String str)`Splits the provided text into an array, using whitespace as the separator, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer. Whitespace is defined by Character#isWhitespace(char).The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.A ` null` input String returns ` null`.
@param `str` the String to parse, may be ` null`@return an array of parsed Strings, ` null` if null String inputsplitPreserveAllTokens`public static String[] splitPreserveAllTokens(String str, String separatorChars)`Splits the provided text into an array, separators specified, preserving all tokens, including empty tokens created by adjacent separators. This is an alternative to using StringTokenizer.The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. For more control over the split use the StrTokenizer class.A ` null` input String returns ` null`. A ` null` separatorChars splits on whitespace.
@param `str` the String to parse, may be ` null`@param `separatorChars` the characters used as the delimiters, ` null` splits on whitespace@return an array of parsed Strings, ` null` if null String inputsplitPreserveAllTokens`public static String[] splitPreserveAllTokens(String str, String separatorChars, int max)`Splits the provided text into an array with a maximum length, separators specified, preserving all tokens, including empty tokens created by adjacent separators.The separator is not included in the returned String array. Adjacent separators are treated as separators for empty tokens. Adjacent separators are treated as one separator.A ` null` input String returns ` null`. A ` null` separatorChars splits on whitespace.If more than ` max` delimited substrings are found, the last returned string includes all characters after the first ` max - 1` returned strings (including separator characters).
@param `str` the String to parse, may be ` null`@param `separatorChars` the characters used as the delimiters, ` null` splits on whitespace@param `max` the maximum number of elements to include in the array. A zero or negative value implies no limit@return an array of parsed Strings, ` null` if null String inputstartsWith`public static boolean startsWith(CharSequence str, CharSequence prefix)`Check if a CharSequence starts with a specified prefix.` null`s are handled without exceptions. Two ` null` references are considered to be equal. The comparison is case sensitive.
@param `str` the CharSequence to check, may be null@param `prefix` the prefix to find, may be null@return ` true` if the CharSequence starts with the prefix, case sensitive, or both ` null`@see String#startsWith(String)startsWithAny`public static boolean startsWithAny(CharSequence string, CharSequence[] searchStrings)`Check if a CharSequence starts with any of an array of specified strings.
@param `string` the CharSequence to check, may be null@param `searchStrings` the CharSequences to find, may be null or empty@return ` true` if the CharSequence starts with any of the the prefixes, case insensitive, or both ` null`startsWithIgnoreCase`public static boolean startsWithIgnoreCase(CharSequence str, CharSequence prefix)`Case insensitive check if a CharSequence starts with a specified prefix.` null`s are handled without exceptions. Two ` null` references are considered to be equal. The comparison is case insensitive.
@param `str` the CharSequence to check, may be null@param `prefix` the prefix to find, may be null@return ` true` if the CharSequence starts with the prefix, case insensitive, or both ` null`@see String#startsWith(String)strip`public static String strip(String str)`Strips whitespace from the start and end of a String.This is similar to #trim(String) but removes whitespace. Whitespace is defined by Character#isWhitespace(char).A ` null` input String returns ` null`.
@param `str` the String to remove whitespace from, may be null@return the stripped String, ` null` if null String inputstrip`public static String strip(String str, String stripChars)`Strips any of a set of characters from the start and end of a String. This is similar to String#trim() but allows the characters to be stripped to be controlled.A ` null` input String returns ` null`. An empty string ("") input returns the empty string.If the stripChars String is ` null`, whitespace is stripped as defined by Character#isWhitespace(char). Alternatively use #strip(String).
@param `str` the String to remove characters from, may be null@param `stripChars` the characters to remove, null treated as whitespace@return the stripped String, ` null` if null String inputstripAccents`public static String stripAccents(String input)`Removes diacritics (~= accents) from a string. The case will not be altered.For instance, 'à' will be replaced by 'a'.Note that ligatures will be left as is.
@param `input` String to be stripped@return input text with diacritics removedstripAll`public static String[] stripAll(String[] strs)`Strips whitespace from the start and end of every String in an array. Whitespace is defined by Character#isWhitespace(char).A new array is returned each time, except for length zero. A ` null` array will return ` null`. An empty array will return itself. A ` null` array entry will be ignored.
@param `strs` the array to remove whitespace from, may be null@return the stripped Strings, ` null` if null array inputstripAll`public static String[] stripAll(String[] strs, String stripChars)`Strips any of a set of characters from the start and end of every String in an array.Whitespace is defined by Character#isWhitespace(char).A new array is returned each time, except for length zero. A ` null` array will return ` null`. An empty array will return itself. A ` null` array entry will be ignored. A ` null` stripChars will strip whitespace as defined by Character#isWhitespace(char).
@param `strs` the array to remove characters from, may be null@param `stripChars` the characters to remove, null treated as whitespace@return the stripped Strings, ` null` if null array inputstripEnd`public static String stripEnd(String str, String stripChars)`Strips any of a set of characters from the end of a String.A ` null` input String returns ` null`. An empty string ("") input returns the empty string.If the stripChars String is ` null`, whitespace is stripped as defined by Character#isWhitespace(char).
@param `str` the String to remove characters from, may be null@param `stripChars` the set of characters to remove, null treated as whitespace@return the stripped String, ` null` if null String inputstripStart`public static String stripStart(String str, String stripChars)`Strips any of a set of characters from the start of a String.A ` null` input String returns ` null`. An empty string ("") input returns the empty string.If the stripChars String is ` null`, whitespace is stripped as defined by Character#isWhitespace(char).
@param `str` the String to remove characters from, may be null@param `stripChars` the characters to remove, null treated as whitespace@return the stripped String, ` null` if null String inputstripToEmpty`public static String stripToEmpty(String str)`Strips whitespace from the start and end of a String returning an empty String if ` null` input.This is similar to #trimToEmpty(String) but removes whitespace. Whitespace is defined by Character#isWhitespace(char).
@param `str` the String to be stripped, may be null@return the trimmed String, or an empty String if ` null` inputstripToNull`public static String stripToNull(String str)`Strips whitespace from the start and end of a String returning ` null` if the String is empty ("") after the strip.This is similar to #trimToNull(String) but removes whitespace. Whitespace is defined by Character#isWhitespace(char).
@param `str` the String to be stripped, may be null@return the stripped String, ` null` if whitespace, empty or null String inputsubstring`public static String substring(String str, int start)`Gets a substring from the specified String avoiding exceptions.A negative start position can be used to start ` n` characters from the end of the String.A ` null` String will return ` null`. An empty ("") String will return "".
@param `str` the String to get the substring from, may be null@param `start` the position to start from, negative means count back from the end of the String by this many characters@return substring from start position, ` null` if null String inputsubstring`public static String substring(String str, int start, int end)`Gets a substring from the specified String avoiding exceptions.A negative start position can be used to start/end ` n` characters from the end of the String.The returned substring starts with the character in the ` start` position and ends before the ` end` position. All position counting is zero-based -- i.e., to start at the beginning of the string use ` start = 0`. Negative start and end positions can be used to specify offsets relative to the end of the String.If ` start` is not strictly to the left of ` end`, "" is returned.
@param `str` the String to get the substring from, may be null@param `start` the position to start from, negative means count back from the end of the String by this many characters@param `end` the position to end at (exclusive), negative means count back from the end of the String by this many characters@return substring from start position to end position, ` null` if null String inputsubstringAfter`public static String substringAfter(String str, String separator)`Gets the substring after the first occurrence of a separator. The separator is not returned.A ` null` string input will return ` null`. An empty ("") string input will return the empty string. A ` null` separator will return the empty string if the input string is not ` null`.If nothing is found, the empty string is returned.
@param `str` the String to get a substring from, may be null@param `separator` the String to search for, may be null@return the substring after the first occurrence of the separator, ` null` if null String inputsubstringAfterLast`public static String substringAfterLast(String str, String separator)`Gets the substring after the last occurrence of a separator. The separator is not returned.A ` null` string input will return ` null`. An empty ("") string input will return the empty string. An empty or ` null` separator will return the empty string if the input string is not ` null`.If nothing is found, the empty string is returned.
@param `str` the String to get a substring from, may be null@param `separator` the String to search for, may be null@return the substring after the last occurrence of the separator, ` null` if null String inputsubstringBefore`public static String substringBefore(String str, String separator)`Gets the substring before the first occurrence of a separator. The separator is not returned.A ` null` string input will return ` null`. An empty ("") string input will return the empty string. A ` null` separator will return the input string.If nothing is found, the string input is returned.
@param `str` the String to get a substring from, may be null@param `separator` the String to search for, may be null@return the substring before the first occurrence of the separator, ` null` if null String inputsubstringBeforeLast`public static String substringBeforeLast(String str, String separator)`Gets the substring before the last occurrence of a separator. The separator is not returned.A ` null` string input will return ` null`. An empty ("") string input will return the empty string. An empty or ` null` separator will return the input string.If nothing is found, the string input is returned.
@param `str` the String to get a substring from, may be null@param `separator` the String to search for, may be null@return the substring before the last occurrence of the separator, ` null` if null String inputsubstringBetween`public static String substringBetween(String str, String tag)`Gets the String that is nested in between two instances of the same String.A ` null` input String returns ` null`. A ` null` tag returns ` null`.
@param `str` the String containing the substring, may be null@param `tag` the String before and after the substring, may be null@return the substring, ` null` if no matchsubstringBetween`public static String substringBetween(String str, String open, String close)`Gets the String that is nested in between two Strings. Only the first match is returned.A ` null` input String returns ` null`. A ` null` open/close returns ` null` (no match). An empty ("") open and close returns an empty string.
@param `str` the String containing the substring, may be null@param `open` the String before the substring, may be null@param `close` the String after the substring, may be null@return the substring, ` null` if no matchswapCase`public static String swapCase(String str)`Swaps the case of a String changing upper and title case to lower case, and lower case to upper case.
@param `str` the String to be trimmed, may be null@return the trimmed string, ` null` if null String inputtrimToEmpty`public static String trimToEmpty(String str)`Removes control characters (char <= 32) from both ends of this String returning an empty String ("") if the String is empty ("") after the trim or if it is ` null`. The String is trimmed using String#trim(). Trim removes start and end characters <= 32. To strip whitespace use #stripToEmpty(String).
@param `str` the String to be trimmed, may be null@return the trimmed String, or an empty String if ` null` inputtrimToNull`public static String trimToNull(String str)`Removes control characters (char <= 32) from both ends of this String returning ` null` if the String is empty ("") after the trim or if it is ` null`. The String is trimmed using String#trim(). Trim removes start and end characters <= 32. To strip whitespace use #stripToNull(String).
@param `str` the String to be trimmed, may be null@return the trimmed String, ` null` if only chars <= 32, empty or null String inputuncapitalize`public static String uncapitalize(String str)`Uncapitalizes a String changing the first letter to title case as per Character#toLowerCase(char). No other letters are changed.For a word based algorithm, see org.apache.commons.lang3.text.WordUtils#uncapitalize(String). A ` null` input String returns ` null`.
@param `str` the String to uncapitalize, may be null@return the uncapitalized String, ` null` if null String input@see org.apache.commons.lang3.text.WordUtils#uncapitalize(String)@see ##capitalize(String)upperCase`public static String upperCase(String str)`Converts a String to upper case as per String#toUpperCase().A ` null` input String returns ` null`.
@param `str` the String to upper case, may be null@param `locale` the locale that defines the case transformation rules, must not be null@return the upper cased String, ` null` if null String inputwrap`public static String wrap(String str, char wrapWith)` Wraps a string with a char.
@param `str` ` the string to be wrapped, may be ` null`@param `wrapWith ` the char that will wrap ` str`@return the wrapped string, or ` null` if ` str==null`wrap`public static String wrap(String str, String wrapWith)` Wraps a String with another String.  A ` null` input String returns ` null`.
@param `str` ` the String to be wrapper, may be null@param `wrapWith ` the String that will wrap str@return wrapped String, ` null` if null String input


class_name: kd.bos.dataentity.utils.StringUtils
method_name: removePattern
param_types_key: String,String
signature_text: removePattern(String source, String regex)
comment:
Removes each substring of the source String that matches the given regular expression using the DOTALL option.


class_name: kd.bos.dataentity.utils.StringUtils
method_name: replacePattern
param_types_key: String,String,String
signature_text: replacePattern(String source, String regex, String replacement)
comment:
Replaces each substring of the source String that matches the given regular expression with the given


class_name: kd.bos.db.archive.ArchiveInfo
method_name: <init>
param_types_key: String,ArchiveRouteType,String,String
comment: 构造方法 @param `key` @param `routeType` @param `name` @param `desc`
signature_text:
public ArchiveInfo(String key, kd.bos.db.archive.ArchiveRouteType routeType, String name, String desc)


class_name: kd.bos.devportal.common.util.SubSysTreeBuilder
method_name: <init>
param_types_key: List,List,String
comment: 子系统树构造函数 @param `bizCloudIds` @param `bizAppIds` @param `industryId`
signature_text:
public SubSysTreeBuilder(java.util.List<String> bizCloudIds, java.util.List<String> bizAppIds, String industryId)


class_name: kd.bos.dts.configoperator.DtsConfigOperator
method_name: deleteDtsConfig
param_types_key: String,String,String,String,String
comment: 删除同步同步配置
signature_text:
deleteDtsConfig(String entityNumber, String businessType, String region, String mappingRule, String destType)


class_name: kd.bos.dts.configoperator.DtsConfigOperator
method_name: disableDtsConfig
param_types_key: String,String,String,String,String
comment: 禁用数据同步配置
signature_text:
disableDtsConfig(String entityNumber, String businessType, String region, String mappingRule, String destType)


class_name: kd.bos.dts.configoperator.DtsConfigOperator
method_name: enableDtsConfig
param_types_key: String,String,String,String,String
comment: 启用数据同步配置
signature_text:
enableDtsConfig(String entityNumber, String businessType, String region, String mappingRule, String destType)


class_name: kd.bos.dts.configoperator.DtsConfigOperator
method_name: existsSyncConfigSnapshot
param_types_key: String,String,String,String
comment: 是否存在配置快照
signature_text:
existsSyncConfigSnapshot(String entityNumber, String businessType, String region, String mappingRule)


class_name: kd.bos.dts.configoperator.DtsConfigOperator
method_name: existsSyncConfigSnapshot
param_types_key: String,String,String,String,String
comment: 是否存在配置快照
signature_text:
existsSyncConfigSnapshot(String entityNumber, String businessType, String region, String mappingRule, String destType)


class_name: kd.bos.dts.configoperator.DtsConfigOperatorInfo
method_name: <init>
param_types_key: String,DtsDestTypeEnum,String,String,String,String[],String,String
comment: 构造同步配置对象
signature_text:
DtsConfigOperatorInfo(String entityNumber, kd.bos.dts.enmu.DtsDestTypeEnum dtsDestType, String region, String businessType, String mappingRule, String[] entityFields, String enable, String timingSequence)


class_name: kd.bos.entity.AnchorItems
method_name: <init>
param_types_key: String,String,List,BadgeInfo
comment: 构造方法 @param `targetId` 锚点项标识 @param `caption` 锚点项标题 @param `items` 下级锚点 @param `badgeInfo` 徽标
signature_text:
public AnchorItems(String targetId, String caption, java.util.List<AnchorItems > items, BadgeInfo badgeInfo)


class_name: kd.bos.entity.BasedataEntityType
method_name: createEntityTreeNodes
param_types_key: EntityTreeNode,boolean,boolean
signature_text:
public java.util.List<java.util.Map<String, Object>> createEntityTreeNodes(kd.bos.entity.property.EntityTreeNode parentEntityTreeNode, boolean isIncludeEntry, boolean isAllNode)


class_name: kd.bos.entity.BasedataEntityType
method_name: isDataLoadNoCache
signature_text: public boolean isDataLoadNoCache()
comment:
获取数据加载时是否不使用缓存的设置
此方法用于确定在加载数据时是否应忽略缓存数据，如果返回true，则表示每次加载数据时先从本地缓存中获取，地缓存不存在则直接从数据库加载
@return 如果数据加载时不应使用缓存，则返回true；否则返回false


class_name: kd.bos.entity.BillEntityType
method_name: setOrgRelationConfigList
param_types_key: Map
comment: 设置组织委托关系配置列表 @param `orgRelationConfigList`
signature_text:
public void setOrgRelationConfigList(java.util.Map<String, OrgRelationConfig> orgRelationConfigList)


class_name: kd.bos.entity.botp.AttachmentPanelMapPolicy
method_name: check
param_types_key: MainEntityType,MainEntityType,ConvertRuleElement,CheckPoint,CheckResult,Map
signature_text:
public void check(MainEntityType srcMainType, MainEntityType tgtMainType, ConvertRuleElement rule, CheckPoint parentPoint, CheckResult checkResult, java.util.Map<Integer, kd.bos.entity.botp.extcontrol.ExtControlElement> elementMap)

comment:
检查配置是否合理
@param `srcMainType`
@param `tgtMainType`
@param `rule`
@param `parentPoint`
@param `checkResult`


class_name: kd.bos.entity.botp.ConvertRuleCache
method_name: batchLoadRules
param_types_key: List
comment: 批量读取两个单据之间的全部转换规则 @param `keys`
signature_text:
public static java.util.Map<kd.bos.entity.botp.ConvertRuleKeyPair, java.util.List<ConvertRuleElement>> batchLoadRules(java.util.List<kd.bos.entity.botp.ConvertRuleKeyPair> keys)


class_name: kd.bos.entity.botp.ConvertRuleCache
method_name: loadRules
param_types_key: String,String
comment: 读取两个单据之间的全部转换规则 @param `sourceEntityNumber` @param `targetEntityNumber`
signature_text:
public static java.util.List<ConvertRuleElement> loadRules(String sourceEntityNumber, String targetEntityNumber)


class_name: kd.bos.entity.botp.ConvertRuleElement
method_name: check
param_types_key: CheckPoint,CheckResult,Map
comment: 检查规则配置是否合理 @param `parentPoint` 父检查点 @param `checkResult` 输出检查结果
signature_text:
public boolean check(CheckPoint parentPoint, CheckResult checkResult, java.util.Map<Integer, kd.bos.entity.botp.extcontrol.ExtControlElement> elementMap)


class_name: kd.bos.entity.botp.ConvertRuleElement
method_name: setExtElements
param_types_key: List
comment: 开闭策略节点信息
signature_text:
public void setExtElements(java.util.List<kd.bos.entity.botp.extcontrol.ExtControlElement> extElements)


class_name: kd.bos.entity.botp.CRCondition
method_name: buildFullFormula
param_types_key: MainEntityType,IUserService,ITimeService
signature_text:
public String buildFullFormula(MainEntityType mainType, IUserService userService, ITimeService timeService)

comment:
合并条件表格、手书条件，生成一条完整的表达式
@param `mainType`
@param `timeService` 解析条件需要用到的时间服务（解析"今天"等比较符）
@param `userService` 解析条件需要用到的用户服务（解析"我的部门"等比较符）


class_name: kd.bos.entity.botp.FieldMapItem
method_name: check
param_types_key: MainEntityType,MainEntityType,ConvertRuleElement,CheckPoint,CheckResult,Map
signature_text:
public void check(MainEntityType srcMainType, MainEntityType tgtMainType, ConvertRuleElement rule, CheckPoint parentPoint, CheckResult checkResult, java.util.Map<String, Boolean> fieldMap)

comment:
检查配置是否合理
@param `srcMainType`
@param `tgtMainType`
@param `rule`
@param `parentPoint`
@param `checkResult`


class_name: kd.bos.entity.botp.plugin.AbstractConvertPlugIn
method_name: setContext
param_types_key: ConvertOpType,BillEntityType,BillEntityType,ConvertRuleElement
signature_text:
public void setContext(ConvertOpType opType, BillEntityType srcMainType, BillEntityType tgtMainType, ConvertRuleElement rule)


class_name: kd.bos.entity.botp.plugin.args.AfterBizRuleEventArgs
method_name: <init>
param_types_key: ExtendedDataEntitySet,Map
signature_text:
public AfterBizRuleEventArgs(ExtendedDataEntitySet targetExtDataEntitySet, java.util.Map<String, DynamicProperty> fldProperties)

comment:
构造函数
@param `targetExtDataEntitySet` 生成的目标单空数据包
@param `fldProperties` 源单字段，与数据包属性对应字典，可以据此到源单数据包中读取字段值


class_name: kd.bos.entity.botp.plugin.args.AfterBuildQueryParemeterEventArgs
method_name: <init>
param_types_key: Map,List
comment: 构造函数 @param `srcFldAlias` @param `qFilters`
signature_text:
public AfterBuildQueryParemeterEventArgs(java.util.Map<String, String> srcFldAlias, java.util.List<QFilter> qFilters)


class_name: kd.bos.entity.botp.plugin.args.AfterBuildRowConditionEventArgs
method_name: getConditons
comment: 拆分后的单据转换数据筛选条件，每个元素都是一个独立的条件
signature_text:
public java.util.List<kd.bos.entity.botp.plugin.args.AfterBuildRowConditionEventArgs.ConditionInfo> getConditons()


class_name: kd.bos.entity.botp.plugin.args.AfterBuildSourceBillIdsEventArgs
method_name: <init>
param_types_key: BillEntityType,List,Set
comment: 构造函数 @param `srcMainType` 上游源单主实体，包含了完整字段
signature_text:
public AfterBuildSourceBillIdsEventArgs(BillEntityType srcMainType, java.util.List<WriteBackRuleElement> ruleElements, java.util.Set<Long> billIds)


class_name: kd.bos.entity.botp.plugin.args.AfterBuildSourceBillIdsEventArgs
method_name: addEntryInfo
param_types_key: EntryInfo
comment: 增加分录信息
signature_text:
public void addEntryInfo(kd.bos.entity.botp.plugin.args.AfterBuildSourceBillIdsEventArgs.EntryInfo e)


class_name: kd.bos.entity.botp.plugin.args.AfterBuildSourceBillIdsEventArgs
method_name: getEntryInfos
comment: 获取分录信息
signature_text:
public java.util.List<kd.bos.entity.botp.plugin.args.AfterBuildSourceBillIdsEventArgs.EntryInfo> getEntryInfos()


class_name: kd.bos.entity.botp.plugin.args.AfterCalcWriteValueEventArgs
method_name: <init>
param_types_key: EntityType,DynamicObject,WriteBackRuleElement,WriteBackFormula,BigDecimal,Object
signature_text:
public AfterCalcWriteValueEventArgs(EntityType entity, DynamicObject activeRow, WriteBackRuleElement rule, WriteBackFormula ruleItem, java.math.BigDecimal val, Object cVal)

comment:
构造函数
@param `entity` 关联主实体
@param `activeRow` 关联主实体当前行
@param `rule` 反写规则
@param `ruleItem` 反写公式
@param `val` 根据反写公式，算出的反写量
@param `cVal` 覆盖反写模式，根据反写公式算出的覆盖值


class_name: kd.bos.entity.botp.plugin.args.AfterCloseRowEventArgs
method_name: <init>
param_types_key: WriteBackRuleElement,BillEntityType,EntityType,DynamicObject,EntityType,DynamicObject
signature_text:
public AfterCloseRowEventArgs(WriteBackRuleElement rule, BillEntityType srcSubMainType, EntityType srcEntity, DynamicObject srcActiveRow, EntityType targetEntity, DynamicObject targetActiveRow)

comment:
构造函数
@param `rule` 反写规则
@param `srcSubMainType` 上游源单主实体，仅包含需要用到的字段
@param `srcEntity` 上游源单，关联主实体
@param `srcActiveRow` 上游源单，关联主实体数据行
@param `targetEntity` 下游目标单关联主实体
@param `targetActiveRow` 下游目标单关联主实体，当前数据行


class_name: kd.bos.entity.botp.plugin.args.AfterCommitAmountEventArgs
method_name: <init>
param_types_key:
WriteBackRuleElement,WriteBackFormula,BillEntityType,EntityType,DynamicObject,String,BigDecimal,BigDecimal,Object,EntityType,DynamicObject

signature_text:
public AfterCommitAmountEventArgs(WriteBackRuleElement rule, WriteBackFormula ruleItem, BillEntityType srcSubMainType, EntityType srcEntity, DynamicObject srcActiveRow, String srcFieldKey, java.math.BigDecimal currVal, java.math.BigDecimal realVal, Object currCVal, EntityType targetEntity, DynamicObject targetActiveRow)

comment:
构造函数
@param `rule` 反写规则
@param `ruleItem` 反写公式
@param `srcSubMainType` 上游源单主实体，仅包含需要用到的字段
@param `srcEntity` 上游源单，关联主实体
@param `srcActiveRow` 上游源单，关联主实体数据行
@param `srcFieldKey` 上游源单反写字段
@param `currVal` 本次操作，对源单行执行的反写差量
@param `realVal` 本次操作执行完毕完后，对源单行的反写总量
@param `currCVal` 覆盖反写值
@param `targetEntity` 下游目标单关联主实体
@param `targetActiveRow` 下游目标单关联主实体，当前数据行


class_name: kd.bos.entity.botp.plugin.args.AfterConvertEventArgs
method_name: <init>
param_types_key: ExtendedDataEntitySet,Map
signature_text:
public AfterConvertEventArgs(ExtendedDataEntitySet targetExtDataEntitySet, java.util.Map<String, DynamicProperty> fldProperties)

comment:
构造函数
@param `targetExtDataEntitySet` 生成的目标单空数据包
@param `fldProperties` 源单字段，与数据包属性对应字典，可以据此到源单数据包中读取字段值


class_name: kd.bos.entity.botp.plugin.args.AfterCreateLinkEventArgs
method_name: <init>
param_types_key: ExtendedDataEntitySet,Map
signature_text:
public AfterCreateLinkEventArgs(ExtendedDataEntitySet targetExtDataEntitySet, java.util.Map<String, DynamicProperty> fldProperties)

comment:
构造函数
@param `targetExtDataEntitySet` 生成的目标单空数据包
@param `fldProperties` 源单字段，与数据包属性对应字典，可以据此到源单数据包中读取字段值


class_name: kd.bos.entity.botp.plugin.args.AfterCreateTargetEventArgs
method_name: <init>
param_types_key: ExtendedDataEntitySet,Map
signature_text:
public AfterCreateTargetEventArgs(ExtendedDataEntitySet targetExtDataEntitySet, java.util.Map<String, DynamicProperty> fldProperties)


class_name: kd.bos.entity.botp.plugin.args.AfterFieldMappingEventArgs
method_name: <init>
param_types_key: ExtendedDataEntitySet,Map
signature_text:
public AfterFieldMappingEventArgs(ExtendedDataEntitySet targetExtDataEntitySet, java.util.Map<String, DynamicProperty> fldProperties)


class_name: kd.bos.entity.botp.plugin.args.AfterGetSourceDataEventArgs
method_name: <init>
param_types_key: List,Map
comment: 构造函数 @param `sourceRows` 待下推的源单数据行 @param `fldProperties` 源单字段，与数据包属性对应字典，可以据此到源单数据包中读取字段值
signature_text:
public AfterGetSourceDataEventArgs(java.util.List<DynamicObject> sourceRows, java.util.Map<String, DynamicProperty> fldProperties)


class_name: kd.bos.entity.botp.plugin.args.AfterSaveSourceBillEventArgs
method_name: isNewThread
signature_text: public boolean isNewThread()
comment:
当前事件是否由异步线程触发，不在事务内：跨库反写时，会启动一个异步线程，在事务外单独的保存源单反写结果，没有事务保护，不能回滚数据。 此时插件抛出异常并不能取消反写，回滚数据。因此，此场景下插件要确保不抛出异常


class_name: kd.bos.entity.botp.plugin.args.BeforeBuildGroupModeEventArgs
method_name: <init>
param_types_key: String,String,String
signature_text:
public BeforeBuildGroupModeEventArgs(String headGroupKey, String entryGroupKey, String subEntryGroupKey)

comment:
构造函数
@param `headGroupKey` 单据头分组(分单)字段
@param `entryGroupKey` 单据体分组字段
@param `subEntryGroupKey` 子单据体分组字段


class_name: kd.bos.entity.botp.plugin.args.BeforeCloseRowEventArgs
method_name: <init>
param_types_key: WriteBackRuleElement,BillEntityType,EntityType,DynamicObject,EntityType,DynamicObject
signature_text:
public BeforeCloseRowEventArgs(WriteBackRuleElement rule, BillEntityType srcSubMainType, EntityType srcEntity, DynamicObject srcActiveRow, EntityType targetEntity, DynamicObject targetActiveRow)

comment:
构造函数
@param `rule` 反写规则
@param `srcSubMainType` 上游源单主实体，仅包含需要用到的字段
@param `srcEntity` 上游源单，关联主实体
@param `srcActiveRow` 上游源单，关联主实体数据行
@param `targetEntity` 下游目标单关联主实体
@param `targetActiveRow` 下游目标单关联主实体，当前数据行


class_name: kd.bos.entity.botp.plugin.args.BeforeCreateArticulationRowEventArgs
method_name: <init>
param_types_key: EntityType,DynamicObject,DynamicObjectCollection
signature_text:
public BeforeCreateArticulationRowEventArgs(EntityType entity, DynamicObject activeRow, DynamicObjectCollection linkRows)

comment:
构造函数
@param `entity` 当前关联主实体
@param `activeRow` 关联主实体当前行
@param `linkRows` 关联主实体行下属的关联子实体行，包含了来源单据行信息


class_name: kd.bos.entity.botp.plugin.args.BeforeCreateLinkEventArgs
method_name: <init>
param_types_key: ExtendedDataEntitySet,Map
comment: 构造函数 @param `targetExtDataEntitySet` @param `fldProperties`
signature_text:
public BeforeCreateLinkEventArgs(ExtendedDataEntitySet targetExtDataEntitySet, java.util.Map<String, DynamicProperty> fldProperties)


class_name: kd.bos.entity.botp.plugin.args.BeforeExcessCheckEventArgs
method_name: <init>
param_types_key: WriteBackRuleElement,BillEntityType,EntityType,DynamicObject,EntityType,DynamicObject
signature_text:
public BeforeExcessCheckEventArgs(WriteBackRuleElement rule, BillEntityType srcSubMainType, EntityType srcEntity, DynamicObject srcActiveRow, EntityType targetEntity, DynamicObject targetActiveRow)

comment:
构造函数
@param `rule` 反写规则
@param `srcSubMainType` 上游源单主实体，仅包含需要用到的字段
@param `srcEntity` 上游源单，关联主实体
@param `srcActiveRow` 上游源单，关联主实体数据行
@param `targetEntity` 下游目标单关联主实体
@param `targetActiveRow` 下游目标单关联主实体，当前数据行


class_name: kd.bos.entity.botp.plugin.args.BeforeReadSourceBillEventArgs
method_name: <init>
param_types_key: BillEntityType,List
comment: 构造函数 @param `srcMainType` 上游源单主实体，包含了完整字段 @param `rules` 反写上游源单的全部反写规则
signature_text:
public BeforeReadSourceBillEventArgs(BillEntityType srcMainType, java.util.List<WriteBackRuleElement> rules)


class_name: kd.bos.entity.botp.plugin.args.BeforeSaveSourceBillEventArgs
method_name: <init>
param_types_key: BillEntityType,DynamicObject[]
comment: 构造函数 @param `srcSubMainType` 源单主实体，只包含了部分用到的字段 @param `srcDataEntities` 源单数据包，只包含了部分用到的字段
signature_text:
public BeforeSaveSourceBillEventArgs(BillEntityType srcSubMainType, DynamicObject[] srcDataEntities)


class_name: kd.bos.entity.botp.plugin.IConvertPlugIn
method_name: setContext
param_types_key: ConvertOpType,BillEntityType,BillEntityType,ConvertRuleElement
comment: 开始执行转换规则之前，创建规则上挂的插件后，触发此事件 @param `opType` @param `srcMainType` @param `tgtMainType` @param `rule`
signature_text:
void setContext(ConvertOpType opType, BillEntityType srcMainType, BillEntityType tgtMainType, ConvertRuleElement rule)


class_name: kd.bos.entity.botp.runtime.BeforeDrawArgs
method_name: <init>
param_types_key: String,String,String,String
signature_text:
public BeforeDrawArgs(String sourceEntityNumber, String targetEntityNumber, String ruleId, String targetPageId)

comment:
构造函数
@param `sourceEntityNumber` 源单主实体编码
@param `targetEntityNumber` 目标单主实体编码
@param `ruleId` 转换规则ID
@param `targetPageId` 目标单界面PageId


class_name: kd.bos.entity.botp.runtime.BFRowId
method_name: <init>
param_types_key: Long,Long,Long,Long
signature_text: public BFRowId(Long mainTableId, Long billId, Long tableId, Long entryId)
comment:
构造函数
@param `mainTableId` 单据主表的表格编码
@param `billId` 单据内码
@param `tableId` 表格编码
@param `entryId` 实体行内码


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: addTargetDataObjects
param_types_key: IRefrencedataProvider,MainEntityType,List
comment: 把生成的目标单，存入缓存 @param `refDataProvider` 引用数据读取服务 @param `mainType` 主实体 @param `dataEntities` 目标单
signature_text:
public void addTargetDataObjects(IRefrencedataProvider refDataProvider, MainEntityType mainType, java.util.List<DynamicObject> dataEntities)


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: cacheAutoSavedDataObjects
param_types_key: IRefrencedataProvider,MainEntityType,List
comment: 把生成的目标单，存入缓存 @param `refDataProvider` 引用数据读取服务 @param `mainType` 主实体 @param `dataEntities` 目标单
signature_text:
public java.util.List<String> cacheAutoSavedDataObjects(IRefrencedataProvider refDataProvider, MainEntityType mainType, java.util.List<DynamicObject> dataEntities)


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: getBillAttachmentPanelInfos
comment: 转换规则生成的下游单的附件
signature_text:
public java.util.Map<Object, java.util.Map<String, java.util.List<kd.bos.entity.botp.runtime.AttachmentItemInfo>>> getBillAttachmentPanelInfos()


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: loadAutoSavedDataObjects
param_types_key: IDataProvider,MainEntityType,Object
comment: 从数据库读取单据数据包 @param `refDataProvider` 引用数据读取服务 @param `mainType` 主实体 @param `pkId` 单据内码
signature_text:
public DynamicObject loadAutoSavedDataObjects(IDataProvider refDataProvider, MainEntityType mainType, Object pkId)


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: loadTargetDataObject
param_types_key: IRefrencedataProvider,MainEntityType,String
signature_text:
public DynamicObject loadTargetDataObject(IRefrencedataProvider refDataProvider, MainEntityType mainType, String pageId)

comment:
从缓存中，读取指定单据返回
@param `refDataProvider` 引用数据读取服务
@param `mainType` 主实体
@param `pageId` 缓存目标单时，给目标单随机生成的唯一标识


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: loadTargetDataObject
param_types_key: IRefrencedataProvider,MainEntityType,String,boolean
signature_text:
public DynamicObject loadTargetDataObject(IRefrencedataProvider refDataProvider, MainEntityType mainType, String pageId, boolean loadReference)

comment:
从缓存中，读取指定单据返回
@param `refDataProvider` 引用数据读取服务
@param `mainType` 主实体
@param `pageId` 缓存目标单时，给目标单随机生成的唯一标识
@param `loadReference` 加载引用


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: loadTargetDataObjects
param_types_key: IRefrencedataProvider,MainEntityType
comment: 从缓存中，读取全部目标单返回；读取后，自动清除全部缓存 @param `refDataProvider` 引用数据读取服务 @param `mainType` 主实体
signature_text:
public java.util.List<DynamicObject> loadTargetDataObjects(IRefrencedataProvider refDataProvider, MainEntityType mainType)


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: loadTargetDataObjects
param_types_key: IRefrencedataProvider,MainEntityType,boolean
signature_text:
public java.util.List<DynamicObject> loadTargetDataObjects(IRefrencedataProvider refDataProvider, MainEntityType mainType, boolean releaseCach)

comment:
从缓存中，读取全部目标单返回；读取后，根据参数控制是否清除缓存
@param `refDataProvider`
@param `mainType`
@param `releaseCach` 是否同时清除缓存


class_name: kd.bos.entity.botp.runtime.ConvertOperationResult
method_name: updateTargetDataObject
param_types_key: String,DynamicObject,boolean
comment: 更新单据数据包 @param `pageId` 目标单唯一标识 @param `dataEntity` 目标单最新的数据包 @param `isFullEntityType` 是否所有更新所有实体
signature_text:
public void updateTargetDataObject(String pageId, DynamicObject dataEntity, boolean isFullEntityType)


class_name: kd.bos.entity.botp.runtime.DrawArgs
method_name: <init>
param_types_key: String,String,String,List,String
signature_text:
public DrawArgs(String sourceEntityNumber, String targetEntityNumber, String ruleId, java.util.List<ListSelectedRow> selectedRows, String targetPageId)

comment:
构造函数
@param `sourceEntityNumber` 源单主实体编码
@param `targetEntityNumber` 目标单主实体编码
@param `ruleId` 规则内码
@param `selectedRows` 所选源单行集合
@param `targetPageId` 目标单界面PageId


class_name: kd.bos.entity.botp.runtime.PushArgs
method_name: <init>
param_types_key: String,String,List
signature_text:
public PushArgs(String sourceEntityNumber, String targetEntityNumber, java.util.List<ListSelectedRow> selectedRows)

comment:
构造函数
@param `sourceEntityNumber` 源单主实体编码
@param `targetEntityNumber` 目标单主实体编码
@param `selectedRows` 待下推的源单数据行


class_name: kd.bos.entity.botp.WriteBackBizRule
method_name: check
param_types_key: MainEntityType,String,CheckPoint,CheckResult
comment: 检查配置是否合理 @param `srcMainType` @param `srcEntityKey` @param `parentPoint` @param `checkResult`
signature_text:
public void check(MainEntityType srcMainType, String srcEntityKey, CheckPoint parentPoint, CheckResult checkResult)


class_name: kd.bos.entity.botp.WriteBackFormula
method_name: check
param_types_key: MainEntityType,MainEntityType,CheckPoint,CheckResult
comment: 检查配置是否合理 @param `srcMainType` @param `tgtMainType` @param `parentPoint` @param `checkResult`
signature_text:
public boolean check(MainEntityType srcMainType, MainEntityType tgtMainType, CheckPoint parentPoint, CheckResult checkResult)


