001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.documentlibrary.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.documentlibrary.model.DLFileEntryType; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the document library file entry type service. This utility wraps {@link com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryTypePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see DLFileEntryTypePersistence 038 * @see com.liferay.portlet.documentlibrary.service.persistence.impl.DLFileEntryTypePersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class DLFileEntryTypeUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(DLFileEntryType dlFileEntryType) { 060 getPersistence().clearCache(dlFileEntryType); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<DLFileEntryType> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<DLFileEntryType> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<DLFileEntryType> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<DLFileEntryType> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static DLFileEntryType update(DLFileEntryType dlFileEntryType) { 101 return getPersistence().update(dlFileEntryType); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static DLFileEntryType update(DLFileEntryType dlFileEntryType, 108 ServiceContext serviceContext) { 109 return getPersistence().update(dlFileEntryType, serviceContext); 110 } 111 112 /** 113 * Returns all the document library file entry types where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching document library file entry types 117 */ 118 public static List<DLFileEntryType> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the document library file entry types where uuid = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of document library file entry types 131 * @param end the upper bound of the range of document library file entry types (not inclusive) 132 * @return the range of matching document library file entry types 133 */ 134 public static List<DLFileEntryType> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the document library file entry types where uuid = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of document library file entry types 148 * @param end the upper bound of the range of document library file entry types (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching document library file entry types 151 */ 152 public static List<DLFileEntryType> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first document library file entry type in the ordered set where uuid = ?. 159 * 160 * @param uuid the uuid 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching document library file entry type 163 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 164 */ 165 public static DLFileEntryType findByUuid_First(java.lang.String uuid, 166 OrderByComparator<DLFileEntryType> orderByComparator) 167 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 168 return getPersistence().findByUuid_First(uuid, orderByComparator); 169 } 170 171 /** 172 * Returns the first document library file entry type in the ordered set where uuid = ?. 173 * 174 * @param uuid the uuid 175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 176 * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 177 */ 178 public static DLFileEntryType fetchByUuid_First(java.lang.String uuid, 179 OrderByComparator<DLFileEntryType> orderByComparator) { 180 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the last document library file entry type in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the last matching document library file entry type 189 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 190 */ 191 public static DLFileEntryType findByUuid_Last(java.lang.String uuid, 192 OrderByComparator<DLFileEntryType> orderByComparator) 193 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 194 return getPersistence().findByUuid_Last(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last document library file entry type in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 203 */ 204 public static DLFileEntryType fetchByUuid_Last(java.lang.String uuid, 205 OrderByComparator<DLFileEntryType> orderByComparator) { 206 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 207 } 208 209 /** 210 * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = ?. 211 * 212 * @param fileEntryTypeId the primary key of the current document library file entry type 213 * @param uuid the uuid 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next document library file entry type 216 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 217 */ 218 public static DLFileEntryType[] findByUuid_PrevAndNext( 219 long fileEntryTypeId, java.lang.String uuid, 220 OrderByComparator<DLFileEntryType> orderByComparator) 221 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 222 return getPersistence() 223 .findByUuid_PrevAndNext(fileEntryTypeId, uuid, 224 orderByComparator); 225 } 226 227 /** 228 * Removes all the document library file entry types where uuid = ? from the database. 229 * 230 * @param uuid the uuid 231 */ 232 public static void removeByUuid(java.lang.String uuid) { 233 getPersistence().removeByUuid(uuid); 234 } 235 236 /** 237 * Returns the number of document library file entry types where uuid = ?. 238 * 239 * @param uuid the uuid 240 * @return the number of matching document library file entry types 241 */ 242 public static int countByUuid(java.lang.String uuid) { 243 return getPersistence().countByUuid(uuid); 244 } 245 246 /** 247 * Returns the document library file entry type where uuid = ? and groupId = ? or throws a {@link NoSuchFileEntryTypeException} if it could not be found. 248 * 249 * @param uuid the uuid 250 * @param groupId the group ID 251 * @return the matching document library file entry type 252 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 253 */ 254 public static DLFileEntryType findByUUID_G(java.lang.String uuid, 255 long groupId) 256 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 257 return getPersistence().findByUUID_G(uuid, groupId); 258 } 259 260 /** 261 * Returns the document library file entry type where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 262 * 263 * @param uuid the uuid 264 * @param groupId the group ID 265 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 266 */ 267 public static DLFileEntryType fetchByUUID_G(java.lang.String uuid, 268 long groupId) { 269 return getPersistence().fetchByUUID_G(uuid, groupId); 270 } 271 272 /** 273 * Returns the document library file entry type where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @param retrieveFromCache whether to use the finder cache 278 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 279 */ 280 public static DLFileEntryType fetchByUUID_G(java.lang.String uuid, 281 long groupId, boolean retrieveFromCache) { 282 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 283 } 284 285 /** 286 * Removes the document library file entry type where uuid = ? and groupId = ? from the database. 287 * 288 * @param uuid the uuid 289 * @param groupId the group ID 290 * @return the document library file entry type that was removed 291 */ 292 public static DLFileEntryType removeByUUID_G(java.lang.String uuid, 293 long groupId) 294 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 295 return getPersistence().removeByUUID_G(uuid, groupId); 296 } 297 298 /** 299 * Returns the number of document library file entry types where uuid = ? and groupId = ?. 300 * 301 * @param uuid the uuid 302 * @param groupId the group ID 303 * @return the number of matching document library file entry types 304 */ 305 public static int countByUUID_G(java.lang.String uuid, long groupId) { 306 return getPersistence().countByUUID_G(uuid, groupId); 307 } 308 309 /** 310 * Returns all the document library file entry types where uuid = ? and companyId = ?. 311 * 312 * @param uuid the uuid 313 * @param companyId the company ID 314 * @return the matching document library file entry types 315 */ 316 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 317 long companyId) { 318 return getPersistence().findByUuid_C(uuid, companyId); 319 } 320 321 /** 322 * Returns a range of all the document library file entry types where uuid = ? and companyId = ?. 323 * 324 * <p> 325 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 326 * </p> 327 * 328 * @param uuid the uuid 329 * @param companyId the company ID 330 * @param start the lower bound of the range of document library file entry types 331 * @param end the upper bound of the range of document library file entry types (not inclusive) 332 * @return the range of matching document library file entry types 333 */ 334 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 335 long companyId, int start, int end) { 336 return getPersistence().findByUuid_C(uuid, companyId, start, end); 337 } 338 339 /** 340 * Returns an ordered range of all the document library file entry types where uuid = ? and companyId = ?. 341 * 342 * <p> 343 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 344 * </p> 345 * 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param start the lower bound of the range of document library file entry types 349 * @param end the upper bound of the range of document library file entry types (not inclusive) 350 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 351 * @return the ordered range of matching document library file entry types 352 */ 353 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 354 long companyId, int start, int end, 355 OrderByComparator<DLFileEntryType> orderByComparator) { 356 return getPersistence() 357 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 358 } 359 360 /** 361 * Returns the first document library file entry type in the ordered set where uuid = ? and companyId = ?. 362 * 363 * @param uuid the uuid 364 * @param companyId the company ID 365 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 366 * @return the first matching document library file entry type 367 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 368 */ 369 public static DLFileEntryType findByUuid_C_First(java.lang.String uuid, 370 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) 371 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 372 return getPersistence() 373 .findByUuid_C_First(uuid, companyId, orderByComparator); 374 } 375 376 /** 377 * Returns the first document library file entry type in the ordered set where uuid = ? and companyId = ?. 378 * 379 * @param uuid the uuid 380 * @param companyId the company ID 381 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 382 * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 383 */ 384 public static DLFileEntryType fetchByUuid_C_First(java.lang.String uuid, 385 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) { 386 return getPersistence() 387 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 388 } 389 390 /** 391 * Returns the last document library file entry type in the ordered set where uuid = ? and companyId = ?. 392 * 393 * @param uuid the uuid 394 * @param companyId the company ID 395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 396 * @return the last matching document library file entry type 397 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 398 */ 399 public static DLFileEntryType findByUuid_C_Last(java.lang.String uuid, 400 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) 401 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 402 return getPersistence() 403 .findByUuid_C_Last(uuid, companyId, orderByComparator); 404 } 405 406 /** 407 * Returns the last document library file entry type in the ordered set where uuid = ? and companyId = ?. 408 * 409 * @param uuid the uuid 410 * @param companyId the company ID 411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 412 * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 413 */ 414 public static DLFileEntryType fetchByUuid_C_Last(java.lang.String uuid, 415 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) { 416 return getPersistence() 417 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 418 } 419 420 /** 421 * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = ? and companyId = ?. 422 * 423 * @param fileEntryTypeId the primary key of the current document library file entry type 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the previous, current, and next document library file entry type 428 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 429 */ 430 public static DLFileEntryType[] findByUuid_C_PrevAndNext( 431 long fileEntryTypeId, java.lang.String uuid, long companyId, 432 OrderByComparator<DLFileEntryType> orderByComparator) 433 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 434 return getPersistence() 435 .findByUuid_C_PrevAndNext(fileEntryTypeId, uuid, companyId, 436 orderByComparator); 437 } 438 439 /** 440 * Removes all the document library file entry types where uuid = ? and companyId = ? from the database. 441 * 442 * @param uuid the uuid 443 * @param companyId the company ID 444 */ 445 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 446 getPersistence().removeByUuid_C(uuid, companyId); 447 } 448 449 /** 450 * Returns the number of document library file entry types where uuid = ? and companyId = ?. 451 * 452 * @param uuid the uuid 453 * @param companyId the company ID 454 * @return the number of matching document library file entry types 455 */ 456 public static int countByUuid_C(java.lang.String uuid, long companyId) { 457 return getPersistence().countByUuid_C(uuid, companyId); 458 } 459 460 /** 461 * Returns all the document library file entry types where groupId = ?. 462 * 463 * @param groupId the group ID 464 * @return the matching document library file entry types 465 */ 466 public static List<DLFileEntryType> findByGroupId(long groupId) { 467 return getPersistence().findByGroupId(groupId); 468 } 469 470 /** 471 * Returns a range of all the document library file entry types where groupId = ?. 472 * 473 * <p> 474 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 475 * </p> 476 * 477 * @param groupId the group ID 478 * @param start the lower bound of the range of document library file entry types 479 * @param end the upper bound of the range of document library file entry types (not inclusive) 480 * @return the range of matching document library file entry types 481 */ 482 public static List<DLFileEntryType> findByGroupId(long groupId, int start, 483 int end) { 484 return getPersistence().findByGroupId(groupId, start, end); 485 } 486 487 /** 488 * Returns an ordered range of all the document library file entry types where groupId = ?. 489 * 490 * <p> 491 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 492 * </p> 493 * 494 * @param groupId the group ID 495 * @param start the lower bound of the range of document library file entry types 496 * @param end the upper bound of the range of document library file entry types (not inclusive) 497 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 498 * @return the ordered range of matching document library file entry types 499 */ 500 public static List<DLFileEntryType> findByGroupId(long groupId, int start, 501 int end, OrderByComparator<DLFileEntryType> orderByComparator) { 502 return getPersistence() 503 .findByGroupId(groupId, start, end, orderByComparator); 504 } 505 506 /** 507 * Returns the first document library file entry type in the ordered set where groupId = ?. 508 * 509 * @param groupId the group ID 510 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 511 * @return the first matching document library file entry type 512 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 513 */ 514 public static DLFileEntryType findByGroupId_First(long groupId, 515 OrderByComparator<DLFileEntryType> orderByComparator) 516 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 517 return getPersistence().findByGroupId_First(groupId, orderByComparator); 518 } 519 520 /** 521 * Returns the first document library file entry type in the ordered set where groupId = ?. 522 * 523 * @param groupId the group ID 524 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 525 * @return the first matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 526 */ 527 public static DLFileEntryType fetchByGroupId_First(long groupId, 528 OrderByComparator<DLFileEntryType> orderByComparator) { 529 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 530 } 531 532 /** 533 * Returns the last document library file entry type in the ordered set where groupId = ?. 534 * 535 * @param groupId the group ID 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the last matching document library file entry type 538 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 539 */ 540 public static DLFileEntryType findByGroupId_Last(long groupId, 541 OrderByComparator<DLFileEntryType> orderByComparator) 542 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 543 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 544 } 545 546 /** 547 * Returns the last document library file entry type in the ordered set where groupId = ?. 548 * 549 * @param groupId the group ID 550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 551 * @return the last matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 552 */ 553 public static DLFileEntryType fetchByGroupId_Last(long groupId, 554 OrderByComparator<DLFileEntryType> orderByComparator) { 555 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 556 } 557 558 /** 559 * Returns the document library file entry types before and after the current document library file entry type in the ordered set where groupId = ?. 560 * 561 * @param fileEntryTypeId the primary key of the current document library file entry type 562 * @param groupId the group ID 563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 564 * @return the previous, current, and next document library file entry type 565 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 566 */ 567 public static DLFileEntryType[] findByGroupId_PrevAndNext( 568 long fileEntryTypeId, long groupId, 569 OrderByComparator<DLFileEntryType> orderByComparator) 570 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 571 return getPersistence() 572 .findByGroupId_PrevAndNext(fileEntryTypeId, groupId, 573 orderByComparator); 574 } 575 576 /** 577 * Returns all the document library file entry types that the user has permission to view where groupId = ?. 578 * 579 * @param groupId the group ID 580 * @return the matching document library file entry types that the user has permission to view 581 */ 582 public static List<DLFileEntryType> filterFindByGroupId(long groupId) { 583 return getPersistence().filterFindByGroupId(groupId); 584 } 585 586 /** 587 * Returns a range of all the document library file entry types that the user has permission to view where groupId = ?. 588 * 589 * <p> 590 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 591 * </p> 592 * 593 * @param groupId the group ID 594 * @param start the lower bound of the range of document library file entry types 595 * @param end the upper bound of the range of document library file entry types (not inclusive) 596 * @return the range of matching document library file entry types that the user has permission to view 597 */ 598 public static List<DLFileEntryType> filterFindByGroupId(long groupId, 599 int start, int end) { 600 return getPersistence().filterFindByGroupId(groupId, start, end); 601 } 602 603 /** 604 * Returns an ordered range of all the document library file entry types that the user has permissions to view where groupId = ?. 605 * 606 * <p> 607 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 608 * </p> 609 * 610 * @param groupId the group ID 611 * @param start the lower bound of the range of document library file entry types 612 * @param end the upper bound of the range of document library file entry types (not inclusive) 613 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 614 * @return the ordered range of matching document library file entry types that the user has permission to view 615 */ 616 public static List<DLFileEntryType> filterFindByGroupId(long groupId, 617 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 618 return getPersistence() 619 .filterFindByGroupId(groupId, start, end, orderByComparator); 620 } 621 622 /** 623 * Returns the document library file entry types before and after the current document library file entry type in the ordered set of document library file entry types that the user has permission to view where groupId = ?. 624 * 625 * @param fileEntryTypeId the primary key of the current document library file entry type 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the previous, current, and next document library file entry type 629 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 630 */ 631 public static DLFileEntryType[] filterFindByGroupId_PrevAndNext( 632 long fileEntryTypeId, long groupId, 633 OrderByComparator<DLFileEntryType> orderByComparator) 634 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 635 return getPersistence() 636 .filterFindByGroupId_PrevAndNext(fileEntryTypeId, groupId, 637 orderByComparator); 638 } 639 640 /** 641 * Returns all the document library file entry types that the user has permission to view where groupId = any ?. 642 * 643 * @param groupIds the group IDs 644 * @return the matching document library file entry types that the user has permission to view 645 */ 646 public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds) { 647 return getPersistence().filterFindByGroupId(groupIds); 648 } 649 650 /** 651 * Returns a range of all the document library file entry types that the user has permission to view where groupId = any ?. 652 * 653 * <p> 654 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 655 * </p> 656 * 657 * @param groupIds the group IDs 658 * @param start the lower bound of the range of document library file entry types 659 * @param end the upper bound of the range of document library file entry types (not inclusive) 660 * @return the range of matching document library file entry types that the user has permission to view 661 */ 662 public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds, 663 int start, int end) { 664 return getPersistence().filterFindByGroupId(groupIds, start, end); 665 } 666 667 /** 668 * Returns an ordered range of all the document library file entry types that the user has permission to view where groupId = any ?. 669 * 670 * <p> 671 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 672 * </p> 673 * 674 * @param groupIds the group IDs 675 * @param start the lower bound of the range of document library file entry types 676 * @param end the upper bound of the range of document library file entry types (not inclusive) 677 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 678 * @return the ordered range of matching document library file entry types that the user has permission to view 679 */ 680 public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds, 681 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 682 return getPersistence() 683 .filterFindByGroupId(groupIds, start, end, orderByComparator); 684 } 685 686 /** 687 * Returns all the document library file entry types where groupId = any ?. 688 * 689 * <p> 690 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 691 * </p> 692 * 693 * @param groupIds the group IDs 694 * @return the matching document library file entry types 695 */ 696 public static List<DLFileEntryType> findByGroupId(long[] groupIds) { 697 return getPersistence().findByGroupId(groupIds); 698 } 699 700 /** 701 * Returns a range of all the document library file entry types where groupId = any ?. 702 * 703 * <p> 704 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 705 * </p> 706 * 707 * @param groupIds the group IDs 708 * @param start the lower bound of the range of document library file entry types 709 * @param end the upper bound of the range of document library file entry types (not inclusive) 710 * @return the range of matching document library file entry types 711 */ 712 public static List<DLFileEntryType> findByGroupId(long[] groupIds, 713 int start, int end) { 714 return getPersistence().findByGroupId(groupIds, start, end); 715 } 716 717 /** 718 * Returns an ordered range of all the document library file entry types where groupId = any ?. 719 * 720 * <p> 721 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 722 * </p> 723 * 724 * @param groupIds the group IDs 725 * @param start the lower bound of the range of document library file entry types 726 * @param end the upper bound of the range of document library file entry types (not inclusive) 727 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 728 * @return the ordered range of matching document library file entry types 729 */ 730 public static List<DLFileEntryType> findByGroupId(long[] groupIds, 731 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 732 return getPersistence() 733 .findByGroupId(groupIds, start, end, orderByComparator); 734 } 735 736 /** 737 * Removes all the document library file entry types where groupId = ? from the database. 738 * 739 * @param groupId the group ID 740 */ 741 public static void removeByGroupId(long groupId) { 742 getPersistence().removeByGroupId(groupId); 743 } 744 745 /** 746 * Returns the number of document library file entry types where groupId = ?. 747 * 748 * @param groupId the group ID 749 * @return the number of matching document library file entry types 750 */ 751 public static int countByGroupId(long groupId) { 752 return getPersistence().countByGroupId(groupId); 753 } 754 755 /** 756 * Returns the number of document library file entry types where groupId = any ?. 757 * 758 * @param groupIds the group IDs 759 * @return the number of matching document library file entry types 760 */ 761 public static int countByGroupId(long[] groupIds) { 762 return getPersistence().countByGroupId(groupIds); 763 } 764 765 /** 766 * Returns the number of document library file entry types that the user has permission to view where groupId = ?. 767 * 768 * @param groupId the group ID 769 * @return the number of matching document library file entry types that the user has permission to view 770 */ 771 public static int filterCountByGroupId(long groupId) { 772 return getPersistence().filterCountByGroupId(groupId); 773 } 774 775 /** 776 * Returns the number of document library file entry types that the user has permission to view where groupId = any ?. 777 * 778 * @param groupIds the group IDs 779 * @return the number of matching document library file entry types that the user has permission to view 780 */ 781 public static int filterCountByGroupId(long[] groupIds) { 782 return getPersistence().filterCountByGroupId(groupIds); 783 } 784 785 /** 786 * Returns the document library file entry type where groupId = ? and fileEntryTypeKey = ? or throws a {@link NoSuchFileEntryTypeException} if it could not be found. 787 * 788 * @param groupId the group ID 789 * @param fileEntryTypeKey the file entry type key 790 * @return the matching document library file entry type 791 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 792 */ 793 public static DLFileEntryType findByG_F(long groupId, 794 java.lang.String fileEntryTypeKey) 795 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 796 return getPersistence().findByG_F(groupId, fileEntryTypeKey); 797 } 798 799 /** 800 * Returns the document library file entry type where groupId = ? and fileEntryTypeKey = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 801 * 802 * @param groupId the group ID 803 * @param fileEntryTypeKey the file entry type key 804 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 805 */ 806 public static DLFileEntryType fetchByG_F(long groupId, 807 java.lang.String fileEntryTypeKey) { 808 return getPersistence().fetchByG_F(groupId, fileEntryTypeKey); 809 } 810 811 /** 812 * Returns the document library file entry type where groupId = ? and fileEntryTypeKey = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 813 * 814 * @param groupId the group ID 815 * @param fileEntryTypeKey the file entry type key 816 * @param retrieveFromCache whether to use the finder cache 817 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 818 */ 819 public static DLFileEntryType fetchByG_F(long groupId, 820 java.lang.String fileEntryTypeKey, boolean retrieveFromCache) { 821 return getPersistence() 822 .fetchByG_F(groupId, fileEntryTypeKey, retrieveFromCache); 823 } 824 825 /** 826 * Removes the document library file entry type where groupId = ? and fileEntryTypeKey = ? from the database. 827 * 828 * @param groupId the group ID 829 * @param fileEntryTypeKey the file entry type key 830 * @return the document library file entry type that was removed 831 */ 832 public static DLFileEntryType removeByG_F(long groupId, 833 java.lang.String fileEntryTypeKey) 834 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 835 return getPersistence().removeByG_F(groupId, fileEntryTypeKey); 836 } 837 838 /** 839 * Returns the number of document library file entry types where groupId = ? and fileEntryTypeKey = ?. 840 * 841 * @param groupId the group ID 842 * @param fileEntryTypeKey the file entry type key 843 * @return the number of matching document library file entry types 844 */ 845 public static int countByG_F(long groupId, java.lang.String fileEntryTypeKey) { 846 return getPersistence().countByG_F(groupId, fileEntryTypeKey); 847 } 848 849 /** 850 * Caches the document library file entry type in the entity cache if it is enabled. 851 * 852 * @param dlFileEntryType the document library file entry type 853 */ 854 public static void cacheResult(DLFileEntryType dlFileEntryType) { 855 getPersistence().cacheResult(dlFileEntryType); 856 } 857 858 /** 859 * Caches the document library file entry types in the entity cache if it is enabled. 860 * 861 * @param dlFileEntryTypes the document library file entry types 862 */ 863 public static void cacheResult(List<DLFileEntryType> dlFileEntryTypes) { 864 getPersistence().cacheResult(dlFileEntryTypes); 865 } 866 867 /** 868 * Creates a new document library file entry type with the primary key. Does not add the document library file entry type to the database. 869 * 870 * @param fileEntryTypeId the primary key for the new document library file entry type 871 * @return the new document library file entry type 872 */ 873 public static DLFileEntryType create(long fileEntryTypeId) { 874 return getPersistence().create(fileEntryTypeId); 875 } 876 877 /** 878 * Removes the document library file entry type with the primary key from the database. Also notifies the appropriate model listeners. 879 * 880 * @param fileEntryTypeId the primary key of the document library file entry type 881 * @return the document library file entry type that was removed 882 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 883 */ 884 public static DLFileEntryType remove(long fileEntryTypeId) 885 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 886 return getPersistence().remove(fileEntryTypeId); 887 } 888 889 public static DLFileEntryType updateImpl(DLFileEntryType dlFileEntryType) { 890 return getPersistence().updateImpl(dlFileEntryType); 891 } 892 893 /** 894 * Returns the document library file entry type with the primary key or throws a {@link NoSuchFileEntryTypeException} if it could not be found. 895 * 896 * @param fileEntryTypeId the primary key of the document library file entry type 897 * @return the document library file entry type 898 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 899 */ 900 public static DLFileEntryType findByPrimaryKey(long fileEntryTypeId) 901 throws com.liferay.portlet.documentlibrary.NoSuchFileEntryTypeException { 902 return getPersistence().findByPrimaryKey(fileEntryTypeId); 903 } 904 905 /** 906 * Returns the document library file entry type with the primary key or returns <code>null</code> if it could not be found. 907 * 908 * @param fileEntryTypeId the primary key of the document library file entry type 909 * @return the document library file entry type, or <code>null</code> if a document library file entry type with the primary key could not be found 910 */ 911 public static DLFileEntryType fetchByPrimaryKey(long fileEntryTypeId) { 912 return getPersistence().fetchByPrimaryKey(fileEntryTypeId); 913 } 914 915 public static java.util.Map<java.io.Serializable, DLFileEntryType> fetchByPrimaryKeys( 916 java.util.Set<java.io.Serializable> primaryKeys) { 917 return getPersistence().fetchByPrimaryKeys(primaryKeys); 918 } 919 920 /** 921 * Returns all the document library file entry types. 922 * 923 * @return the document library file entry types 924 */ 925 public static List<DLFileEntryType> findAll() { 926 return getPersistence().findAll(); 927 } 928 929 /** 930 * Returns a range of all the document library file entry types. 931 * 932 * <p> 933 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 934 * </p> 935 * 936 * @param start the lower bound of the range of document library file entry types 937 * @param end the upper bound of the range of document library file entry types (not inclusive) 938 * @return the range of document library file entry types 939 */ 940 public static List<DLFileEntryType> findAll(int start, int end) { 941 return getPersistence().findAll(start, end); 942 } 943 944 /** 945 * Returns an ordered range of all the document library file entry types. 946 * 947 * <p> 948 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 949 * </p> 950 * 951 * @param start the lower bound of the range of document library file entry types 952 * @param end the upper bound of the range of document library file entry types (not inclusive) 953 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 954 * @return the ordered range of document library file entry types 955 */ 956 public static List<DLFileEntryType> findAll(int start, int end, 957 OrderByComparator<DLFileEntryType> orderByComparator) { 958 return getPersistence().findAll(start, end, orderByComparator); 959 } 960 961 /** 962 * Removes all the document library file entry types from the database. 963 */ 964 public static void removeAll() { 965 getPersistence().removeAll(); 966 } 967 968 /** 969 * Returns the number of document library file entry types. 970 * 971 * @return the number of document library file entry types 972 */ 973 public static int countAll() { 974 return getPersistence().countAll(); 975 } 976 977 /** 978 * Returns the primaryKeys of document library folders associated with the document library file entry type. 979 * 980 * @param pk the primary key of the document library file entry type 981 * @return long[] of the primaryKeys of document library folders associated with the document library file entry type 982 */ 983 public static long[] getDLFolderPrimaryKeys(long pk) { 984 return getPersistence().getDLFolderPrimaryKeys(pk); 985 } 986 987 /** 988 * Returns all the document library folders associated with the document library file entry type. 989 * 990 * @param pk the primary key of the document library file entry type 991 * @return the document library folders associated with the document library file entry type 992 */ 993 public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders( 994 long pk) { 995 return getPersistence().getDLFolders(pk); 996 } 997 998 /** 999 * Returns a range of all the document library folders associated with the document library file entry type. 1000 * 1001 * <p> 1002 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1003 * </p> 1004 * 1005 * @param pk the primary key of the document library file entry type 1006 * @param start the lower bound of the range of document library file entry types 1007 * @param end the upper bound of the range of document library file entry types (not inclusive) 1008 * @return the range of document library folders associated with the document library file entry type 1009 */ 1010 public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders( 1011 long pk, int start, int end) { 1012 return getPersistence().getDLFolders(pk, start, end); 1013 } 1014 1015 /** 1016 * Returns an ordered range of all the document library folders associated with the document library file entry type. 1017 * 1018 * <p> 1019 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1020 * </p> 1021 * 1022 * @param pk the primary key of the document library file entry type 1023 * @param start the lower bound of the range of document library file entry types 1024 * @param end the upper bound of the range of document library file entry types (not inclusive) 1025 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1026 * @return the ordered range of document library folders associated with the document library file entry type 1027 */ 1028 public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders( 1029 long pk, int start, int end, 1030 OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFolder> orderByComparator) { 1031 return getPersistence().getDLFolders(pk, start, end, orderByComparator); 1032 } 1033 1034 /** 1035 * Returns the number of document library folders associated with the document library file entry type. 1036 * 1037 * @param pk the primary key of the document library file entry type 1038 * @return the number of document library folders associated with the document library file entry type 1039 */ 1040 public static int getDLFoldersSize(long pk) { 1041 return getPersistence().getDLFoldersSize(pk); 1042 } 1043 1044 /** 1045 * Returns <code>true</code> if the document library folder is associated with the document library file entry type. 1046 * 1047 * @param pk the primary key of the document library file entry type 1048 * @param dlFolderPK the primary key of the document library folder 1049 * @return <code>true</code> if the document library folder is associated with the document library file entry type; <code>false</code> otherwise 1050 */ 1051 public static boolean containsDLFolder(long pk, long dlFolderPK) { 1052 return getPersistence().containsDLFolder(pk, dlFolderPK); 1053 } 1054 1055 /** 1056 * Returns <code>true</code> if the document library file entry type has any document library folders associated with it. 1057 * 1058 * @param pk the primary key of the document library file entry type to check for associations with document library folders 1059 * @return <code>true</code> if the document library file entry type has any document library folders associated with it; <code>false</code> otherwise 1060 */ 1061 public static boolean containsDLFolders(long pk) { 1062 return getPersistence().containsDLFolders(pk); 1063 } 1064 1065 /** 1066 * Adds an association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1067 * 1068 * @param pk the primary key of the document library file entry type 1069 * @param dlFolderPK the primary key of the document library folder 1070 */ 1071 public static void addDLFolder(long pk, long dlFolderPK) { 1072 getPersistence().addDLFolder(pk, dlFolderPK); 1073 } 1074 1075 /** 1076 * Adds an association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1077 * 1078 * @param pk the primary key of the document library file entry type 1079 * @param dlFolder the document library folder 1080 */ 1081 public static void addDLFolder(long pk, 1082 com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) { 1083 getPersistence().addDLFolder(pk, dlFolder); 1084 } 1085 1086 /** 1087 * Adds an association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1088 * 1089 * @param pk the primary key of the document library file entry type 1090 * @param dlFolderPKs the primary keys of the document library folders 1091 */ 1092 public static void addDLFolders(long pk, long[] dlFolderPKs) { 1093 getPersistence().addDLFolders(pk, dlFolderPKs); 1094 } 1095 1096 /** 1097 * Adds an association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1098 * 1099 * @param pk the primary key of the document library file entry type 1100 * @param dlFolders the document library folders 1101 */ 1102 public static void addDLFolders(long pk, 1103 List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) { 1104 getPersistence().addDLFolders(pk, dlFolders); 1105 } 1106 1107 /** 1108 * Clears all associations between the document library file entry type and its document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1109 * 1110 * @param pk the primary key of the document library file entry type to clear the associated document library folders from 1111 */ 1112 public static void clearDLFolders(long pk) { 1113 getPersistence().clearDLFolders(pk); 1114 } 1115 1116 /** 1117 * Removes the association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1118 * 1119 * @param pk the primary key of the document library file entry type 1120 * @param dlFolderPK the primary key of the document library folder 1121 */ 1122 public static void removeDLFolder(long pk, long dlFolderPK) { 1123 getPersistence().removeDLFolder(pk, dlFolderPK); 1124 } 1125 1126 /** 1127 * Removes the association between the document library file entry type and the document library folder. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1128 * 1129 * @param pk the primary key of the document library file entry type 1130 * @param dlFolder the document library folder 1131 */ 1132 public static void removeDLFolder(long pk, 1133 com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) { 1134 getPersistence().removeDLFolder(pk, dlFolder); 1135 } 1136 1137 /** 1138 * Removes the association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1139 * 1140 * @param pk the primary key of the document library file entry type 1141 * @param dlFolderPKs the primary keys of the document library folders 1142 */ 1143 public static void removeDLFolders(long pk, long[] dlFolderPKs) { 1144 getPersistence().removeDLFolders(pk, dlFolderPKs); 1145 } 1146 1147 /** 1148 * Removes the association between the document library file entry type and the document library folders. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1149 * 1150 * @param pk the primary key of the document library file entry type 1151 * @param dlFolders the document library folders 1152 */ 1153 public static void removeDLFolders(long pk, 1154 List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) { 1155 getPersistence().removeDLFolders(pk, dlFolders); 1156 } 1157 1158 /** 1159 * Sets the document library folders associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1160 * 1161 * @param pk the primary key of the document library file entry type 1162 * @param dlFolderPKs the primary keys of the document library folders to be associated with the document library file entry type 1163 */ 1164 public static void setDLFolders(long pk, long[] dlFolderPKs) { 1165 getPersistence().setDLFolders(pk, dlFolderPKs); 1166 } 1167 1168 /** 1169 * Sets the document library folders associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1170 * 1171 * @param pk the primary key of the document library file entry type 1172 * @param dlFolders the document library folders to be associated with the document library file entry type 1173 */ 1174 public static void setDLFolders(long pk, 1175 List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) { 1176 getPersistence().setDLFolders(pk, dlFolders); 1177 } 1178 1179 /** 1180 * Returns the primaryKeys of d d m structures associated with the document library file entry type. 1181 * 1182 * @param pk the primary key of the document library file entry type 1183 * @return long[] of the primaryKeys of d d m structures associated with the document library file entry type 1184 */ 1185 public static long[] getDDMStructurePrimaryKeys(long pk) { 1186 return getPersistence().getDDMStructurePrimaryKeys(pk); 1187 } 1188 1189 /** 1190 * Returns all the d d m structures associated with the document library file entry type. 1191 * 1192 * @param pk the primary key of the document library file entry type 1193 * @return the d d m structures associated with the document library file entry type 1194 */ 1195 public static List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures( 1196 long pk) { 1197 return getPersistence().getDDMStructures(pk); 1198 } 1199 1200 /** 1201 * Returns a range of all the d d m structures associated with the document library file entry type. 1202 * 1203 * <p> 1204 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1205 * </p> 1206 * 1207 * @param pk the primary key of the document library file entry type 1208 * @param start the lower bound of the range of document library file entry types 1209 * @param end the upper bound of the range of document library file entry types (not inclusive) 1210 * @return the range of d d m structures associated with the document library file entry type 1211 */ 1212 public static List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures( 1213 long pk, int start, int end) { 1214 return getPersistence().getDDMStructures(pk, start, end); 1215 } 1216 1217 /** 1218 * Returns an ordered range of all the d d m structures associated with the document library file entry type. 1219 * 1220 * <p> 1221 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link DLFileEntryTypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1222 * </p> 1223 * 1224 * @param pk the primary key of the document library file entry type 1225 * @param start the lower bound of the range of document library file entry types 1226 * @param end the upper bound of the range of document library file entry types (not inclusive) 1227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1228 * @return the ordered range of d d m structures associated with the document library file entry type 1229 */ 1230 public static List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures( 1231 long pk, int start, int end, 1232 OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) { 1233 return getPersistence() 1234 .getDDMStructures(pk, start, end, orderByComparator); 1235 } 1236 1237 /** 1238 * Returns the number of d d m structures associated with the document library file entry type. 1239 * 1240 * @param pk the primary key of the document library file entry type 1241 * @return the number of d d m structures associated with the document library file entry type 1242 */ 1243 public static int getDDMStructuresSize(long pk) { 1244 return getPersistence().getDDMStructuresSize(pk); 1245 } 1246 1247 /** 1248 * Returns <code>true</code> if the d d m structure is associated with the document library file entry type. 1249 * 1250 * @param pk the primary key of the document library file entry type 1251 * @param ddmStructurePK the primary key of the d d m structure 1252 * @return <code>true</code> if the d d m structure is associated with the document library file entry type; <code>false</code> otherwise 1253 */ 1254 public static boolean containsDDMStructure(long pk, long ddmStructurePK) { 1255 return getPersistence().containsDDMStructure(pk, ddmStructurePK); 1256 } 1257 1258 /** 1259 * Returns <code>true</code> if the document library file entry type has any d d m structures associated with it. 1260 * 1261 * @param pk the primary key of the document library file entry type to check for associations with d d m structures 1262 * @return <code>true</code> if the document library file entry type has any d d m structures associated with it; <code>false</code> otherwise 1263 */ 1264 public static boolean containsDDMStructures(long pk) { 1265 return getPersistence().containsDDMStructures(pk); 1266 } 1267 1268 /** 1269 * Adds an association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1270 * 1271 * @param pk the primary key of the document library file entry type 1272 * @param ddmStructurePK the primary key of the d d m structure 1273 */ 1274 public static void addDDMStructure(long pk, long ddmStructurePK) { 1275 getPersistence().addDDMStructure(pk, ddmStructurePK); 1276 } 1277 1278 /** 1279 * Adds an association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1280 * 1281 * @param pk the primary key of the document library file entry type 1282 * @param ddmStructure the d d m structure 1283 */ 1284 public static void addDDMStructure(long pk, 1285 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 1286 getPersistence().addDDMStructure(pk, ddmStructure); 1287 } 1288 1289 /** 1290 * Adds an association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1291 * 1292 * @param pk the primary key of the document library file entry type 1293 * @param ddmStructurePKs the primary keys of the d d m structures 1294 */ 1295 public static void addDDMStructures(long pk, long[] ddmStructurePKs) { 1296 getPersistence().addDDMStructures(pk, ddmStructurePKs); 1297 } 1298 1299 /** 1300 * Adds an association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1301 * 1302 * @param pk the primary key of the document library file entry type 1303 * @param ddmStructures the d d m structures 1304 */ 1305 public static void addDDMStructures(long pk, 1306 List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) { 1307 getPersistence().addDDMStructures(pk, ddmStructures); 1308 } 1309 1310 /** 1311 * Clears all associations between the document library file entry type and its d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1312 * 1313 * @param pk the primary key of the document library file entry type to clear the associated d d m structures from 1314 */ 1315 public static void clearDDMStructures(long pk) { 1316 getPersistence().clearDDMStructures(pk); 1317 } 1318 1319 /** 1320 * Removes the association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1321 * 1322 * @param pk the primary key of the document library file entry type 1323 * @param ddmStructurePK the primary key of the d d m structure 1324 */ 1325 public static void removeDDMStructure(long pk, long ddmStructurePK) { 1326 getPersistence().removeDDMStructure(pk, ddmStructurePK); 1327 } 1328 1329 /** 1330 * Removes the association between the document library file entry type and the d d m structure. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1331 * 1332 * @param pk the primary key of the document library file entry type 1333 * @param ddmStructure the d d m structure 1334 */ 1335 public static void removeDDMStructure(long pk, 1336 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 1337 getPersistence().removeDDMStructure(pk, ddmStructure); 1338 } 1339 1340 /** 1341 * Removes the association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1342 * 1343 * @param pk the primary key of the document library file entry type 1344 * @param ddmStructurePKs the primary keys of the d d m structures 1345 */ 1346 public static void removeDDMStructures(long pk, long[] ddmStructurePKs) { 1347 getPersistence().removeDDMStructures(pk, ddmStructurePKs); 1348 } 1349 1350 /** 1351 * Removes the association between the document library file entry type and the d d m structures. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1352 * 1353 * @param pk the primary key of the document library file entry type 1354 * @param ddmStructures the d d m structures 1355 */ 1356 public static void removeDDMStructures(long pk, 1357 List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) { 1358 getPersistence().removeDDMStructures(pk, ddmStructures); 1359 } 1360 1361 /** 1362 * Sets the d d m structures associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1363 * 1364 * @param pk the primary key of the document library file entry type 1365 * @param ddmStructurePKs the primary keys of the d d m structures to be associated with the document library file entry type 1366 */ 1367 public static void setDDMStructures(long pk, long[] ddmStructurePKs) { 1368 getPersistence().setDDMStructures(pk, ddmStructurePKs); 1369 } 1370 1371 /** 1372 * Sets the d d m structures associated with the document library file entry type, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1373 * 1374 * @param pk the primary key of the document library file entry type 1375 * @param ddmStructures the d d m structures to be associated with the document library file entry type 1376 */ 1377 public static void setDDMStructures(long pk, 1378 List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) { 1379 getPersistence().setDDMStructures(pk, ddmStructures); 1380 } 1381 1382 public static DLFileEntryTypePersistence getPersistence() { 1383 if (_persistence == null) { 1384 _persistence = (DLFileEntryTypePersistence)PortalBeanLocatorUtil.locate(DLFileEntryTypePersistence.class.getName()); 1385 1386 ReferenceRegistry.registerReference(DLFileEntryTypeUtil.class, 1387 "_persistence"); 1388 } 1389 1390 return _persistence; 1391 } 1392 1393 /** 1394 * @deprecated As of 6.2.0 1395 */ 1396 @Deprecated 1397 public void setPersistence(DLFileEntryTypePersistence persistence) { 1398 } 1399 1400 private static DLFileEntryTypePersistence _persistence; 1401 }