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 an ordered range of all the layout friendly u r ls 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 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of layout friendly u r ls 166 * @param end the upper bound of the range of layout friendly u r ls (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 layout friendly u r ls 170 */ 171 public static List<LayoutFriendlyURL> findByUuid(java.lang.String uuid, 172 int start, int end, 173 OrderByComparator<LayoutFriendlyURL> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByUuid(uuid, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first layout friendly u r l 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 layout friendly u r l 186 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 187 */ 188 public static LayoutFriendlyURL findByUuid_First(java.lang.String uuid, 189 OrderByComparator<LayoutFriendlyURL> orderByComparator) 190 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 191 return getPersistence().findByUuid_First(uuid, orderByComparator); 192 } 193 194 /** 195 * Returns the first layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 200 */ 201 public static LayoutFriendlyURL fetchByUuid_First(java.lang.String uuid, 202 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 203 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 204 } 205 206 /** 207 * Returns the last layout friendly u r l 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 layout friendly u r l 212 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 213 */ 214 public static LayoutFriendlyURL findByUuid_Last(java.lang.String uuid, 215 OrderByComparator<LayoutFriendlyURL> orderByComparator) 216 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 217 return getPersistence().findByUuid_Last(uuid, orderByComparator); 218 } 219 220 /** 221 * Returns the last layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 226 */ 227 public static LayoutFriendlyURL fetchByUuid_Last(java.lang.String uuid, 228 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 229 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 230 } 231 232 /** 233 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where uuid = ?. 234 * 235 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 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 layout friendly u r l 239 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 240 */ 241 public static LayoutFriendlyURL[] findByUuid_PrevAndNext( 242 long layoutFriendlyURLId, java.lang.String uuid, 243 OrderByComparator<LayoutFriendlyURL> orderByComparator) 244 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(layoutFriendlyURLId, uuid, 247 orderByComparator); 248 } 249 250 /** 251 * Removes all the layout friendly u r ls 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 layout friendly u r ls where uuid = ?. 261 * 262 * @param uuid the uuid 263 * @return the number of matching layout friendly u r ls 264 */ 265 public static int countByUuid(java.lang.String uuid) { 266 return getPersistence().countByUuid(uuid); 267 } 268 269 /** 270 * Returns the layout friendly u r l where uuid = ? and groupId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 271 * 272 * @param uuid the uuid 273 * @param groupId the group ID 274 * @return the matching layout friendly u r l 275 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 276 */ 277 public static LayoutFriendlyURL findByUUID_G(java.lang.String uuid, 278 long groupId) 279 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 280 return getPersistence().findByUUID_G(uuid, groupId); 281 } 282 283 /** 284 * 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. 285 * 286 * @param uuid the uuid 287 * @param groupId the group ID 288 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 289 */ 290 public static LayoutFriendlyURL fetchByUUID_G(java.lang.String uuid, 291 long groupId) { 292 return getPersistence().fetchByUUID_G(uuid, groupId); 293 } 294 295 /** 296 * 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. 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 302 */ 303 public static LayoutFriendlyURL 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 layout friendly u r l where uuid = ? and groupId = ? from the database. 310 * 311 * @param uuid the uuid 312 * @param groupId the group ID 313 * @return the layout friendly u r l that was removed 314 */ 315 public static LayoutFriendlyURL removeByUUID_G(java.lang.String uuid, 316 long groupId) 317 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 318 return getPersistence().removeByUUID_G(uuid, groupId); 319 } 320 321 /** 322 * Returns the number of layout friendly u r ls where uuid = ? and groupId = ?. 323 * 324 * @param uuid the uuid 325 * @param groupId the group ID 326 * @return the number of matching layout friendly u r ls 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 layout friendly u r ls where uuid = ? and companyId = ?. 334 * 335 * @param uuid the uuid 336 * @param companyId the company ID 337 * @return the matching layout friendly u r ls 338 */ 339 public static List<LayoutFriendlyURL> 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 layout friendly u r ls 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 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. 349 * </p> 350 * 351 * @param uuid the uuid 352 * @param companyId the company ID 353 * @param start the lower bound of the range of layout friendly u r ls 354 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 355 * @return the range of matching layout friendly u r ls 356 */ 357 public static List<LayoutFriendlyURL> 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 layout friendly u r ls 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 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. 367 * </p> 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param start the lower bound of the range of layout friendly u r ls 372 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 373 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 374 * @return the ordered range of matching layout friendly u r ls 375 */ 376 public static List<LayoutFriendlyURL> findByUuid_C(java.lang.String uuid, 377 long companyId, int start, int end, 378 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 379 return getPersistence() 380 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 381 } 382 383 /** 384 * Returns an ordered range of all the layout friendly u r ls 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 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. 388 * </p> 389 * 390 * @param uuid the uuid 391 * @param companyId the company ID 392 * @param start the lower bound of the range of layout friendly u r ls 393 * @param end the upper bound of the range of layout friendly u r ls (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 layout friendly u r ls 397 */ 398 public static List<LayoutFriendlyURL> findByUuid_C(java.lang.String uuid, 399 long companyId, int start, int end, 400 OrderByComparator<LayoutFriendlyURL> orderByComparator, 401 boolean retrieveFromCache) { 402 return getPersistence() 403 .findByUuid_C(uuid, companyId, start, end, 404 orderByComparator, retrieveFromCache); 405 } 406 407 /** 408 * Returns the first layout friendly u r l 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 layout friendly u r l 414 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 415 */ 416 public static LayoutFriendlyURL findByUuid_C_First(java.lang.String uuid, 417 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) 418 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 419 return getPersistence() 420 .findByUuid_C_First(uuid, companyId, orderByComparator); 421 } 422 423 /** 424 * Returns the first layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 430 */ 431 public static LayoutFriendlyURL fetchByUuid_C_First(java.lang.String uuid, 432 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 433 return getPersistence() 434 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 435 } 436 437 /** 438 * Returns the last layout friendly u r l 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 layout friendly u r l 444 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 445 */ 446 public static LayoutFriendlyURL findByUuid_C_Last(java.lang.String uuid, 447 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) 448 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 449 return getPersistence() 450 .findByUuid_C_Last(uuid, companyId, orderByComparator); 451 } 452 453 /** 454 * Returns the last layout friendly u r l 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 layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 460 */ 461 public static LayoutFriendlyURL fetchByUuid_C_Last(java.lang.String uuid, 462 long companyId, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 463 return getPersistence() 464 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 465 } 466 467 /** 468 * 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 = ?. 469 * 470 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 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 layout friendly u r l 475 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 476 */ 477 public static LayoutFriendlyURL[] findByUuid_C_PrevAndNext( 478 long layoutFriendlyURLId, java.lang.String uuid, long companyId, 479 OrderByComparator<LayoutFriendlyURL> orderByComparator) 480 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 481 return getPersistence() 482 .findByUuid_C_PrevAndNext(layoutFriendlyURLId, uuid, 483 companyId, orderByComparator); 484 } 485 486 /** 487 * Removes all the layout friendly u r ls 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 layout friendly u r ls where uuid = ? and companyId = ?. 498 * 499 * @param uuid the uuid 500 * @param companyId the company ID 501 * @return the number of matching layout friendly u r ls 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 layout friendly u r ls where groupId = ?. 509 * 510 * @param groupId the group ID 511 * @return the matching layout friendly u r ls 512 */ 513 public static List<LayoutFriendlyURL> findByGroupId(long groupId) { 514 return getPersistence().findByGroupId(groupId); 515 } 516 517 /** 518 * Returns a range of all the layout friendly u r ls 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 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. 522 * </p> 523 * 524 * @param groupId the group ID 525 * @param start the lower bound of the range of layout friendly u r ls 526 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 527 * @return the range of matching layout friendly u r ls 528 */ 529 public static List<LayoutFriendlyURL> findByGroupId(long groupId, 530 int start, int end) { 531 return getPersistence().findByGroupId(groupId, start, end); 532 } 533 534 /** 535 * Returns an ordered range of all the layout friendly u r ls 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 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. 539 * </p> 540 * 541 * @param groupId the group ID 542 * @param start the lower bound of the range of layout friendly u r ls 543 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 544 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 545 * @return the ordered range of matching layout friendly u r ls 546 */ 547 public static List<LayoutFriendlyURL> findByGroupId(long groupId, 548 int start, int end, 549 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 550 return getPersistence() 551 .findByGroupId(groupId, start, end, orderByComparator); 552 } 553 554 /** 555 * Returns an ordered range of all the layout friendly u r ls where groupId = ?. 556 * 557 * <p> 558 * 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. 559 * </p> 560 * 561 * @param groupId the group ID 562 * @param start the lower bound of the range of layout friendly u r ls 563 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 564 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 565 * @param retrieveFromCache whether to retrieve from the finder cache 566 * @return the ordered range of matching layout friendly u r ls 567 */ 568 public static List<LayoutFriendlyURL> findByGroupId(long groupId, 569 int start, int end, 570 OrderByComparator<LayoutFriendlyURL> orderByComparator, 571 boolean retrieveFromCache) { 572 return getPersistence() 573 .findByGroupId(groupId, start, end, orderByComparator, 574 retrieveFromCache); 575 } 576 577 /** 578 * Returns the first layout friendly u r l in the ordered set where groupId = ?. 579 * 580 * @param groupId the group ID 581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 582 * @return the first matching layout friendly u r l 583 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 584 */ 585 public static LayoutFriendlyURL findByGroupId_First(long groupId, 586 OrderByComparator<LayoutFriendlyURL> orderByComparator) 587 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 588 return getPersistence().findByGroupId_First(groupId, orderByComparator); 589 } 590 591 /** 592 * Returns the first layout friendly u r l in the ordered set where groupId = ?. 593 * 594 * @param groupId the group ID 595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 596 * @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 597 */ 598 public static LayoutFriendlyURL fetchByGroupId_First(long groupId, 599 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 600 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 601 } 602 603 /** 604 * Returns the last layout friendly u r l in the ordered set where groupId = ?. 605 * 606 * @param groupId the group ID 607 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 608 * @return the last matching layout friendly u r l 609 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 610 */ 611 public static LayoutFriendlyURL findByGroupId_Last(long groupId, 612 OrderByComparator<LayoutFriendlyURL> orderByComparator) 613 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 614 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 615 } 616 617 /** 618 * Returns the last layout friendly u r l in the ordered set where groupId = ?. 619 * 620 * @param groupId the group ID 621 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 622 * @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 623 */ 624 public static LayoutFriendlyURL fetchByGroupId_Last(long groupId, 625 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 626 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 627 } 628 629 /** 630 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where groupId = ?. 631 * 632 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 633 * @param groupId the group ID 634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 635 * @return the previous, current, and next layout friendly u r l 636 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 637 */ 638 public static LayoutFriendlyURL[] findByGroupId_PrevAndNext( 639 long layoutFriendlyURLId, long groupId, 640 OrderByComparator<LayoutFriendlyURL> orderByComparator) 641 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 642 return getPersistence() 643 .findByGroupId_PrevAndNext(layoutFriendlyURLId, groupId, 644 orderByComparator); 645 } 646 647 /** 648 * Removes all the layout friendly u r ls where groupId = ? from the database. 649 * 650 * @param groupId the group ID 651 */ 652 public static void removeByGroupId(long groupId) { 653 getPersistence().removeByGroupId(groupId); 654 } 655 656 /** 657 * Returns the number of layout friendly u r ls where groupId = ?. 658 * 659 * @param groupId the group ID 660 * @return the number of matching layout friendly u r ls 661 */ 662 public static int countByGroupId(long groupId) { 663 return getPersistence().countByGroupId(groupId); 664 } 665 666 /** 667 * Returns all the layout friendly u r ls where companyId = ?. 668 * 669 * @param companyId the company ID 670 * @return the matching layout friendly u r ls 671 */ 672 public static List<LayoutFriendlyURL> findByCompanyId(long companyId) { 673 return getPersistence().findByCompanyId(companyId); 674 } 675 676 /** 677 * Returns a range of all the layout friendly u r ls where companyId = ?. 678 * 679 * <p> 680 * 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. 681 * </p> 682 * 683 * @param companyId the company ID 684 * @param start the lower bound of the range of layout friendly u r ls 685 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 686 * @return the range of matching layout friendly u r ls 687 */ 688 public static List<LayoutFriendlyURL> findByCompanyId(long companyId, 689 int start, int end) { 690 return getPersistence().findByCompanyId(companyId, start, end); 691 } 692 693 /** 694 * Returns an ordered range of all the layout friendly u r ls where companyId = ?. 695 * 696 * <p> 697 * 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. 698 * </p> 699 * 700 * @param companyId the company ID 701 * @param start the lower bound of the range of layout friendly u r ls 702 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 703 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 704 * @return the ordered range of matching layout friendly u r ls 705 */ 706 public static List<LayoutFriendlyURL> findByCompanyId(long companyId, 707 int start, int end, 708 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 709 return getPersistence() 710 .findByCompanyId(companyId, start, end, orderByComparator); 711 } 712 713 /** 714 * Returns an ordered range of all the layout friendly u r ls where companyId = ?. 715 * 716 * <p> 717 * 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. 718 * </p> 719 * 720 * @param companyId the company ID 721 * @param start the lower bound of the range of layout friendly u r ls 722 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 723 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 724 * @param retrieveFromCache whether to retrieve from the finder cache 725 * @return the ordered range of matching layout friendly u r ls 726 */ 727 public static List<LayoutFriendlyURL> findByCompanyId(long companyId, 728 int start, int end, 729 OrderByComparator<LayoutFriendlyURL> orderByComparator, 730 boolean retrieveFromCache) { 731 return getPersistence() 732 .findByCompanyId(companyId, start, end, orderByComparator, 733 retrieveFromCache); 734 } 735 736 /** 737 * Returns the first layout friendly u r l in the ordered set where companyId = ?. 738 * 739 * @param companyId the company ID 740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 741 * @return the first matching layout friendly u r l 742 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 743 */ 744 public static LayoutFriendlyURL findByCompanyId_First(long companyId, 745 OrderByComparator<LayoutFriendlyURL> orderByComparator) 746 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 747 return getPersistence() 748 .findByCompanyId_First(companyId, orderByComparator); 749 } 750 751 /** 752 * Returns the first layout friendly u r l in the ordered set where companyId = ?. 753 * 754 * @param companyId the company ID 755 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 756 * @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 757 */ 758 public static LayoutFriendlyURL fetchByCompanyId_First(long companyId, 759 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 760 return getPersistence() 761 .fetchByCompanyId_First(companyId, orderByComparator); 762 } 763 764 /** 765 * Returns the last layout friendly u r l in the ordered set where companyId = ?. 766 * 767 * @param companyId the company ID 768 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 769 * @return the last matching layout friendly u r l 770 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 771 */ 772 public static LayoutFriendlyURL findByCompanyId_Last(long companyId, 773 OrderByComparator<LayoutFriendlyURL> orderByComparator) 774 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 775 return getPersistence() 776 .findByCompanyId_Last(companyId, orderByComparator); 777 } 778 779 /** 780 * Returns the last layout friendly u r l in the ordered set where companyId = ?. 781 * 782 * @param companyId the company ID 783 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 784 * @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 785 */ 786 public static LayoutFriendlyURL fetchByCompanyId_Last(long companyId, 787 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 788 return getPersistence() 789 .fetchByCompanyId_Last(companyId, orderByComparator); 790 } 791 792 /** 793 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where companyId = ?. 794 * 795 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 796 * @param companyId the company ID 797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 798 * @return the previous, current, and next layout friendly u r l 799 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 800 */ 801 public static LayoutFriendlyURL[] findByCompanyId_PrevAndNext( 802 long layoutFriendlyURLId, long companyId, 803 OrderByComparator<LayoutFriendlyURL> orderByComparator) 804 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 805 return getPersistence() 806 .findByCompanyId_PrevAndNext(layoutFriendlyURLId, companyId, 807 orderByComparator); 808 } 809 810 /** 811 * Removes all the layout friendly u r ls where companyId = ? from the database. 812 * 813 * @param companyId the company ID 814 */ 815 public static void removeByCompanyId(long companyId) { 816 getPersistence().removeByCompanyId(companyId); 817 } 818 819 /** 820 * Returns the number of layout friendly u r ls where companyId = ?. 821 * 822 * @param companyId the company ID 823 * @return the number of matching layout friendly u r ls 824 */ 825 public static int countByCompanyId(long companyId) { 826 return getPersistence().countByCompanyId(companyId); 827 } 828 829 /** 830 * Returns all the layout friendly u r ls where plid = ?. 831 * 832 * @param plid the plid 833 * @return the matching layout friendly u r ls 834 */ 835 public static List<LayoutFriendlyURL> findByPlid(long plid) { 836 return getPersistence().findByPlid(plid); 837 } 838 839 /** 840 * Returns a range of all the layout friendly u r ls where plid = ?. 841 * 842 * <p> 843 * 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. 844 * </p> 845 * 846 * @param plid the plid 847 * @param start the lower bound of the range of layout friendly u r ls 848 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 849 * @return the range of matching layout friendly u r ls 850 */ 851 public static List<LayoutFriendlyURL> findByPlid(long plid, int start, 852 int end) { 853 return getPersistence().findByPlid(plid, start, end); 854 } 855 856 /** 857 * Returns an ordered range of all the layout friendly u r ls where plid = ?. 858 * 859 * <p> 860 * 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. 861 * </p> 862 * 863 * @param plid the plid 864 * @param start the lower bound of the range of layout friendly u r ls 865 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 866 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 867 * @return the ordered range of matching layout friendly u r ls 868 */ 869 public static List<LayoutFriendlyURL> findByPlid(long plid, int start, 870 int end, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 871 return getPersistence().findByPlid(plid, start, end, orderByComparator); 872 } 873 874 /** 875 * Returns an ordered range of all the layout friendly u r ls where plid = ?. 876 * 877 * <p> 878 * 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. 879 * </p> 880 * 881 * @param plid the plid 882 * @param start the lower bound of the range of layout friendly u r ls 883 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 884 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 885 * @param retrieveFromCache whether to retrieve from the finder cache 886 * @return the ordered range of matching layout friendly u r ls 887 */ 888 public static List<LayoutFriendlyURL> findByPlid(long plid, int start, 889 int end, OrderByComparator<LayoutFriendlyURL> orderByComparator, 890 boolean retrieveFromCache) { 891 return getPersistence() 892 .findByPlid(plid, start, end, orderByComparator, 893 retrieveFromCache); 894 } 895 896 /** 897 * Returns the first layout friendly u r l in the ordered set where plid = ?. 898 * 899 * @param plid the plid 900 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 901 * @return the first matching layout friendly u r l 902 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 903 */ 904 public static LayoutFriendlyURL findByPlid_First(long plid, 905 OrderByComparator<LayoutFriendlyURL> orderByComparator) 906 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 907 return getPersistence().findByPlid_First(plid, orderByComparator); 908 } 909 910 /** 911 * Returns the first layout friendly u r l in the ordered set where plid = ?. 912 * 913 * @param plid the plid 914 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 915 * @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 916 */ 917 public static LayoutFriendlyURL fetchByPlid_First(long plid, 918 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 919 return getPersistence().fetchByPlid_First(plid, orderByComparator); 920 } 921 922 /** 923 * Returns the last layout friendly u r l in the ordered set where plid = ?. 924 * 925 * @param plid the plid 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the last 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 findByPlid_Last(long plid, 931 OrderByComparator<LayoutFriendlyURL> orderByComparator) 932 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 933 return getPersistence().findByPlid_Last(plid, orderByComparator); 934 } 935 936 /** 937 * Returns the last layout friendly u r l in the ordered set where plid = ?. 938 * 939 * @param plid the plid 940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 941 * @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 942 */ 943 public static LayoutFriendlyURL fetchByPlid_Last(long plid, 944 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 945 return getPersistence().fetchByPlid_Last(plid, orderByComparator); 946 } 947 948 /** 949 * Returns the layout friendly u r ls before and after the current layout friendly u r l in the ordered set where plid = ?. 950 * 951 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 952 * @param plid the plid 953 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 954 * @return the previous, current, and next layout friendly u r l 955 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 956 */ 957 public static LayoutFriendlyURL[] findByPlid_PrevAndNext( 958 long layoutFriendlyURLId, long plid, 959 OrderByComparator<LayoutFriendlyURL> orderByComparator) 960 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 961 return getPersistence() 962 .findByPlid_PrevAndNext(layoutFriendlyURLId, plid, 963 orderByComparator); 964 } 965 966 /** 967 * Removes all the layout friendly u r ls where plid = ? from the database. 968 * 969 * @param plid the plid 970 */ 971 public static void removeByPlid(long plid) { 972 getPersistence().removeByPlid(plid); 973 } 974 975 /** 976 * Returns the number of layout friendly u r ls where plid = ?. 977 * 978 * @param plid the plid 979 * @return the number of matching layout friendly u r ls 980 */ 981 public static int countByPlid(long plid) { 982 return getPersistence().countByPlid(plid); 983 } 984 985 /** 986 * Returns all the layout friendly u r ls where plid = ? and friendlyURL = ?. 987 * 988 * @param plid the plid 989 * @param friendlyURL the friendly u r l 990 * @return the matching layout friendly u r ls 991 */ 992 public static List<LayoutFriendlyURL> findByP_F(long plid, 993 java.lang.String friendlyURL) { 994 return getPersistence().findByP_F(plid, friendlyURL); 995 } 996 997 /** 998 * Returns a range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 999 * 1000 * <p> 1001 * 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. 1002 * </p> 1003 * 1004 * @param plid the plid 1005 * @param friendlyURL the friendly u r l 1006 * @param start the lower bound of the range of layout friendly u r ls 1007 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1008 * @return the range of matching layout friendly u r ls 1009 */ 1010 public static List<LayoutFriendlyURL> findByP_F(long plid, 1011 java.lang.String friendlyURL, int start, int end) { 1012 return getPersistence().findByP_F(plid, friendlyURL, start, end); 1013 } 1014 1015 /** 1016 * Returns an ordered range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 1017 * 1018 * <p> 1019 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1020 * </p> 1021 * 1022 * @param plid the plid 1023 * @param friendlyURL the friendly u r l 1024 * @param start the lower bound of the range of layout friendly u r ls 1025 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1026 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1027 * @return the ordered range of matching layout friendly u r ls 1028 */ 1029 public static List<LayoutFriendlyURL> findByP_F(long plid, 1030 java.lang.String friendlyURL, int start, int end, 1031 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1032 return getPersistence() 1033 .findByP_F(plid, friendlyURL, start, end, orderByComparator); 1034 } 1035 1036 /** 1037 * Returns an ordered range of all the layout friendly u r ls where plid = ? and friendlyURL = ?. 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 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. 1041 * </p> 1042 * 1043 * @param plid the plid 1044 * @param friendlyURL the friendly u r l 1045 * @param start the lower bound of the range of layout friendly u r ls 1046 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1047 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1048 * @param retrieveFromCache whether to retrieve from the finder cache 1049 * @return the ordered range of matching layout friendly u r ls 1050 */ 1051 public static List<LayoutFriendlyURL> findByP_F(long plid, 1052 java.lang.String friendlyURL, int start, int end, 1053 OrderByComparator<LayoutFriendlyURL> orderByComparator, 1054 boolean retrieveFromCache) { 1055 return getPersistence() 1056 .findByP_F(plid, friendlyURL, start, end, orderByComparator, 1057 retrieveFromCache); 1058 } 1059 1060 /** 1061 * Returns the first layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 1062 * 1063 * @param plid the plid 1064 * @param friendlyURL the friendly u r l 1065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1066 * @return the first matching layout friendly u r l 1067 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1068 */ 1069 public static LayoutFriendlyURL findByP_F_First(long plid, 1070 java.lang.String friendlyURL, 1071 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1072 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1073 return getPersistence() 1074 .findByP_F_First(plid, friendlyURL, orderByComparator); 1075 } 1076 1077 /** 1078 * Returns the first layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 1079 * 1080 * @param plid the plid 1081 * @param friendlyURL the friendly u r l 1082 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1083 * @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 1084 */ 1085 public static LayoutFriendlyURL fetchByP_F_First(long plid, 1086 java.lang.String friendlyURL, 1087 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1088 return getPersistence() 1089 .fetchByP_F_First(plid, friendlyURL, orderByComparator); 1090 } 1091 1092 /** 1093 * Returns the last layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 1094 * 1095 * @param plid the plid 1096 * @param friendlyURL the friendly u r l 1097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1098 * @return the last matching layout friendly u r l 1099 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1100 */ 1101 public static LayoutFriendlyURL findByP_F_Last(long plid, 1102 java.lang.String friendlyURL, 1103 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1104 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1105 return getPersistence() 1106 .findByP_F_Last(plid, friendlyURL, orderByComparator); 1107 } 1108 1109 /** 1110 * Returns the last layout friendly u r l in the ordered set where plid = ? and friendlyURL = ?. 1111 * 1112 * @param plid the plid 1113 * @param friendlyURL the friendly u r l 1114 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1115 * @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 1116 */ 1117 public static LayoutFriendlyURL fetchByP_F_Last(long plid, 1118 java.lang.String friendlyURL, 1119 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1120 return getPersistence() 1121 .fetchByP_F_Last(plid, friendlyURL, orderByComparator); 1122 } 1123 1124 /** 1125 * 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 = ?. 1126 * 1127 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 1128 * @param plid the plid 1129 * @param friendlyURL the friendly u r l 1130 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1131 * @return the previous, current, and next layout friendly u r l 1132 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1133 */ 1134 public static LayoutFriendlyURL[] findByP_F_PrevAndNext( 1135 long layoutFriendlyURLId, long plid, java.lang.String friendlyURL, 1136 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1137 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1138 return getPersistence() 1139 .findByP_F_PrevAndNext(layoutFriendlyURLId, plid, 1140 friendlyURL, orderByComparator); 1141 } 1142 1143 /** 1144 * Removes all the layout friendly u r ls where plid = ? and friendlyURL = ? from the database. 1145 * 1146 * @param plid the plid 1147 * @param friendlyURL the friendly u r l 1148 */ 1149 public static void removeByP_F(long plid, java.lang.String friendlyURL) { 1150 getPersistence().removeByP_F(plid, friendlyURL); 1151 } 1152 1153 /** 1154 * Returns the number of layout friendly u r ls where plid = ? and friendlyURL = ?. 1155 * 1156 * @param plid the plid 1157 * @param friendlyURL the friendly u r l 1158 * @return the number of matching layout friendly u r ls 1159 */ 1160 public static int countByP_F(long plid, java.lang.String friendlyURL) { 1161 return getPersistence().countByP_F(plid, friendlyURL); 1162 } 1163 1164 /** 1165 * Returns the layout friendly u r l where plid = ? and languageId = ? or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1166 * 1167 * @param plid the plid 1168 * @param languageId the language ID 1169 * @return the matching layout friendly u r l 1170 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1171 */ 1172 public static LayoutFriendlyURL findByP_L(long plid, 1173 java.lang.String languageId) 1174 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1175 return getPersistence().findByP_L(plid, languageId); 1176 } 1177 1178 /** 1179 * 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. 1180 * 1181 * @param plid the plid 1182 * @param languageId the language ID 1183 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1184 */ 1185 public static LayoutFriendlyURL fetchByP_L(long plid, 1186 java.lang.String languageId) { 1187 return getPersistence().fetchByP_L(plid, languageId); 1188 } 1189 1190 /** 1191 * 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. 1192 * 1193 * @param plid the plid 1194 * @param languageId the language ID 1195 * @param retrieveFromCache whether to retrieve from the finder cache 1196 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1197 */ 1198 public static LayoutFriendlyURL fetchByP_L(long plid, 1199 java.lang.String languageId, boolean retrieveFromCache) { 1200 return getPersistence().fetchByP_L(plid, languageId, retrieveFromCache); 1201 } 1202 1203 /** 1204 * Removes the layout friendly u r l where plid = ? and languageId = ? from the database. 1205 * 1206 * @param plid the plid 1207 * @param languageId the language ID 1208 * @return the layout friendly u r l that was removed 1209 */ 1210 public static LayoutFriendlyURL removeByP_L(long plid, 1211 java.lang.String languageId) 1212 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1213 return getPersistence().removeByP_L(plid, languageId); 1214 } 1215 1216 /** 1217 * Returns the number of layout friendly u r ls where plid = ? and languageId = ?. 1218 * 1219 * @param plid the plid 1220 * @param languageId the language ID 1221 * @return the number of matching layout friendly u r ls 1222 */ 1223 public static int countByP_L(long plid, java.lang.String languageId) { 1224 return getPersistence().countByP_L(plid, languageId); 1225 } 1226 1227 /** 1228 * Returns all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1229 * 1230 * @param groupId the group ID 1231 * @param privateLayout the private layout 1232 * @param friendlyURL the friendly u r l 1233 * @return the matching layout friendly u r ls 1234 */ 1235 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1236 boolean privateLayout, java.lang.String friendlyURL) { 1237 return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL); 1238 } 1239 1240 /** 1241 * Returns a range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1242 * 1243 * <p> 1244 * 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. 1245 * </p> 1246 * 1247 * @param groupId the group ID 1248 * @param privateLayout the private layout 1249 * @param friendlyURL the friendly u r l 1250 * @param start the lower bound of the range of layout friendly u r ls 1251 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1252 * @return the range of matching layout friendly u r ls 1253 */ 1254 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1255 boolean privateLayout, java.lang.String friendlyURL, int start, int end) { 1256 return getPersistence() 1257 .findByG_P_F(groupId, privateLayout, friendlyURL, start, end); 1258 } 1259 1260 /** 1261 * Returns an ordered range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1262 * 1263 * <p> 1264 * 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. 1265 * </p> 1266 * 1267 * @param groupId the group ID 1268 * @param privateLayout the private layout 1269 * @param friendlyURL the friendly u r l 1270 * @param start the lower bound of the range of layout friendly u r ls 1271 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1272 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1273 * @return the ordered range of matching layout friendly u r ls 1274 */ 1275 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1276 boolean privateLayout, java.lang.String friendlyURL, int start, 1277 int end, OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1278 return getPersistence() 1279 .findByG_P_F(groupId, privateLayout, friendlyURL, start, 1280 end, orderByComparator); 1281 } 1282 1283 /** 1284 * Returns an ordered range of all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1285 * 1286 * <p> 1287 * 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. 1288 * </p> 1289 * 1290 * @param groupId the group ID 1291 * @param privateLayout the private layout 1292 * @param friendlyURL the friendly u r l 1293 * @param start the lower bound of the range of layout friendly u r ls 1294 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1295 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1296 * @param retrieveFromCache whether to retrieve from the finder cache 1297 * @return the ordered range of matching layout friendly u r ls 1298 */ 1299 public static List<LayoutFriendlyURL> findByG_P_F(long groupId, 1300 boolean privateLayout, java.lang.String friendlyURL, int start, 1301 int end, OrderByComparator<LayoutFriendlyURL> orderByComparator, 1302 boolean retrieveFromCache) { 1303 return getPersistence() 1304 .findByG_P_F(groupId, privateLayout, friendlyURL, start, 1305 end, orderByComparator, retrieveFromCache); 1306 } 1307 1308 /** 1309 * Returns the first layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1310 * 1311 * @param groupId the group ID 1312 * @param privateLayout the private layout 1313 * @param friendlyURL the friendly u r l 1314 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1315 * @return the first matching layout friendly u r l 1316 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1317 */ 1318 public static LayoutFriendlyURL findByG_P_F_First(long groupId, 1319 boolean privateLayout, java.lang.String friendlyURL, 1320 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1321 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1322 return getPersistence() 1323 .findByG_P_F_First(groupId, privateLayout, friendlyURL, 1324 orderByComparator); 1325 } 1326 1327 /** 1328 * Returns the first layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1329 * 1330 * @param groupId the group ID 1331 * @param privateLayout the private layout 1332 * @param friendlyURL the friendly u r l 1333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1334 * @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 1335 */ 1336 public static LayoutFriendlyURL fetchByG_P_F_First(long groupId, 1337 boolean privateLayout, java.lang.String friendlyURL, 1338 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1339 return getPersistence() 1340 .fetchByG_P_F_First(groupId, privateLayout, friendlyURL, 1341 orderByComparator); 1342 } 1343 1344 /** 1345 * Returns the last layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1346 * 1347 * @param groupId the group ID 1348 * @param privateLayout the private layout 1349 * @param friendlyURL the friendly u r l 1350 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1351 * @return the last matching layout friendly u r l 1352 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1353 */ 1354 public static LayoutFriendlyURL findByG_P_F_Last(long groupId, 1355 boolean privateLayout, java.lang.String friendlyURL, 1356 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1357 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1358 return getPersistence() 1359 .findByG_P_F_Last(groupId, privateLayout, friendlyURL, 1360 orderByComparator); 1361 } 1362 1363 /** 1364 * Returns the last layout friendly u r l in the ordered set where groupId = ? and privateLayout = ? and friendlyURL = ?. 1365 * 1366 * @param groupId the group ID 1367 * @param privateLayout the private layout 1368 * @param friendlyURL the friendly u r l 1369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1370 * @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 1371 */ 1372 public static LayoutFriendlyURL fetchByG_P_F_Last(long groupId, 1373 boolean privateLayout, java.lang.String friendlyURL, 1374 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1375 return getPersistence() 1376 .fetchByG_P_F_Last(groupId, privateLayout, friendlyURL, 1377 orderByComparator); 1378 } 1379 1380 /** 1381 * 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 = ?. 1382 * 1383 * @param layoutFriendlyURLId the primary key of the current layout friendly u r l 1384 * @param groupId the group ID 1385 * @param privateLayout the private layout 1386 * @param friendlyURL the friendly u r l 1387 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1388 * @return the previous, current, and next layout friendly u r l 1389 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1390 */ 1391 public static LayoutFriendlyURL[] findByG_P_F_PrevAndNext( 1392 long layoutFriendlyURLId, long groupId, boolean privateLayout, 1393 java.lang.String friendlyURL, 1394 OrderByComparator<LayoutFriendlyURL> orderByComparator) 1395 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1396 return getPersistence() 1397 .findByG_P_F_PrevAndNext(layoutFriendlyURLId, groupId, 1398 privateLayout, friendlyURL, orderByComparator); 1399 } 1400 1401 /** 1402 * Removes all the layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ? from the database. 1403 * 1404 * @param groupId the group ID 1405 * @param privateLayout the private layout 1406 * @param friendlyURL the friendly u r l 1407 */ 1408 public static void removeByG_P_F(long groupId, boolean privateLayout, 1409 java.lang.String friendlyURL) { 1410 getPersistence().removeByG_P_F(groupId, privateLayout, friendlyURL); 1411 } 1412 1413 /** 1414 * Returns the number of layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ?. 1415 * 1416 * @param groupId the group ID 1417 * @param privateLayout the private layout 1418 * @param friendlyURL the friendly u r l 1419 * @return the number of matching layout friendly u r ls 1420 */ 1421 public static int countByG_P_F(long groupId, boolean privateLayout, 1422 java.lang.String friendlyURL) { 1423 return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL); 1424 } 1425 1426 /** 1427 * 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. 1428 * 1429 * @param groupId the group ID 1430 * @param privateLayout the private layout 1431 * @param friendlyURL the friendly u r l 1432 * @param languageId the language ID 1433 * @return the matching layout friendly u r l 1434 * @throws NoSuchLayoutFriendlyURLException if a matching layout friendly u r l could not be found 1435 */ 1436 public static LayoutFriendlyURL findByG_P_F_L(long groupId, 1437 boolean privateLayout, java.lang.String friendlyURL, 1438 java.lang.String languageId) 1439 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1440 return getPersistence() 1441 .findByG_P_F_L(groupId, privateLayout, friendlyURL, 1442 languageId); 1443 } 1444 1445 /** 1446 * 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. 1447 * 1448 * @param groupId the group ID 1449 * @param privateLayout the private layout 1450 * @param friendlyURL the friendly u r l 1451 * @param languageId the language ID 1452 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1453 */ 1454 public static LayoutFriendlyURL fetchByG_P_F_L(long groupId, 1455 boolean privateLayout, java.lang.String friendlyURL, 1456 java.lang.String languageId) { 1457 return getPersistence() 1458 .fetchByG_P_F_L(groupId, privateLayout, friendlyURL, 1459 languageId); 1460 } 1461 1462 /** 1463 * 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. 1464 * 1465 * @param groupId the group ID 1466 * @param privateLayout the private layout 1467 * @param friendlyURL the friendly u r l 1468 * @param languageId the language ID 1469 * @param retrieveFromCache whether to retrieve from the finder cache 1470 * @return the matching layout friendly u r l, or <code>null</code> if a matching layout friendly u r l could not be found 1471 */ 1472 public static LayoutFriendlyURL fetchByG_P_F_L(long groupId, 1473 boolean privateLayout, java.lang.String friendlyURL, 1474 java.lang.String languageId, boolean retrieveFromCache) { 1475 return getPersistence() 1476 .fetchByG_P_F_L(groupId, privateLayout, friendlyURL, 1477 languageId, retrieveFromCache); 1478 } 1479 1480 /** 1481 * Removes the layout friendly u r l where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ? from the database. 1482 * 1483 * @param groupId the group ID 1484 * @param privateLayout the private layout 1485 * @param friendlyURL the friendly u r l 1486 * @param languageId the language ID 1487 * @return the layout friendly u r l that was removed 1488 */ 1489 public static LayoutFriendlyURL removeByG_P_F_L(long groupId, 1490 boolean privateLayout, java.lang.String friendlyURL, 1491 java.lang.String languageId) 1492 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1493 return getPersistence() 1494 .removeByG_P_F_L(groupId, privateLayout, friendlyURL, 1495 languageId); 1496 } 1497 1498 /** 1499 * Returns the number of layout friendly u r ls where groupId = ? and privateLayout = ? and friendlyURL = ? and languageId = ?. 1500 * 1501 * @param groupId the group ID 1502 * @param privateLayout the private layout 1503 * @param friendlyURL the friendly u r l 1504 * @param languageId the language ID 1505 * @return the number of matching layout friendly u r ls 1506 */ 1507 public static int countByG_P_F_L(long groupId, boolean privateLayout, 1508 java.lang.String friendlyURL, java.lang.String languageId) { 1509 return getPersistence() 1510 .countByG_P_F_L(groupId, privateLayout, friendlyURL, 1511 languageId); 1512 } 1513 1514 /** 1515 * Caches the layout friendly u r l in the entity cache if it is enabled. 1516 * 1517 * @param layoutFriendlyURL the layout friendly u r l 1518 */ 1519 public static void cacheResult(LayoutFriendlyURL layoutFriendlyURL) { 1520 getPersistence().cacheResult(layoutFriendlyURL); 1521 } 1522 1523 /** 1524 * Caches the layout friendly u r ls in the entity cache if it is enabled. 1525 * 1526 * @param layoutFriendlyURLs the layout friendly u r ls 1527 */ 1528 public static void cacheResult(List<LayoutFriendlyURL> layoutFriendlyURLs) { 1529 getPersistence().cacheResult(layoutFriendlyURLs); 1530 } 1531 1532 /** 1533 * Creates a new layout friendly u r l with the primary key. Does not add the layout friendly u r l to the database. 1534 * 1535 * @param layoutFriendlyURLId the primary key for the new layout friendly u r l 1536 * @return the new layout friendly u r l 1537 */ 1538 public static LayoutFriendlyURL create(long layoutFriendlyURLId) { 1539 return getPersistence().create(layoutFriendlyURLId); 1540 } 1541 1542 /** 1543 * Removes the layout friendly u r l with the primary key from the database. Also notifies the appropriate model listeners. 1544 * 1545 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1546 * @return the layout friendly u r l that was removed 1547 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1548 */ 1549 public static LayoutFriendlyURL remove(long layoutFriendlyURLId) 1550 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1551 return getPersistence().remove(layoutFriendlyURLId); 1552 } 1553 1554 public static LayoutFriendlyURL updateImpl( 1555 LayoutFriendlyURL layoutFriendlyURL) { 1556 return getPersistence().updateImpl(layoutFriendlyURL); 1557 } 1558 1559 /** 1560 * Returns the layout friendly u r l with the primary key or throws a {@link NoSuchLayoutFriendlyURLException} if it could not be found. 1561 * 1562 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1563 * @return the layout friendly u r l 1564 * @throws NoSuchLayoutFriendlyURLException if a layout friendly u r l with the primary key could not be found 1565 */ 1566 public static LayoutFriendlyURL findByPrimaryKey(long layoutFriendlyURLId) 1567 throws com.liferay.portal.exception.NoSuchLayoutFriendlyURLException { 1568 return getPersistence().findByPrimaryKey(layoutFriendlyURLId); 1569 } 1570 1571 /** 1572 * Returns the layout friendly u r l with the primary key or returns <code>null</code> if it could not be found. 1573 * 1574 * @param layoutFriendlyURLId the primary key of the layout friendly u r l 1575 * @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 1576 */ 1577 public static LayoutFriendlyURL fetchByPrimaryKey(long layoutFriendlyURLId) { 1578 return getPersistence().fetchByPrimaryKey(layoutFriendlyURLId); 1579 } 1580 1581 public static java.util.Map<java.io.Serializable, LayoutFriendlyURL> fetchByPrimaryKeys( 1582 java.util.Set<java.io.Serializable> primaryKeys) { 1583 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1584 } 1585 1586 /** 1587 * Returns all the layout friendly u r ls. 1588 * 1589 * @return the layout friendly u r ls 1590 */ 1591 public static List<LayoutFriendlyURL> findAll() { 1592 return getPersistence().findAll(); 1593 } 1594 1595 /** 1596 * Returns a range of all the layout friendly u r ls. 1597 * 1598 * <p> 1599 * 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. 1600 * </p> 1601 * 1602 * @param start the lower bound of the range of layout friendly u r ls 1603 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1604 * @return the range of layout friendly u r ls 1605 */ 1606 public static List<LayoutFriendlyURL> findAll(int start, int end) { 1607 return getPersistence().findAll(start, end); 1608 } 1609 1610 /** 1611 * Returns an ordered range of all the layout friendly u r ls. 1612 * 1613 * <p> 1614 * 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. 1615 * </p> 1616 * 1617 * @param start the lower bound of the range of layout friendly u r ls 1618 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1619 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1620 * @return the ordered range of layout friendly u r ls 1621 */ 1622 public static List<LayoutFriendlyURL> findAll(int start, int end, 1623 OrderByComparator<LayoutFriendlyURL> orderByComparator) { 1624 return getPersistence().findAll(start, end, orderByComparator); 1625 } 1626 1627 /** 1628 * Returns an ordered range of all the layout friendly u r ls. 1629 * 1630 * <p> 1631 * 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. 1632 * </p> 1633 * 1634 * @param start the lower bound of the range of layout friendly u r ls 1635 * @param end the upper bound of the range of layout friendly u r ls (not inclusive) 1636 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1637 * @param retrieveFromCache whether to retrieve from the finder cache 1638 * @return the ordered range of layout friendly u r ls 1639 */ 1640 public static List<LayoutFriendlyURL> findAll(int start, int end, 1641 OrderByComparator<LayoutFriendlyURL> orderByComparator, 1642 boolean retrieveFromCache) { 1643 return getPersistence() 1644 .findAll(start, end, orderByComparator, retrieveFromCache); 1645 } 1646 1647 /** 1648 * Removes all the layout friendly u r ls from the database. 1649 */ 1650 public static void removeAll() { 1651 getPersistence().removeAll(); 1652 } 1653 1654 /** 1655 * Returns the number of layout friendly u r ls. 1656 * 1657 * @return the number of layout friendly u r ls 1658 */ 1659 public static int countAll() { 1660 return getPersistence().countAll(); 1661 } 1662 1663 public static java.util.Set<java.lang.String> getBadColumnNames() { 1664 return getPersistence().getBadColumnNames(); 1665 } 1666 1667 public static LayoutFriendlyURLPersistence getPersistence() { 1668 if (_persistence == null) { 1669 _persistence = (LayoutFriendlyURLPersistence)PortalBeanLocatorUtil.locate(LayoutFriendlyURLPersistence.class.getName()); 1670 1671 ReferenceRegistry.registerReference(LayoutFriendlyURLUtil.class, 1672 "_persistence"); 1673 } 1674 1675 return _persistence; 1676 } 1677 1678 private static LayoutFriendlyURLPersistence _persistence; 1679 }