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.portal.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.model.LayoutFriendlyURL; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the layout friendly u r l service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutFriendlyURLPersistenceImpl} 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. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see LayoutFriendlyURLPersistence 037 * @see com.liferay.portal.service.persistence.impl.LayoutFriendlyURLPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class LayoutFriendlyURLUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(LayoutFriendlyURL layoutFriendlyURL) { 059 getPersistence().clearCache(layoutFriendlyURL); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<LayoutFriendlyURL> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<LayoutFriendlyURL> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<LayoutFriendlyURL> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static LayoutFriendlyURL update(LayoutFriendlyURL layoutFriendlyURL) { 100 return getPersistence().update(layoutFriendlyURL); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static LayoutFriendlyURL update( 107 LayoutFriendlyURL layoutFriendlyURL, ServiceContext serviceContext) { 108 return getPersistence().update(layoutFriendlyURL, serviceContext); 109 } 110 111 /** 112 * Returns all the layout friendly u r ls where uuid = ?. 113 * 114 * @param uuid the uuid 115 * @return the matching layout friendly u r ls 116 */ 117 public static List<LayoutFriendlyURL> findByUuid(java.lang.String uuid) { 118 return getPersistence().findByUuid(uuid); 119 } 120 121 /** 122 * Returns a range of all the layout friendly u r ls where uuid = ?. 123 * 124 * <p> 125 * 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 LayoutFriendlyURLModelImpl}. 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. 126 * </p> 127 * 128 * @param uuid the uuid 129 * @param start the lower bound of the range of layout friendly u r ls 130 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 131 * @return the range of matching layout friendly u r ls 132 */ 133 public static List<LayoutFriendlyURL> findByUuid(java.lang.String uuid, 134 int start, int end) { 135 return getPersistence().findByUuid(uuid, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the layout friendly u r ls where uuid = ?. 140 * 141 * <p> 142 * 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 LayoutFriendlyURLModelImpl}. 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. 143 * </p> 144 * 145 * @param uuid the uuid 146 * @param start the lower bound of the range of layout friendly u r ls 147 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching layout friendly u r ls 150 */ 151 public static List<LayoutFriendlyURL> findByUuid(java.lang.String uuid, 152 int start, int end, 153 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first layout friendly u r l 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 layout friendly u r l 163 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 164 */ 165 public static LayoutFriendlyURL findByUuid_First(java.lang.String uuid, 166 OrderByComparator<LayoutFriendlyURL> orderByComparator) 167 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 168 return getPersistence().findByUuid_First(uuid, orderByComparator); 169 } 170 171 /** 172 * Returns the first layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 177 */ 178 public static LayoutFriendlyURL fetchByUuid_First(java.lang.String uuid, 179 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 180 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the last layout friendly u r l 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 layout friendly u r l 189 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 190 */ 191 public static LayoutFriendlyURL findByUuid_Last(java.lang.String uuid, 192 OrderByComparator<LayoutFriendlyURL> orderByComparator) 193 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 194 return getPersistence().findByUuid_Last(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 203 */ 204 public static LayoutFriendlyURL fetchByUuid_Last(java.lang.String uuid, 205 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 206 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 207 } 208 209 /** 210 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = ?. 211 * 212 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 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 layout friendly u r l 216 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 217 */ 218 public static LayoutFriendlyURL[] findByUuid_PrevAndNext( 219 long layoutFriendlyURLId, java.lang.String uuid, 220 OrderByComparator<LayoutFriendlyURL> orderByComparator) 221 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 222 return getPersistence() 223 .findByUuid_PrevAndNext(layoutFriendlyURLId, uuid, 224 orderByComparator); 225 } 226 227 /** 228 * Removes all the layout friendly u r ls 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 layout friendly u r ls where uuid = ?. 238 * 239 * @param uuid the uuid 240 * @return the number of matching layout friendly u r ls 241 */ 242 public static int countByUuid(java.lang.String uuid) { 243 return getPersistence().countByUuid(uuid); 244 } 245 246 /** 247 * Returns the layout friendly u r l where uuid = ? and groupId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 248 * 249 * @param uuid the uuid 250 * @param groupId the group ID 251 * @return the matching layout friendly u r l 252 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 253 */ 254 public static LayoutFriendlyURL findByUUID_G(java.lang.String uuid, 255 long groupId) 256 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 257 return getPersistence().findByUUID_G(uuid, groupId); 258 } 259 260 /** 261 * Returns the layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 266 */ 267 public static LayoutFriendlyURL fetchByUUID_G(java.lang.String uuid, 268 long groupId) { 269 return getPersistence().fetchByUUID_G(uuid, groupId); 270 } 271 272 /** 273 * Returns the layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 279 */ 280 public static LayoutFriendlyURL 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 layout friendly u r l where uuid = ? and groupId = ? from the database. 287 * 288 * @param uuid the uuid 289 * @param groupId the group ID 290 * @return the layout friendly u r l that was removed 291 */ 292 public static LayoutFriendlyURL removeByUUID_G(java.lang.String uuid, 293 long groupId) 294 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 295 return getPersistence().removeByUUID_G(uuid, groupId); 296 } 297 298 /** 299 * Returns the number of layout friendly u r ls where uuid = ? and groupId = ?. 300 * 301 * @param uuid the uuid 302 * @param groupId the group ID 303 * @return the number of matching layout friendly u r ls 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 layout friendly u r ls where uuid = ? and companyId = ?. 311 * 312 * @param uuid the uuid 313 * @param companyId the company ID 314 * @return the matching layout friendly u r ls 315 */ 316 public static List<LayoutFriendlyURL> 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 layout friendly u r ls 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 LayoutFriendlyURLModelImpl}. 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 layout friendly u r ls 331 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 332 * @return the range of matching layout friendly u r ls 333 */ 334 public static List<LayoutFriendlyURL> 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 layout friendly u r ls 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 LayoutFriendlyURLModelImpl}. 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 layout friendly u r ls 349 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 350 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 351 * @return the ordered range of matching layout friendly u r ls 352 */ 353 public static List<LayoutFriendlyURL> findByUuid_C(java.lang.String uuid, 354 long companyId, int start, int end, 355 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 356 return getPersistence() 357 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 358 } 359 360 /** 361 * Returns the first layout friendly u r l 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 layout friendly u r l 367 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 368 */ 369 public static LayoutFriendlyURL findByUuid_C_First(java.lang.String uuid, 370 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) 371 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 372 return getPersistence() 373 .findByUuid_C_First(uuid, companyId, orderByComparator); 374 } 375 376 /** 377 * Returns the first layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 383 */ 384 public static LayoutFriendlyURL fetchByUuid_C_First(java.lang.String uuid, 385 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 386 return getPersistence() 387 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 388 } 389 390 /** 391 * Returns the last layout friendly u r l 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 layout friendly u r l 397 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 398 */ 399 public static LayoutFriendlyURL findByUuid_C_Last(java.lang.String uuid, 400 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) 401 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 402 return getPersistence() 403 .findByUuid_C_Last(uuid, companyId, orderByComparator); 404 } 405 406 /** 407 * Returns the last layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 413 */ 414 public static LayoutFriendlyURL fetchByUuid_C_Last(java.lang.String uuid, 415 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 416 return getPersistence() 417 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 418 } 419 420 /** 421 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = ? and companyId = ?. 422 * 423 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 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 layout friendly u r l 428 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 429 */ 430 public static LayoutFriendlyURL[] findByUuid_C_PrevAndNext( 431 long layoutFriendlyURLId, java.lang.String uuid, long companyId, 432 OrderByComparator<LayoutFriendlyURL> orderByComparator) 433 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 434 return getPersistence() 435 .findByUuid_C_PrevAndNext(layoutFriendlyURLId, uuid, 436 companyId, orderByComparator); 437 } 438 439 /** 440 * Removes all the layout friendly u r ls 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 layout friendly u r ls where uuid = ? and companyId = ?. 451 * 452 * @param uuid the uuid 453 * @param companyId the company ID 454 * @return the number of matching layout friendly u r ls 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 layout friendly u r ls where groupId = ?. 462 * 463 * @param groupId the group ID 464 * @return the matching layout friendly u r ls 465 */ 466 public static List<LayoutFriendlyURL> findByGroupId(long groupId) { 467 return getPersistence().findByGroupId(groupId); 468 } 469 470 /** 471 * Returns a range of all the layout friendly u r ls 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 LayoutFriendlyURLModelImpl}. 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 layout friendly u r ls 479 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 480 * @return the range of matching layout friendly u r ls 481 */ 482 public static List<LayoutFriendlyURL> findByGroupId(long groupId, 483 int start, int end) { 484 return getPersistence().findByGroupId(groupId, start, end); 485 } 486 487 /** 488 * Returns an ordered range of all the layout friendly u r ls 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 LayoutFriendlyURLModelImpl}. 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 layout friendly u r ls 496 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 497 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 498 * @return the ordered range of matching layout friendly u r ls 499 */ 500 public static List<LayoutFriendlyURL> findByGroupId(long groupId, 501 int start, int end, 502 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 503 return getPersistence() 504 .findByGroupId(groupId, start, end, orderByComparator); 505 } 506 507 /** 508 * Returns the first layout friendly u r l in the ordered set where groupId = ?. 509 * 510 * @param groupId the group ID 511 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 512 * @return the first matching layout friendly u r l 513 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 514 */ 515 public static LayoutFriendlyURL findByGroupId_First(long groupId, 516 OrderByComparator<LayoutFriendlyURL> orderByComparator) 517 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 518 return getPersistence().findByGroupId_First(groupId, orderByComparator); 519 } 520 521 /** 522 * Returns the first layout friendly u r l in the ordered set where groupId = ?. 523 * 524 * @param groupId the group ID 525 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 526 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 527 */ 528 public static LayoutFriendlyURL fetchByGroupId_First(long groupId, 529 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 530 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 531 } 532 533 /** 534 * Returns the last layout friendly u r l in the ordered set where groupId = ?. 535 * 536 * @param groupId the group ID 537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 538 * @return the last matching layout friendly u r l 539 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 540 */ 541 public static LayoutFriendlyURL findByGroupId_Last(long groupId, 542 OrderByComparator<LayoutFriendlyURL> orderByComparator) 543 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 544 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 545 } 546 547 /** 548 * Returns the last layout friendly u r l in the ordered set where groupId = ?. 549 * 550 * @param groupId the group ID 551 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 552 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 553 */ 554 public static LayoutFriendlyURL fetchByGroupId_Last(long groupId, 555 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 556 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 557 } 558 559 /** 560 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = ?. 561 * 562 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 563 * @param groupId the group ID 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the previous, current, and next layout friendly u r l 566 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 567 */ 568 public static LayoutFriendlyURL[] findByGroupId_PrevAndNext( 569 long layoutFriendlyURLId, long groupId, 570 OrderByComparator<LayoutFriendlyURL> orderByComparator) 571 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 572 return getPersistence() 573 .findByGroupId_PrevAndNext(layoutFriendlyURLId, groupId, 574 orderByComparator); 575 } 576 577 /** 578 * Removes all the layout friendly u r ls where groupId = ? from the database. 579 * 580 * @param groupId the group ID 581 */ 582 public static void removeByGroupId(long groupId) { 583 getPersistence().removeByGroupId(groupId); 584 } 585 586 /** 587 * Returns the number of layout friendly u r ls where groupId = ?. 588 * 589 * @param groupId the group ID 590 * @return the number of matching layout friendly u r ls 591 */ 592 public static int countByGroupId(long groupId) { 593 return getPersistence().countByGroupId(groupId); 594 } 595 596 /** 597 * Returns all the layout friendly u r ls where companyId = ?. 598 * 599 * @param companyId the company ID 600 * @return the matching layout friendly u r ls 601 */ 602 public static List<LayoutFriendlyURL> findByCompanyId(long companyId) { 603 return getPersistence().findByCompanyId(companyId); 604 } 605 606 /** 607 * Returns a range of all the layout friendly u r ls where companyId = ?. 608 * 609 * <p> 610 * 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 LayoutFriendlyURLModelImpl}. 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. 611 * </p> 612 * 613 * @param companyId the company ID 614 * @param start the lower bound of the range of layout friendly u r ls 615 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 616 * @return the range of matching layout friendly u r ls 617 */ 618 public static List<LayoutFriendlyURL> findByCompanyId(long companyId, 619 int start, int end) { 620 return getPersistence().findByCompanyId(companyId, start, end); 621 } 622 623 /** 624 * Returns an ordered range of all the layout friendly u r ls where companyId = ?. 625 * 626 * <p> 627 * 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 LayoutFriendlyURLModelImpl}. 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. 628 * </p> 629 * 630 * @param companyId the company ID 631 * @param start the lower bound of the range of layout friendly u r ls 632 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 633 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 634 * @return the ordered range of matching layout friendly u r ls 635 */ 636 public static List<LayoutFriendlyURL> findByCompanyId(long companyId, 637 int start, int end, 638 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 639 return getPersistence() 640 .findByCompanyId(companyId, start, end, orderByComparator); 641 } 642 643 /** 644 * Returns the first layout friendly u r l in the ordered set where companyId = ?. 645 * 646 * @param companyId the company ID 647 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 648 * @return the first matching layout friendly u r l 649 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 650 */ 651 public static LayoutFriendlyURL findByCompanyId_First(long companyId, 652 OrderByComparator<LayoutFriendlyURL> orderByComparator) 653 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 654 return getPersistence() 655 .findByCompanyId_First(companyId, orderByComparator); 656 } 657 658 /** 659 * Returns the first layout friendly u r l in the ordered set where companyId = ?. 660 * 661 * @param companyId the company ID 662 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 663 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 664 */ 665 public static LayoutFriendlyURL fetchByCompanyId_First(long companyId, 666 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 667 return getPersistence() 668 .fetchByCompanyId_First(companyId, orderByComparator); 669 } 670 671 /** 672 * Returns the last layout friendly u r l in the ordered set where companyId = ?. 673 * 674 * @param companyId the company ID 675 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 676 * @return the last matching layout friendly u r l 677 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 678 */ 679 public static LayoutFriendlyURL findByCompanyId_Last(long companyId, 680 OrderByComparator<LayoutFriendlyURL> orderByComparator) 681 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 682 return getPersistence() 683 .findByCompanyId_Last(companyId, orderByComparator); 684 } 685 686 /** 687 * Returns the last layout friendly u r l in the ordered set where companyId = ?. 688 * 689 * @param companyId the company ID 690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 691 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 692 */ 693 public static LayoutFriendlyURL fetchByCompanyId_Last(long companyId, 694 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 695 return getPersistence() 696 .fetchByCompanyId_Last(companyId, orderByComparator); 697 } 698 699 /** 700 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where companyId = ?. 701 * 702 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 703 * @param companyId the company ID 704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 705 * @return the previous, current, and next layout friendly u r l 706 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 707 */ 708 public static LayoutFriendlyURL[] findByCompanyId_PrevAndNext( 709 long layoutFriendlyURLId, long companyId, 710 OrderByComparator<LayoutFriendlyURL> orderByComparator) 711 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 712 return getPersistence() 713 .findByCompanyId_PrevAndNext(layoutFriendlyURLId, companyId, 714 orderByComparator); 715 } 716 717 /** 718 * Removes all the layout friendly u r ls where companyId = ? from the database. 719 * 720 * @param companyId the company ID 721 */ 722 public static void removeByCompanyId(long companyId) { 723 getPersistence().removeByCompanyId(companyId); 724 } 725 726 /** 727 * Returns the number of layout friendly u r ls where companyId = ?. 728 * 729 * @param companyId the company ID 730 * @return the number of matching layout friendly u r ls 731 */ 732 public static int countByCompanyId(long companyId) { 733 return getPersistence().countByCompanyId(companyId); 734 } 735 736 /** 737 * Returns all the layout friendly u r ls where plid = ?. 738 * 739 * @param plid the plid 740 * @return the matching layout friendly u r ls 741 */ 742 public static List<LayoutFriendlyURL> findByPlid(long plid) { 743 return getPersistence().findByPlid(plid); 744 } 745 746 /** 747 * Returns a range of all the layout friendly u r ls where plid = ?. 748 * 749 * <p> 750 * 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 LayoutFriendlyURLModelImpl}. 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. 751 * </p> 752 * 753 * @param plid the plid 754 * @param start the lower bound of the range of layout friendly u r ls 755 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 756 * @return the range of matching layout friendly u r ls 757 */ 758 public static List<LayoutFriendlyURL> findByPlid(long plid, int start, 759 int end) { 760 return getPersistence().findByPlid(plid, start, end); 761 } 762 763 /** 764 * Returns an ordered range of all the layout friendly u r ls where plid = ?. 765 * 766 * <p> 767 * 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 LayoutFriendlyURLModelImpl}. 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. 768 * </p> 769 * 770 * @param plid the plid 771 * @param start the lower bound of the range of layout friendly u r ls 772 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 773 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 774 * @return the ordered range of matching layout friendly u r ls 775 */ 776 public static List<LayoutFriendlyURL> findByPlid(long plid, int start, 777 int end, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 778 return getPersistence().findByPlid(plid, start, end, orderByComparator); 779 } 780 781 /** 782 * Returns the first layout friendly u r l in the ordered set where plid = ?. 783 * 784 * @param plid the plid 785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 786 * @return the first matching layout friendly u r l 787 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 788 */ 789 public static LayoutFriendlyURL findByPlid_First(long plid, 790 OrderByComparator<LayoutFriendlyURL> orderByComparator) 791 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 792 return getPersistence().findByPlid_First(plid, orderByComparator); 793 } 794 795 /** 796 * Returns the first layout friendly u r l in the ordered set where plid = ?. 797 * 798 * @param plid the plid 799 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 800 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 801 */ 802 public static LayoutFriendlyURL fetchByPlid_First(long plid, 803 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 804 return getPersistence().fetchByPlid_First(plid, orderByComparator); 805 } 806 807 /** 808 * Returns the last layout friendly u r l in the ordered set where plid = ?. 809 * 810 * @param plid the plid 811 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 812 * @return the last matching layout friendly u r l 813 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 814 */ 815 public static LayoutFriendlyURL findByPlid_Last(long plid, 816 OrderByComparator<LayoutFriendlyURL> orderByComparator) 817 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 818 return getPersistence().findByPlid_Last(plid, orderByComparator); 819 } 820 821 /** 822 * Returns the last layout friendly u r l in the ordered set where plid = ?. 823 * 824 * @param plid the plid 825 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 826 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 827 */ 828 public static LayoutFriendlyURL fetchByPlid_Last(long plid, 829 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 830 return getPersistence().fetchByPlid_Last(plid, orderByComparator); 831 } 832 833 /** 834 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = ?. 835 * 836 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 837 * @param plid the plid 838 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 839 * @return the previous, current, and next layout friendly u r l 840 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 841 */ 842 public static LayoutFriendlyURL[] findByPlid_PrevAndNext( 843 long layoutFriendlyURLId, long plid, 844 OrderByComparator<LayoutFriendlyURL> orderByComparator) 845 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 846 return getPersistence() 847 .findByPlid_PrevAndNext(layoutFriendlyURLId, plid, 848 orderByComparator); 849 } 850 851 /** 852 * Removes all the layout friendly u r ls where plid = ? from the database. 853 * 854 * @param plid the plid 855 */ 856 public static void removeByPlid(long plid) { 857 getPersistence().removeByPlid(plid); 858 } 859 860 /** 861 * Returns the number of layout friendly u r ls where plid = ?. 862 * 863 * @param plid the plid 864 * @return the number of matching layout friendly u r ls 865 */ 866 public static int countByPlid(long plid) { 867 return getPersistence().countByPlid(plid); 868 } 869 870 /** 871 * Returns all the layout friendly u r ls where plid = ? and friendlyURL = ?. 872 * 873 * @param plid the plid 874 * @param friendlyURL the friendly u r l 875 * @return the matching layout friendly u r ls 876 */ 877 public static List<LayoutFriendlyURL> findByP_F(long plid, 878 java.lang.String friendlyURL) { 879 return getPersistence().findByP_F(plid, friendlyURL); 880 } 881 882 /** 883 * Returns a range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 884 * 885 * <p> 886 * 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 LayoutFriendlyURLModelImpl}. 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. 887 * </p> 888 * 889 * @param plid the plid 890 * @param friendlyURL the friendly u r l 891 * @param start the lower bound of the range of layout friendly u r ls 892 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 893 * @return the range of matching layout friendly u r ls 894 */ 895 public static List<LayoutFriendlyURL> findByP_F(long plid, 896 java.lang.String friendlyURL, int start, int end) { 897 return getPersistence().findByP_F(plid, friendlyURL, start, end); 898 } 899 900 /** 901 * Returns an ordered range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 902 * 903 * <p> 904 * 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 LayoutFriendlyURLModelImpl}. 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. 905 * </p> 906 * 907 * @param plid the plid 908 * @param friendlyURL the friendly u r l 909 * @param start the lower bound of the range of layout friendly u r ls 910 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 911 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 912 * @return the ordered range of matching layout friendly u r ls 913 */ 914 public static List<LayoutFriendlyURL> findByP_F(long plid, 915 java.lang.String friendlyURL, int start, int end, 916 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 917 return getPersistence() 918 .findByP_F(plid, friendlyURL, start, end, orderByComparator); 919 } 920 921 /** 922 * Returns the first layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 923 * 924 * @param plid the plid 925 * @param friendlyURL the friendly u r l 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the first matching layout friendly u r l 928 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 929 */ 930 public static LayoutFriendlyURL findByP_F_First(long plid, 931 java.lang.String friendlyURL, 932 OrderByComparator<LayoutFriendlyURL> orderByComparator) 933 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 934 return getPersistence() 935 .findByP_F_First(plid, friendlyURL, orderByComparator); 936 } 937 938 /** 939 * Returns the first layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 940 * 941 * @param plid the plid 942 * @param friendlyURL the friendly u r l 943 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 944 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 945 */ 946 public static LayoutFriendlyURL fetchByP_F_First(long plid, 947 java.lang.String friendlyURL, 948 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 949 return getPersistence() 950 .fetchByP_F_First(plid, friendlyURL, orderByComparator); 951 } 952 953 /** 954 * Returns the last layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 955 * 956 * @param plid the plid 957 * @param friendlyURL the friendly u r l 958 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 959 * @return the last matching layout friendly u r l 960 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 961 */ 962 public static LayoutFriendlyURL findByP_F_Last(long plid, 963 java.lang.String friendlyURL, 964 OrderByComparator<LayoutFriendlyURL> orderByComparator) 965 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 966 return getPersistence() 967 .findByP_F_Last(plid, friendlyURL, orderByComparator); 968 } 969 970 /** 971 * Returns the last layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 972 * 973 * @param plid the plid 974 * @param friendlyURL the friendly u r l 975 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 976 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 977 */ 978 public static LayoutFriendlyURL fetchByP_F_Last(long plid, 979 java.lang.String friendlyURL, 980 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 981 return getPersistence() 982 .fetchByP_F_Last(plid, friendlyURL, orderByComparator); 983 } 984 985 /** 986 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 987 * 988 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 989 * @param plid the plid 990 * @param friendlyURL the friendly u r l 991 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 992 * @return the previous, current, and next layout friendly u r l 993 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 994 */ 995 public static LayoutFriendlyURL[] findByP_F_PrevAndNext( 996 long layoutFriendlyURLId, long plid, java.lang.String friendlyURL, 997 OrderByComparator<LayoutFriendlyURL> orderByComparator) 998 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 999 return getPersistence() 1000 .findByP_F_PrevAndNext(layoutFriendlyURLId, plid, 1001 friendlyURL, orderByComparator); 1002 } 1003 1004 /** 1005 * Removes all the layout friendly u r ls where plid = ? and friendlyURL = ? from the database. 1006 * 1007 * @param plid the plid 1008 * @param friendlyURL the friendly u r l 1009 */ 1010 public static void removeByP_F(long plid, java.lang.String friendlyURL) { 1011 getPersistence().removeByP_F(plid, friendlyURL); 1012 } 1013 1014 /** 1015 * Returns the number of layout friendly u r ls where plid = ? and friendlyURL = ?. 1016 * 1017 * @param plid the plid 1018 * @param friendlyURL the friendly u r l 1019 * @return the number of matching layout friendly u r ls 1020 */ 1021 public static int countByP_F(long plid, java.lang.String friendlyURL) { 1022 return getPersistence().countByP_F(plid, friendlyURL); 1023 } 1024 1025 /** 1026 * Returns the layout friendly u r l where plid = ? and languageId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1027 * 1028 * @param plid the plid 1029 * @param languageId the language ID 1030 * @return the matching layout friendly u r l 1031 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1032 */ 1033 public static LayoutFriendlyURL findByP_L(long plid, 1034 java.lang.String languageId) 1035 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1036 return getPersistence().findByP_L(plid, languageId); 1037 } 1038 1039 /** 1040 * Returns the layout friendly u r l where plid = ? and languageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1041 * 1042 * @param plid the plid 1043 * @param languageId the language ID 1044 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1045 */ 1046 public static LayoutFriendlyURL fetchByP_L(long plid, 1047 java.lang.String languageId) { 1048 return getPersistence().fetchByP_L(plid, languageId); 1049 } 1050 1051 /** 1052 * Returns the layout friendly u r l where plid = ? and languageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1053 * 1054 * @param plid the plid 1055 * @param languageId the language ID 1056 * @param retrieveFromCache whether to use the finder cache 1057 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1058 */ 1059 public static LayoutFriendlyURL fetchByP_L(long plid, 1060 java.lang.String languageId, boolean retrieveFromCache) { 1061 return getPersistence().fetchByP_L(plid, languageId, retrieveFromCache); 1062 } 1063 1064 /** 1065 * Removes the layout friendly u r l where plid = ? and languageId = ? from the database. 1066 * 1067 * @param plid the plid 1068 * @param languageId the language ID 1069 * @return the layout friendly u r l that was removed 1070 */ 1071 public static LayoutFriendlyURL removeByP_L(long plid, 1072 java.lang.String languageId) 1073 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1074 return getPersistence().removeByP_L(plid, languageId); 1075 } 1076 1077 /** 1078 * Returns the number of layout friendly u r ls where plid = ? and languageId = ?. 1079 * 1080 * @param plid the plid 1081 * @param languageId the language ID 1082 * @return the number of matching layout friendly u r ls 1083 */ 1084 public static int countByP_L(long plid, java.lang.String languageId) { 1085 return getPersistence().countByP_L(plid, languageId); 1086 } 1087 1088 /** 1089 * Returns all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1090 * 1091 * @param groupId the group ID 1092 * @param privateLayout the private layout 1093 * @param friendlyURL the friendly u r l 1094 * @return the matching layout friendly u r ls 1095 */ 1096 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1097 boolean privateLayout, java.lang.String friendlyURL) { 1098 return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL); 1099 } 1100 1101 /** 1102 * Returns a range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1103 * 1104 * <p> 1105 * 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 LayoutFriendlyURLModelImpl}. 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. 1106 * </p> 1107 * 1108 * @param groupId the group ID 1109 * @param privateLayout the private layout 1110 * @param friendlyURL the friendly u r l 1111 * @param start the lower bound of the range of layout friendly u r ls 1112 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1113 * @return the range of matching layout friendly u r ls 1114 */ 1115 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1116 boolean privateLayout, java.lang.String friendlyURL, int start, int end) { 1117 return getPersistence() 1118 .findByG_P_F(groupId, privateLayout, friendlyURL, start, end); 1119 } 1120 1121 /** 1122 * Returns an ordered range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1123 * 1124 * <p> 1125 * 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 LayoutFriendlyURLModelImpl}. 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. 1126 * </p> 1127 * 1128 * @param groupId the group ID 1129 * @param privateLayout the private layout 1130 * @param friendlyURL the friendly u r l 1131 * @param start the lower bound of the range of layout friendly u r ls 1132 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1133 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1134 * @return the ordered range of matching layout friendly u r ls 1135 */ 1136 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1137 boolean privateLayout, java.lang.String friendlyURL, int start, 1138 int end, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1139 return getPersistence() 1140 .findByG_P_F(groupId, privateLayout, friendlyURL, start, 1141 end, orderByComparator); 1142 } 1143 1144 /** 1145 * Returns the first layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1146 * 1147 * @param groupId the group ID 1148 * @param privateLayout the private layout 1149 * @param friendlyURL the friendly u r l 1150 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1151 * @return the first matching layout friendly u r l 1152 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1153 */ 1154 public static LayoutFriendlyURL findByG_P_F_First(long groupId, 1155 boolean privateLayout, java.lang.String friendlyURL, 1156 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1157 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1158 return getPersistence() 1159 .findByG_P_F_First(groupId, privateLayout, friendlyURL, 1160 orderByComparator); 1161 } 1162 1163 /** 1164 * Returns the first layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1165 * 1166 * @param groupId the group ID 1167 * @param privateLayout the private layout 1168 * @param friendlyURL the friendly u r l 1169 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1170 * @return the first matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1171 */ 1172 public static LayoutFriendlyURL fetchByG_P_F_First(long groupId, 1173 boolean privateLayout, java.lang.String friendlyURL, 1174 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1175 return getPersistence() 1176 .fetchByG_P_F_First(groupId, privateLayout, friendlyURL, 1177 orderByComparator); 1178 } 1179 1180 /** 1181 * Returns the last layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1182 * 1183 * @param groupId the group ID 1184 * @param privateLayout the private layout 1185 * @param friendlyURL the friendly u r l 1186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1187 * @return the last matching layout friendly u r l 1188 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1189 */ 1190 public static LayoutFriendlyURL findByG_P_F_Last(long groupId, 1191 boolean privateLayout, java.lang.String friendlyURL, 1192 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1193 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1194 return getPersistence() 1195 .findByG_P_F_Last(groupId, privateLayout, friendlyURL, 1196 orderByComparator); 1197 } 1198 1199 /** 1200 * Returns the last layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1201 * 1202 * @param groupId the group ID 1203 * @param privateLayout the private layout 1204 * @param friendlyURL the friendly u r l 1205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1206 * @return the last matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1207 */ 1208 public static LayoutFriendlyURL fetchByG_P_F_Last(long groupId, 1209 boolean privateLayout, java.lang.String friendlyURL, 1210 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1211 return getPersistence() 1212 .fetchByG_P_F_Last(groupId, privateLayout, friendlyURL, 1213 orderByComparator); 1214 } 1215 1216 /** 1217 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1218 * 1219 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 1220 * @param groupId the group ID 1221 * @param privateLayout the private layout 1222 * @param friendlyURL the friendly u r l 1223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1224 * @return the previous, current, and next layout friendly u r l 1225 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1226 */ 1227 public static LayoutFriendlyURL[] findByG_P_F_PrevAndNext( 1228 long layoutFriendlyURLId, long groupId, boolean privateLayout, 1229 java.lang.String friendlyURL, 1230 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1231 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1232 return getPersistence() 1233 .findByG_P_F_PrevAndNext(layoutFriendlyURLId, groupId, 1234 privateLayout, friendlyURL, orderByComparator); 1235 } 1236 1237 /** 1238 * Removes all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ? from the database. 1239 * 1240 * @param groupId the group ID 1241 * @param privateLayout the private layout 1242 * @param friendlyURL the friendly u r l 1243 */ 1244 public static void removeByG_P_F(long groupId, boolean privateLayout, 1245 java.lang.String friendlyURL) { 1246 getPersistence().removeByG_P_F(groupId, privateLayout, friendlyURL); 1247 } 1248 1249 /** 1250 * Returns the number of layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1251 * 1252 * @param groupId the group ID 1253 * @param privateLayout the private layout 1254 * @param friendlyURL the friendly u r l 1255 * @return the number of matching layout friendly u r ls 1256 */ 1257 public static int countByG_P_F(long groupId, boolean privateLayout, 1258 java.lang.String friendlyURL) { 1259 return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL); 1260 } 1261 1262 /** 1263 * Returns the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1264 * 1265 * @param groupId the group ID 1266 * @param privateLayout the private layout 1267 * @param friendlyURL the friendly u r l 1268 * @param languageId the language ID 1269 * @return the matching layout friendly u r l 1270 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1271 */ 1272 public static LayoutFriendlyURL findByG_P_F_L(long groupId, 1273 boolean privateLayout, java.lang.String friendlyURL, 1274 java.lang.String languageId) 1275 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1276 return getPersistence() 1277 .findByG_P_F_L(groupId, privateLayout, friendlyURL, 1278 languageId); 1279 } 1280 1281 /** 1282 * Returns the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1283 * 1284 * @param groupId the group ID 1285 * @param privateLayout the private layout 1286 * @param friendlyURL the friendly u r l 1287 * @param languageId the language ID 1288 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1289 */ 1290 public static LayoutFriendlyURL fetchByG_P_F_L(long groupId, 1291 boolean privateLayout, java.lang.String friendlyURL, 1292 java.lang.String languageId) { 1293 return getPersistence() 1294 .fetchByG_P_F_L(groupId, privateLayout, friendlyURL, 1295 languageId); 1296 } 1297 1298 /** 1299 * Returns the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1300 * 1301 * @param groupId the group ID 1302 * @param privateLayout the private layout 1303 * @param friendlyURL the friendly u r l 1304 * @param languageId the language ID 1305 * @param retrieveFromCache whether to use the finder cache 1306 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1307 */ 1308 public static LayoutFriendlyURL fetchByG_P_F_L(long groupId, 1309 boolean privateLayout, java.lang.String friendlyURL, 1310 java.lang.String languageId, boolean retrieveFromCache) { 1311 return getPersistence() 1312 .fetchByG_P_F_L(groupId, privateLayout, friendlyURL, 1313 languageId, retrieveFromCache); 1314 } 1315 1316 /** 1317 * Removes the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? from the database. 1318 * 1319 * @param groupId the group ID 1320 * @param privateLayout the private layout 1321 * @param friendlyURL the friendly u r l 1322 * @param languageId the language ID 1323 * @return the layout friendly u r l that was removed 1324 */ 1325 public static LayoutFriendlyURL removeByG_P_F_L(long groupId, 1326 boolean privateLayout, java.lang.String friendlyURL, 1327 java.lang.String languageId) 1328 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1329 return getPersistence() 1330 .removeByG_P_F_L(groupId, privateLayout, friendlyURL, 1331 languageId); 1332 } 1333 1334 /** 1335 * Returns the number of layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ?. 1336 * 1337 * @param groupId the group ID 1338 * @param privateLayout the private layout 1339 * @param friendlyURL the friendly u r l 1340 * @param languageId the language ID 1341 * @return the number of matching layout friendly u r ls 1342 */ 1343 public static int countByG_P_F_L(long groupId, boolean privateLayout, 1344 java.lang.String friendlyURL, java.lang.String languageId) { 1345 return getPersistence() 1346 .countByG_P_F_L(groupId, privateLayout, friendlyURL, 1347 languageId); 1348 } 1349 1350 /** 1351 * Caches the layout friendly u r l in the entity cache if it is enabled. 1352 * 1353 * @param layoutFriendlyURL the layout friendly u r l 1354 */ 1355 public static void cacheResult(LayoutFriendlyURL layoutFriendlyURL) { 1356 getPersistence().cacheResult(layoutFriendlyURL); 1357 } 1358 1359 /** 1360 * Caches the layout friendly u r ls in the entity cache if it is enabled. 1361 * 1362 * @param layoutFriendlyURLs the layout friendly u r ls 1363 */ 1364 public static void cacheResult(List<LayoutFriendlyURL> layoutFriendlyURLs) { 1365 getPersistence().cacheResult(layoutFriendlyURLs); 1366 } 1367 1368 /** 1369 * Creates a new layout friendly u r l with the primary key. Does not add the layout friendly u r l to the database. 1370 * 1371 * @param layoutFriendlyURLId the primary key for the new layout friendly u r l 1372 * @return the new layout friendly u r l 1373 */ 1374 public static LayoutFriendlyURL create(long layoutFriendlyURLId) { 1375 return getPersistence().create(layoutFriendlyURLId); 1376 } 1377 1378 /** 1379 * Removes the layout friendly u r l with the primary key from the database. Also notifies the appropriate model listeners. 1380 * 1381 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1382 * @return the layout friendly u r l that was removed 1383 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1384 */ 1385 public static LayoutFriendlyURL remove(long layoutFriendlyURLId) 1386 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1387 return getPersistence().remove(layoutFriendlyURLId); 1388 } 1389 1390 public static LayoutFriendlyURL updateImpl( 1391 LayoutFriendlyURL layoutFriendlyURL) { 1392 return getPersistence().updateImpl(layoutFriendlyURL); 1393 } 1394 1395 /** 1396 * Returns the layout friendly u r l with the primary key or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1397 * 1398 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1399 * @return the layout friendly u r l 1400 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1401 */ 1402 public static LayoutFriendlyURL findByPrimaryKey(long layoutFriendlyURLId) 1403 throws com.liferay.portal.NoSuchLayoutFriendlyURLException { 1404 return getPersistence().findByPrimaryKey(layoutFriendlyURLId); 1405 } 1406 1407 /** 1408 * Returns the layout friendly u r l with the primary key or returns <code>null</code> if it could not be found. 1409 * 1410 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1411 * @return the layout friendly u r l, or <code>null</code> if a layout friendly u r l with the primary key could not be found 1412 */ 1413 public static LayoutFriendlyURL fetchByPrimaryKey(long layoutFriendlyURLId) { 1414 return getPersistence().fetchByPrimaryKey(layoutFriendlyURLId); 1415 } 1416 1417 public static java.util.Map<java.io.Serializable, LayoutFriendlyURL> fetchByPrimaryKeys( 1418 java.util.Set<java.io.Serializable> primaryKeys) { 1419 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1420 } 1421 1422 /** 1423 * Returns all the layout friendly u r ls. 1424 * 1425 * @return the layout friendly u r ls 1426 */ 1427 public static List<LayoutFriendlyURL> findAll() { 1428 return getPersistence().findAll(); 1429 } 1430 1431 /** 1432 * Returns a range of all the layout friendly u r ls. 1433 * 1434 * <p> 1435 * 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 LayoutFriendlyURLModelImpl}. 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. 1436 * </p> 1437 * 1438 * @param start the lower bound of the range of layout friendly u r ls 1439 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1440 * @return the range of layout friendly u r ls 1441 */ 1442 public static List<LayoutFriendlyURL> findAll(int start, int end) { 1443 return getPersistence().findAll(start, end); 1444 } 1445 1446 /** 1447 * Returns an ordered range of all the layout friendly u r ls. 1448 * 1449 * <p> 1450 * 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 LayoutFriendlyURLModelImpl}. 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. 1451 * </p> 1452 * 1453 * @param start the lower bound of the range of layout friendly u r ls 1454 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1455 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1456 * @return the ordered range of layout friendly u r ls 1457 */ 1458 public static List<LayoutFriendlyURL> findAll(int start, int end, 1459 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1460 return getPersistence().findAll(start, end, orderByComparator); 1461 } 1462 1463 /** 1464 * Removes all the layout friendly u r ls from the database. 1465 */ 1466 public static void removeAll() { 1467 getPersistence().removeAll(); 1468 } 1469 1470 /** 1471 * Returns the number of layout friendly u r ls. 1472 * 1473 * @return the number of layout friendly u r ls 1474 */ 1475 public static int countAll() { 1476 return getPersistence().countAll(); 1477 } 1478 1479 public static LayoutFriendlyURLPersistence getPersistence() { 1480 if (_persistence == null) { 1481 _persistence = (LayoutFriendlyURLPersistence)PortalBeanLocatorUtil.locate(LayoutFriendlyURLPersistence.class.getName()); 1482 1483 ReferenceRegistry.registerReference(LayoutFriendlyURLUtil.class, 1484 "_persistence"); 1485 } 1486 1487 return _persistence; 1488 } 1489 1490 /** 1491 * @deprecated As of 6.2.0 1492 */ 1493 @Deprecated 1494 public void setPersistence(LayoutFriendlyURLPersistence persistence) { 1495 } 1496 1497 private static LayoutFriendlyURLPersistence _persistence; 1498 }