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 an ordered range of all the document library file entry types where uuid = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of document library file entry types 166 * @param end the upper bound of the range of document library file entry types (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching document library file entry types 170 */ 171 public static List<DLFileEntryType> findByUuid(java.lang.String uuid, 172 int start, int end, 173 OrderByComparator<DLFileEntryType> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByUuid(uuid, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first document library file entry type in the ordered set where uuid = ?. 182 * 183 * @param uuid the uuid 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the first matching document library file entry type 186 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 187 */ 188 public static DLFileEntryType findByUuid_First(java.lang.String uuid, 189 OrderByComparator<DLFileEntryType> orderByComparator) 190 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 191 return getPersistence().findByUuid_First(uuid, orderByComparator); 192 } 193 194 /** 195 * Returns the first document library file entry type in the ordered set where uuid = ?. 196 * 197 * @param uuid the uuid 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @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 200 */ 201 public static DLFileEntryType fetchByUuid_First(java.lang.String uuid, 202 OrderByComparator<DLFileEntryType> orderByComparator) { 203 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 204 } 205 206 /** 207 * Returns the last document library file entry type in the ordered set where uuid = ?. 208 * 209 * @param uuid the uuid 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the last matching document library file entry type 212 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 213 */ 214 public static DLFileEntryType findByUuid_Last(java.lang.String uuid, 215 OrderByComparator<DLFileEntryType> orderByComparator) 216 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 217 return getPersistence().findByUuid_Last(uuid, orderByComparator); 218 } 219 220 /** 221 * Returns the last document library file entry type in the ordered set where uuid = ?. 222 * 223 * @param uuid the uuid 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @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 226 */ 227 public static DLFileEntryType fetchByUuid_Last(java.lang.String uuid, 228 OrderByComparator<DLFileEntryType> orderByComparator) { 229 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 230 } 231 232 /** 233 * Returns the document library file entry types before and after the current document library file entry type in the ordered set where uuid = ?. 234 * 235 * @param fileEntryTypeId the primary key of the current document library file entry type 236 * @param uuid the uuid 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the previous, current, and next document library file entry type 239 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 240 */ 241 public static DLFileEntryType[] findByUuid_PrevAndNext( 242 long fileEntryTypeId, java.lang.String uuid, 243 OrderByComparator<DLFileEntryType> orderByComparator) 244 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(fileEntryTypeId, uuid, 247 orderByComparator); 248 } 249 250 /** 251 * Removes all the document library file entry types where uuid = ? from the database. 252 * 253 * @param uuid the uuid 254 */ 255 public static void removeByUuid(java.lang.String uuid) { 256 getPersistence().removeByUuid(uuid); 257 } 258 259 /** 260 * Returns the number of document library file entry types where uuid = ?. 261 * 262 * @param uuid the uuid 263 * @return the number of matching document library file entry types 264 */ 265 public static int countByUuid(java.lang.String uuid) { 266 return getPersistence().countByUuid(uuid); 267 } 268 269 /** 270 * Returns the document library file entry type where uuid = ? and groupId = ? or throws a {@link NoSuchFileEntryTypeException} if it could not be found. 271 * 272 * @param uuid the uuid 273 * @param groupId the group ID 274 * @return the matching document library file entry type 275 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 276 */ 277 public static DLFileEntryType findByUUID_G(java.lang.String uuid, 278 long groupId) 279 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 280 return getPersistence().findByUUID_G(uuid, groupId); 281 } 282 283 /** 284 * 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. 285 * 286 * @param uuid the uuid 287 * @param groupId the group ID 288 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 289 */ 290 public static DLFileEntryType fetchByUUID_G(java.lang.String uuid, 291 long groupId) { 292 return getPersistence().fetchByUUID_G(uuid, groupId); 293 } 294 295 /** 296 * 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. 297 * 298 * @param uuid the uuid 299 * @param groupId the group ID 300 * @param retrieveFromCache whether to retrieve from the finder cache 301 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 302 */ 303 public static DLFileEntryType fetchByUUID_G(java.lang.String uuid, 304 long groupId, boolean retrieveFromCache) { 305 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 306 } 307 308 /** 309 * Removes the document library file entry type where uuid = ? and groupId = ? from the database. 310 * 311 * @param uuid the uuid 312 * @param groupId the group ID 313 * @return the document library file entry type that was removed 314 */ 315 public static DLFileEntryType removeByUUID_G(java.lang.String uuid, 316 long groupId) 317 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 318 return getPersistence().removeByUUID_G(uuid, groupId); 319 } 320 321 /** 322 * Returns the number of document library file entry types where uuid = ? and groupId = ?. 323 * 324 * @param uuid the uuid 325 * @param groupId the group ID 326 * @return the number of matching document library file entry types 327 */ 328 public static int countByUUID_G(java.lang.String uuid, long groupId) { 329 return getPersistence().countByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns all the document library file entry types where uuid = ? and companyId = ?. 334 * 335 * @param uuid the uuid 336 * @param companyId the company ID 337 * @return the matching document library file entry types 338 */ 339 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 340 long companyId) { 341 return getPersistence().findByUuid_C(uuid, companyId); 342 } 343 344 /** 345 * Returns a range of all the document library file entry types where uuid = ? and companyId = ?. 346 * 347 * <p> 348 * 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. 349 * </p> 350 * 351 * @param uuid the uuid 352 * @param companyId the company ID 353 * @param start the lower bound of the range of document library file entry types 354 * @param end the upper bound of the range of document library file entry types (not inclusive) 355 * @return the range of matching document library file entry types 356 */ 357 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 358 long companyId, int start, int end) { 359 return getPersistence().findByUuid_C(uuid, companyId, start, end); 360 } 361 362 /** 363 * Returns an ordered range of all the document library file entry types where uuid = ? and companyId = ?. 364 * 365 * <p> 366 * 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. 367 * </p> 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param start the lower bound of the range of document library file entry types 372 * @param end the upper bound of the range of document library file entry types (not inclusive) 373 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 374 * @return the ordered range of matching document library file entry types 375 */ 376 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 377 long companyId, int start, int end, 378 OrderByComparator<DLFileEntryType> orderByComparator) { 379 return getPersistence() 380 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 381 } 382 383 /** 384 * Returns an ordered range of all the document library file entry types where uuid = ? and companyId = ?. 385 * 386 * <p> 387 * 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. 388 * </p> 389 * 390 * @param uuid the uuid 391 * @param companyId the company ID 392 * @param start the lower bound of the range of document library file entry types 393 * @param end the upper bound of the range of document library file entry types (not inclusive) 394 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 395 * @param retrieveFromCache whether to retrieve from the finder cache 396 * @return the ordered range of matching document library file entry types 397 */ 398 public static List<DLFileEntryType> findByUuid_C(java.lang.String uuid, 399 long companyId, int start, int end, 400 OrderByComparator<DLFileEntryType> orderByComparator, 401 boolean retrieveFromCache) { 402 return getPersistence() 403 .findByUuid_C(uuid, companyId, start, end, 404 orderByComparator, retrieveFromCache); 405 } 406 407 /** 408 * Returns the first document library file entry type in the ordered set where uuid = ? and companyId = ?. 409 * 410 * @param uuid the uuid 411 * @param companyId the company ID 412 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 413 * @return the first matching document library file entry type 414 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 415 */ 416 public static DLFileEntryType findByUuid_C_First(java.lang.String uuid, 417 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) 418 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 419 return getPersistence() 420 .findByUuid_C_First(uuid, companyId, orderByComparator); 421 } 422 423 /** 424 * Returns the first document library file entry type in the ordered set where uuid = ? and companyId = ?. 425 * 426 * @param uuid the uuid 427 * @param companyId the company ID 428 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 429 * @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 430 */ 431 public static DLFileEntryType fetchByUuid_C_First(java.lang.String uuid, 432 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) { 433 return getPersistence() 434 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 435 } 436 437 /** 438 * Returns the last document library file entry type in the ordered set where uuid = ? and companyId = ?. 439 * 440 * @param uuid the uuid 441 * @param companyId the company ID 442 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 443 * @return the last matching document library file entry type 444 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 445 */ 446 public static DLFileEntryType findByUuid_C_Last(java.lang.String uuid, 447 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) 448 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 449 return getPersistence() 450 .findByUuid_C_Last(uuid, companyId, orderByComparator); 451 } 452 453 /** 454 * Returns the last document library file entry type in the ordered set where uuid = ? and companyId = ?. 455 * 456 * @param uuid the uuid 457 * @param companyId the company ID 458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 459 * @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 460 */ 461 public static DLFileEntryType fetchByUuid_C_Last(java.lang.String uuid, 462 long companyId, OrderByComparator<DLFileEntryType> orderByComparator) { 463 return getPersistence() 464 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 465 } 466 467 /** 468 * 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 = ?. 469 * 470 * @param fileEntryTypeId the primary key of the current document library file entry type 471 * @param uuid the uuid 472 * @param companyId the company ID 473 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 474 * @return the previous, current, and next document library file entry type 475 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 476 */ 477 public static DLFileEntryType[] findByUuid_C_PrevAndNext( 478 long fileEntryTypeId, java.lang.String uuid, long companyId, 479 OrderByComparator<DLFileEntryType> orderByComparator) 480 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 481 return getPersistence() 482 .findByUuid_C_PrevAndNext(fileEntryTypeId, uuid, companyId, 483 orderByComparator); 484 } 485 486 /** 487 * Removes all the document library file entry types where uuid = ? and companyId = ? from the database. 488 * 489 * @param uuid the uuid 490 * @param companyId the company ID 491 */ 492 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 493 getPersistence().removeByUuid_C(uuid, companyId); 494 } 495 496 /** 497 * Returns the number of document library file entry types where uuid = ? and companyId = ?. 498 * 499 * @param uuid the uuid 500 * @param companyId the company ID 501 * @return the number of matching document library file entry types 502 */ 503 public static int countByUuid_C(java.lang.String uuid, long companyId) { 504 return getPersistence().countByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns all the document library file entry types where groupId = ?. 509 * 510 * @param groupId the group ID 511 * @return the matching document library file entry types 512 */ 513 public static List<DLFileEntryType> findByGroupId(long groupId) { 514 return getPersistence().findByGroupId(groupId); 515 } 516 517 /** 518 * Returns a range of all the document library file entry types where groupId = ?. 519 * 520 * <p> 521 * 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. 522 * </p> 523 * 524 * @param groupId the group ID 525 * @param start the lower bound of the range of document library file entry types 526 * @param end the upper bound of the range of document library file entry types (not inclusive) 527 * @return the range of matching document library file entry types 528 */ 529 public static List<DLFileEntryType> findByGroupId(long groupId, int start, 530 int end) { 531 return getPersistence().findByGroupId(groupId, start, end); 532 } 533 534 /** 535 * Returns an ordered range of all the document library file entry types where groupId = ?. 536 * 537 * <p> 538 * 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. 539 * </p> 540 * 541 * @param groupId the group ID 542 * @param start the lower bound of the range of document library file entry types 543 * @param end the upper bound of the range of document library file entry types (not inclusive) 544 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 545 * @return the ordered range of matching document library file entry types 546 */ 547 public static List<DLFileEntryType> findByGroupId(long groupId, int start, 548 int end, OrderByComparator<DLFileEntryType> orderByComparator) { 549 return getPersistence() 550 .findByGroupId(groupId, start, end, orderByComparator); 551 } 552 553 /** 554 * Returns an ordered range of all the document library file entry types where groupId = ?. 555 * 556 * <p> 557 * 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. 558 * </p> 559 * 560 * @param groupId the group ID 561 * @param start the lower bound of the range of document library file entry types 562 * @param end the upper bound of the range of document library file entry types (not inclusive) 563 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 564 * @param retrieveFromCache whether to retrieve from the finder cache 565 * @return the ordered range of matching document library file entry types 566 */ 567 public static List<DLFileEntryType> findByGroupId(long groupId, int start, 568 int end, OrderByComparator<DLFileEntryType> orderByComparator, 569 boolean retrieveFromCache) { 570 return getPersistence() 571 .findByGroupId(groupId, start, end, orderByComparator, 572 retrieveFromCache); 573 } 574 575 /** 576 * Returns the first document library file entry type in the ordered set where groupId = ?. 577 * 578 * @param groupId the group ID 579 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 580 * @return the first matching document library file entry type 581 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 582 */ 583 public static DLFileEntryType findByGroupId_First(long groupId, 584 OrderByComparator<DLFileEntryType> orderByComparator) 585 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 586 return getPersistence().findByGroupId_First(groupId, orderByComparator); 587 } 588 589 /** 590 * Returns the first document library file entry type in the ordered set where groupId = ?. 591 * 592 * @param groupId the group ID 593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 594 * @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 595 */ 596 public static DLFileEntryType fetchByGroupId_First(long groupId, 597 OrderByComparator<DLFileEntryType> orderByComparator) { 598 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 599 } 600 601 /** 602 * Returns the last document library file entry type in the ordered set where groupId = ?. 603 * 604 * @param groupId the group ID 605 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 606 * @return the last matching document library file entry type 607 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 608 */ 609 public static DLFileEntryType findByGroupId_Last(long groupId, 610 OrderByComparator<DLFileEntryType> orderByComparator) 611 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 612 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 613 } 614 615 /** 616 * Returns the last document library file entry type in the ordered set where groupId = ?. 617 * 618 * @param groupId the group ID 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @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 621 */ 622 public static DLFileEntryType fetchByGroupId_Last(long groupId, 623 OrderByComparator<DLFileEntryType> orderByComparator) { 624 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 625 } 626 627 /** 628 * Returns the document library file entry types before and after the current document library file entry type in the ordered set where groupId = ?. 629 * 630 * @param fileEntryTypeId the primary key of the current document library file entry type 631 * @param groupId the group ID 632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 633 * @return the previous, current, and next document library file entry type 634 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 635 */ 636 public static DLFileEntryType[] findByGroupId_PrevAndNext( 637 long fileEntryTypeId, long groupId, 638 OrderByComparator<DLFileEntryType> orderByComparator) 639 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 640 return getPersistence() 641 .findByGroupId_PrevAndNext(fileEntryTypeId, groupId, 642 orderByComparator); 643 } 644 645 /** 646 * Returns all the document library file entry types that the user has permission to view where groupId = ?. 647 * 648 * @param groupId the group ID 649 * @return the matching document library file entry types that the user has permission to view 650 */ 651 public static List<DLFileEntryType> filterFindByGroupId(long groupId) { 652 return getPersistence().filterFindByGroupId(groupId); 653 } 654 655 /** 656 * Returns a range of all the document library file entry types that the user has permission to view where groupId = ?. 657 * 658 * <p> 659 * 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. 660 * </p> 661 * 662 * @param groupId the group ID 663 * @param start the lower bound of the range of document library file entry types 664 * @param end the upper bound of the range of document library file entry types (not inclusive) 665 * @return the range of matching document library file entry types that the user has permission to view 666 */ 667 public static List<DLFileEntryType> filterFindByGroupId(long groupId, 668 int start, int end) { 669 return getPersistence().filterFindByGroupId(groupId, start, end); 670 } 671 672 /** 673 * Returns an ordered range of all the document library file entry types that the user has permissions to view where groupId = ?. 674 * 675 * <p> 676 * 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. 677 * </p> 678 * 679 * @param groupId the group ID 680 * @param start the lower bound of the range of document library file entry types 681 * @param end the upper bound of the range of document library file entry types (not inclusive) 682 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 683 * @return the ordered range of matching document library file entry types that the user has permission to view 684 */ 685 public static List<DLFileEntryType> filterFindByGroupId(long groupId, 686 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 687 return getPersistence() 688 .filterFindByGroupId(groupId, start, end, orderByComparator); 689 } 690 691 /** 692 * 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 = ?. 693 * 694 * @param fileEntryTypeId the primary key of the current document library file entry type 695 * @param groupId the group ID 696 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 697 * @return the previous, current, and next document library file entry type 698 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 699 */ 700 public static DLFileEntryType[] filterFindByGroupId_PrevAndNext( 701 long fileEntryTypeId, long groupId, 702 OrderByComparator<DLFileEntryType> orderByComparator) 703 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 704 return getPersistence() 705 .filterFindByGroupId_PrevAndNext(fileEntryTypeId, groupId, 706 orderByComparator); 707 } 708 709 /** 710 * Returns all the document library file entry types that the user has permission to view where groupId = any ?. 711 * 712 * @param groupIds the group IDs 713 * @return the matching document library file entry types that the user has permission to view 714 */ 715 public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds) { 716 return getPersistence().filterFindByGroupId(groupIds); 717 } 718 719 /** 720 * Returns a range of all the document library file entry types that the user has permission to view where groupId = any ?. 721 * 722 * <p> 723 * 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. 724 * </p> 725 * 726 * @param groupIds the group IDs 727 * @param start the lower bound of the range of document library file entry types 728 * @param end the upper bound of the range of document library file entry types (not inclusive) 729 * @return the range of matching document library file entry types that the user has permission to view 730 */ 731 public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds, 732 int start, int end) { 733 return getPersistence().filterFindByGroupId(groupIds, start, end); 734 } 735 736 /** 737 * Returns an ordered range of all the document library file entry types that the user has permission to view where groupId = any ?. 738 * 739 * <p> 740 * 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. 741 * </p> 742 * 743 * @param groupIds the group IDs 744 * @param start the lower bound of the range of document library file entry types 745 * @param end the upper bound of the range of document library file entry types (not inclusive) 746 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 747 * @return the ordered range of matching document library file entry types that the user has permission to view 748 */ 749 public static List<DLFileEntryType> filterFindByGroupId(long[] groupIds, 750 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 751 return getPersistence() 752 .filterFindByGroupId(groupIds, start, end, orderByComparator); 753 } 754 755 /** 756 * Returns all the document library file entry types where groupId = any ?. 757 * 758 * <p> 759 * 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. 760 * </p> 761 * 762 * @param groupIds the group IDs 763 * @return the matching document library file entry types 764 */ 765 public static List<DLFileEntryType> findByGroupId(long[] groupIds) { 766 return getPersistence().findByGroupId(groupIds); 767 } 768 769 /** 770 * Returns a range of all the document library file entry types where groupId = any ?. 771 * 772 * <p> 773 * 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. 774 * </p> 775 * 776 * @param groupIds the group IDs 777 * @param start the lower bound of the range of document library file entry types 778 * @param end the upper bound of the range of document library file entry types (not inclusive) 779 * @return the range of matching document library file entry types 780 */ 781 public static List<DLFileEntryType> findByGroupId(long[] groupIds, 782 int start, int end) { 783 return getPersistence().findByGroupId(groupIds, start, end); 784 } 785 786 /** 787 * Returns an ordered range of all the document library file entry types where groupId = any ?. 788 * 789 * <p> 790 * 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. 791 * </p> 792 * 793 * @param groupIds the group IDs 794 * @param start the lower bound of the range of document library file entry types 795 * @param end the upper bound of the range of document library file entry types (not inclusive) 796 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 797 * @return the ordered range of matching document library file entry types 798 */ 799 public static List<DLFileEntryType> findByGroupId(long[] groupIds, 800 int start, int end, OrderByComparator<DLFileEntryType> orderByComparator) { 801 return getPersistence() 802 .findByGroupId(groupIds, start, end, orderByComparator); 803 } 804 805 /** 806 * Returns an ordered range of all the document library file entry types where groupId = ?, optionally using the finder cache. 807 * 808 * <p> 809 * 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. 810 * </p> 811 * 812 * @param groupId the group ID 813 * @param start the lower bound of the range of document library file entry types 814 * @param end the upper bound of the range of document library file entry types (not inclusive) 815 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 816 * @param retrieveFromCache whether to retrieve from the finder cache 817 * @return the ordered range of matching document library file entry types 818 */ 819 public static List<DLFileEntryType> findByGroupId(long[] groupIds, 820 int start, int end, 821 OrderByComparator<DLFileEntryType> orderByComparator, 822 boolean retrieveFromCache) { 823 return getPersistence() 824 .findByGroupId(groupIds, start, end, orderByComparator, 825 retrieveFromCache); 826 } 827 828 /** 829 * Removes all the document library file entry types where groupId = ? from the database. 830 * 831 * @param groupId the group ID 832 */ 833 public static void removeByGroupId(long groupId) { 834 getPersistence().removeByGroupId(groupId); 835 } 836 837 /** 838 * Returns the number of document library file entry types where groupId = ?. 839 * 840 * @param groupId the group ID 841 * @return the number of matching document library file entry types 842 */ 843 public static int countByGroupId(long groupId) { 844 return getPersistence().countByGroupId(groupId); 845 } 846 847 /** 848 * Returns the number of document library file entry types where groupId = any ?. 849 * 850 * @param groupIds the group IDs 851 * @return the number of matching document library file entry types 852 */ 853 public static int countByGroupId(long[] groupIds) { 854 return getPersistence().countByGroupId(groupIds); 855 } 856 857 /** 858 * Returns the number of document library file entry types that the user has permission to view where groupId = ?. 859 * 860 * @param groupId the group ID 861 * @return the number of matching document library file entry types that the user has permission to view 862 */ 863 public static int filterCountByGroupId(long groupId) { 864 return getPersistence().filterCountByGroupId(groupId); 865 } 866 867 /** 868 * Returns the number of document library file entry types that the user has permission to view where groupId = any ?. 869 * 870 * @param groupIds the group IDs 871 * @return the number of matching document library file entry types that the user has permission to view 872 */ 873 public static int filterCountByGroupId(long[] groupIds) { 874 return getPersistence().filterCountByGroupId(groupIds); 875 } 876 877 /** 878 * Returns the document library file entry type where groupId = ? and fileEntryTypeKey = ? or throws a {@link NoSuchFileEntryTypeException} if it could not be found. 879 * 880 * @param groupId the group ID 881 * @param fileEntryTypeKey the file entry type key 882 * @return the matching document library file entry type 883 * @throws NoSuchFileEntryTypeException if a matching document library file entry type could not be found 884 */ 885 public static DLFileEntryType findByG_F(long groupId, 886 java.lang.String fileEntryTypeKey) 887 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 888 return getPersistence().findByG_F(groupId, fileEntryTypeKey); 889 } 890 891 /** 892 * 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. 893 * 894 * @param groupId the group ID 895 * @param fileEntryTypeKey the file entry type key 896 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 897 */ 898 public static DLFileEntryType fetchByG_F(long groupId, 899 java.lang.String fileEntryTypeKey) { 900 return getPersistence().fetchByG_F(groupId, fileEntryTypeKey); 901 } 902 903 /** 904 * 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. 905 * 906 * @param groupId the group ID 907 * @param fileEntryTypeKey the file entry type key 908 * @param retrieveFromCache whether to retrieve from the finder cache 909 * @return the matching document library file entry type, or <code>null</code> if a matching document library file entry type could not be found 910 */ 911 public static DLFileEntryType fetchByG_F(long groupId, 912 java.lang.String fileEntryTypeKey, boolean retrieveFromCache) { 913 return getPersistence() 914 .fetchByG_F(groupId, fileEntryTypeKey, retrieveFromCache); 915 } 916 917 /** 918 * Removes the document library file entry type where groupId = ? and fileEntryTypeKey = ? from the database. 919 * 920 * @param groupId the group ID 921 * @param fileEntryTypeKey the file entry type key 922 * @return the document library file entry type that was removed 923 */ 924 public static DLFileEntryType removeByG_F(long groupId, 925 java.lang.String fileEntryTypeKey) 926 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 927 return getPersistence().removeByG_F(groupId, fileEntryTypeKey); 928 } 929 930 /** 931 * Returns the number of document library file entry types where groupId = ? and fileEntryTypeKey = ?. 932 * 933 * @param groupId the group ID 934 * @param fileEntryTypeKey the file entry type key 935 * @return the number of matching document library file entry types 936 */ 937 public static int countByG_F(long groupId, java.lang.String fileEntryTypeKey) { 938 return getPersistence().countByG_F(groupId, fileEntryTypeKey); 939 } 940 941 /** 942 * Caches the document library file entry type in the entity cache if it is enabled. 943 * 944 * @param dlFileEntryType the document library file entry type 945 */ 946 public static void cacheResult(DLFileEntryType dlFileEntryType) { 947 getPersistence().cacheResult(dlFileEntryType); 948 } 949 950 /** 951 * Caches the document library file entry types in the entity cache if it is enabled. 952 * 953 * @param dlFileEntryTypes the document library file entry types 954 */ 955 public static void cacheResult(List<DLFileEntryType> dlFileEntryTypes) { 956 getPersistence().cacheResult(dlFileEntryTypes); 957 } 958 959 /** 960 * Creates a new document library file entry type with the primary key. Does not add the document library file entry type to the database. 961 * 962 * @param fileEntryTypeId the primary key for the new document library file entry type 963 * @return the new document library file entry type 964 */ 965 public static DLFileEntryType create(long fileEntryTypeId) { 966 return getPersistence().create(fileEntryTypeId); 967 } 968 969 /** 970 * Removes the document library file entry type with the primary key from the database. Also notifies the appropriate model listeners. 971 * 972 * @param fileEntryTypeId the primary key of the document library file entry type 973 * @return the document library file entry type that was removed 974 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 975 */ 976 public static DLFileEntryType remove(long fileEntryTypeId) 977 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 978 return getPersistence().remove(fileEntryTypeId); 979 } 980 981 public static DLFileEntryType updateImpl(DLFileEntryType dlFileEntryType) { 982 return getPersistence().updateImpl(dlFileEntryType); 983 } 984 985 /** 986 * Returns the document library file entry type with the primary key or throws a {@link NoSuchFileEntryTypeException} if it could not be found. 987 * 988 * @param fileEntryTypeId the primary key of the document library file entry type 989 * @return the document library file entry type 990 * @throws NoSuchFileEntryTypeException if a document library file entry type with the primary key could not be found 991 */ 992 public static DLFileEntryType findByPrimaryKey(long fileEntryTypeId) 993 throws com.liferay.portlet.documentlibrary.exception.NoSuchFileEntryTypeException { 994 return getPersistence().findByPrimaryKey(fileEntryTypeId); 995 } 996 997 /** 998 * Returns the document library file entry type with the primary key or returns <code>null</code> if it could not be found. 999 * 1000 * @param fileEntryTypeId the primary key of the document library file entry type 1001 * @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 1002 */ 1003 public static DLFileEntryType fetchByPrimaryKey(long fileEntryTypeId) { 1004 return getPersistence().fetchByPrimaryKey(fileEntryTypeId); 1005 } 1006 1007 public static java.util.Map<java.io.Serializable, DLFileEntryType> fetchByPrimaryKeys( 1008 java.util.Set<java.io.Serializable> primaryKeys) { 1009 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1010 } 1011 1012 /** 1013 * Returns all the document library file entry types. 1014 * 1015 * @return the document library file entry types 1016 */ 1017 public static List<DLFileEntryType> findAll() { 1018 return getPersistence().findAll(); 1019 } 1020 1021 /** 1022 * Returns a range of all the document library file entry types. 1023 * 1024 * <p> 1025 * 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. 1026 * </p> 1027 * 1028 * @param start the lower bound of the range of document library file entry types 1029 * @param end the upper bound of the range of document library file entry types (not inclusive) 1030 * @return the range of document library file entry types 1031 */ 1032 public static List<DLFileEntryType> findAll(int start, int end) { 1033 return getPersistence().findAll(start, end); 1034 } 1035 1036 /** 1037 * Returns an ordered range of all the document library file entry types. 1038 * 1039 * <p> 1040 * 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. 1041 * </p> 1042 * 1043 * @param start the lower bound of the range of document library file entry types 1044 * @param end the upper bound of the range of document library file entry types (not inclusive) 1045 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1046 * @return the ordered range of document library file entry types 1047 */ 1048 public static List<DLFileEntryType> findAll(int start, int end, 1049 OrderByComparator<DLFileEntryType> orderByComparator) { 1050 return getPersistence().findAll(start, end, orderByComparator); 1051 } 1052 1053 /** 1054 * Returns an ordered range of all the document library file entry types. 1055 * 1056 * <p> 1057 * 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. 1058 * </p> 1059 * 1060 * @param start the lower bound of the range of document library file entry types 1061 * @param end the upper bound of the range of document library file entry types (not inclusive) 1062 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1063 * @param retrieveFromCache whether to retrieve from the finder cache 1064 * @return the ordered range of document library file entry types 1065 */ 1066 public static List<DLFileEntryType> findAll(int start, int end, 1067 OrderByComparator<DLFileEntryType> orderByComparator, 1068 boolean retrieveFromCache) { 1069 return getPersistence() 1070 .findAll(start, end, orderByComparator, retrieveFromCache); 1071 } 1072 1073 /** 1074 * Removes all the document library file entry types from the database. 1075 */ 1076 public static void removeAll() { 1077 getPersistence().removeAll(); 1078 } 1079 1080 /** 1081 * Returns the number of document library file entry types. 1082 * 1083 * @return the number of document library file entry types 1084 */ 1085 public static int countAll() { 1086 return getPersistence().countAll(); 1087 } 1088 1089 /** 1090 * Returns the primaryKeys of document library folders associated with the document library file entry type. 1091 * 1092 * @param pk the primary key of the document library file entry type 1093 * @return long[] of the primaryKeys of document library folders associated with the document library file entry type 1094 */ 1095 public static long[] getDLFolderPrimaryKeys(long pk) { 1096 return getPersistence().getDLFolderPrimaryKeys(pk); 1097 } 1098 1099 /** 1100 * Returns all the document library folders associated with the document library file entry type. 1101 * 1102 * @param pk the primary key of the document library file entry type 1103 * @return the document library folders associated with the document library file entry type 1104 */ 1105 public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders( 1106 long pk) { 1107 return getPersistence().getDLFolders(pk); 1108 } 1109 1110 /** 1111 * Returns a range of all the document library folders associated with the document library file entry type. 1112 * 1113 * <p> 1114 * 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. 1115 * </p> 1116 * 1117 * @param pk the primary key of the document library file entry type 1118 * @param start the lower bound of the range of document library file entry types 1119 * @param end the upper bound of the range of document library file entry types (not inclusive) 1120 * @return the range of document library folders associated with the document library file entry type 1121 */ 1122 public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders( 1123 long pk, int start, int end) { 1124 return getPersistence().getDLFolders(pk, start, end); 1125 } 1126 1127 /** 1128 * Returns an ordered range of all the document library folders associated with the document library file entry type. 1129 * 1130 * <p> 1131 * 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. 1132 * </p> 1133 * 1134 * @param pk the primary key of the document library file entry type 1135 * @param start the lower bound of the range of document library file entry types 1136 * @param end the upper bound of the range of document library file entry types (not inclusive) 1137 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1138 * @return the ordered range of document library folders associated with the document library file entry type 1139 */ 1140 public static List<com.liferay.portlet.documentlibrary.model.DLFolder> getDLFolders( 1141 long pk, int start, int end, 1142 OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFolder> orderByComparator) { 1143 return getPersistence().getDLFolders(pk, start, end, orderByComparator); 1144 } 1145 1146 /** 1147 * Returns the number of document library folders associated with the document library file entry type. 1148 * 1149 * @param pk the primary key of the document library file entry type 1150 * @return the number of document library folders associated with the document library file entry type 1151 */ 1152 public static int getDLFoldersSize(long pk) { 1153 return getPersistence().getDLFoldersSize(pk); 1154 } 1155 1156 /** 1157 * Returns <code>true</code> if the document library folder is associated with the document library file entry type. 1158 * 1159 * @param pk the primary key of the document library file entry type 1160 * @param dlFolderPK the primary key of the document library folder 1161 * @return <code>true</code> if the document library folder is associated with the document library file entry type; <code>false</code> otherwise 1162 */ 1163 public static boolean containsDLFolder(long pk, long dlFolderPK) { 1164 return getPersistence().containsDLFolder(pk, dlFolderPK); 1165 } 1166 1167 /** 1168 * Returns <code>true</code> if the document library file entry type has any document library folders associated with it. 1169 * 1170 * @param pk the primary key of the document library file entry type to check for associations with document library folders 1171 * @return <code>true</code> if the document library file entry type has any document library folders associated with it; <code>false</code> otherwise 1172 */ 1173 public static boolean containsDLFolders(long pk) { 1174 return getPersistence().containsDLFolders(pk); 1175 } 1176 1177 /** 1178 * 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. 1179 * 1180 * @param pk the primary key of the document library file entry type 1181 * @param dlFolderPK the primary key of the document library folder 1182 */ 1183 public static void addDLFolder(long pk, long dlFolderPK) { 1184 getPersistence().addDLFolder(pk, dlFolderPK); 1185 } 1186 1187 /** 1188 * 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. 1189 * 1190 * @param pk the primary key of the document library file entry type 1191 * @param dlFolder the document library folder 1192 */ 1193 public static void addDLFolder(long pk, 1194 com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) { 1195 getPersistence().addDLFolder(pk, dlFolder); 1196 } 1197 1198 /** 1199 * 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. 1200 * 1201 * @param pk the primary key of the document library file entry type 1202 * @param dlFolderPKs the primary keys of the document library folders 1203 */ 1204 public static void addDLFolders(long pk, long[] dlFolderPKs) { 1205 getPersistence().addDLFolders(pk, dlFolderPKs); 1206 } 1207 1208 /** 1209 * 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. 1210 * 1211 * @param pk the primary key of the document library file entry type 1212 * @param dlFolders the document library folders 1213 */ 1214 public static void addDLFolders(long pk, 1215 List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) { 1216 getPersistence().addDLFolders(pk, dlFolders); 1217 } 1218 1219 /** 1220 * 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. 1221 * 1222 * @param pk the primary key of the document library file entry type to clear the associated document library folders from 1223 */ 1224 public static void clearDLFolders(long pk) { 1225 getPersistence().clearDLFolders(pk); 1226 } 1227 1228 /** 1229 * 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. 1230 * 1231 * @param pk the primary key of the document library file entry type 1232 * @param dlFolderPK the primary key of the document library folder 1233 */ 1234 public static void removeDLFolder(long pk, long dlFolderPK) { 1235 getPersistence().removeDLFolder(pk, dlFolderPK); 1236 } 1237 1238 /** 1239 * 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. 1240 * 1241 * @param pk the primary key of the document library file entry type 1242 * @param dlFolder the document library folder 1243 */ 1244 public static void removeDLFolder(long pk, 1245 com.liferay.portlet.documentlibrary.model.DLFolder dlFolder) { 1246 getPersistence().removeDLFolder(pk, dlFolder); 1247 } 1248 1249 /** 1250 * 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. 1251 * 1252 * @param pk the primary key of the document library file entry type 1253 * @param dlFolderPKs the primary keys of the document library folders 1254 */ 1255 public static void removeDLFolders(long pk, long[] dlFolderPKs) { 1256 getPersistence().removeDLFolders(pk, dlFolderPKs); 1257 } 1258 1259 /** 1260 * 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. 1261 * 1262 * @param pk the primary key of the document library file entry type 1263 * @param dlFolders the document library folders 1264 */ 1265 public static void removeDLFolders(long pk, 1266 List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) { 1267 getPersistence().removeDLFolders(pk, dlFolders); 1268 } 1269 1270 /** 1271 * 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. 1272 * 1273 * @param pk the primary key of the document library file entry type 1274 * @param dlFolderPKs the primary keys of the document library folders to be associated with the document library file entry type 1275 */ 1276 public static void setDLFolders(long pk, long[] dlFolderPKs) { 1277 getPersistence().setDLFolders(pk, dlFolderPKs); 1278 } 1279 1280 /** 1281 * 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. 1282 * 1283 * @param pk the primary key of the document library file entry type 1284 * @param dlFolders the document library folders to be associated with the document library file entry type 1285 */ 1286 public static void setDLFolders(long pk, 1287 List<com.liferay.portlet.documentlibrary.model.DLFolder> dlFolders) { 1288 getPersistence().setDLFolders(pk, dlFolders); 1289 } 1290 1291 public static java.util.Set<java.lang.String> getBadColumnNames() { 1292 return getPersistence().getBadColumnNames(); 1293 } 1294 1295 public static DLFileEntryTypePersistence getPersistence() { 1296 if (_persistence == null) { 1297 _persistence = (DLFileEntryTypePersistence)PortalBeanLocatorUtil.locate(DLFileEntryTypePersistence.class.getName()); 1298 1299 ReferenceRegistry.registerReference(DLFileEntryTypeUtil.class, 1300 "_persistence"); 1301 } 1302 1303 return _persistence; 1304 } 1305 1306 private static DLFileEntryTypePersistence _persistence; 1307 }