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.LayoutRevision; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the layout revision service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutRevisionPersistenceImpl} 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 LayoutRevisionPersistence 037 * @see com.liferay.portal.service.persistence.impl.LayoutRevisionPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class LayoutRevisionUtil { 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(LayoutRevision layoutRevision) { 059 getPersistence().clearCache(layoutRevision); 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<LayoutRevision> 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<LayoutRevision> 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<LayoutRevision> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<LayoutRevision> 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 LayoutRevision update(LayoutRevision layoutRevision) { 100 return getPersistence().update(layoutRevision); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static LayoutRevision update(LayoutRevision layoutRevision, 107 ServiceContext serviceContext) { 108 return getPersistence().update(layoutRevision, serviceContext); 109 } 110 111 /** 112 * Returns all the layout revisions where layoutSetBranchId = ?. 113 * 114 * @param layoutSetBranchId the layout set branch ID 115 * @return the matching layout revisions 116 */ 117 public static List<LayoutRevision> findByLayoutSetBranchId( 118 long layoutSetBranchId) { 119 return getPersistence().findByLayoutSetBranchId(layoutSetBranchId); 120 } 121 122 /** 123 * Returns a range of all the layout revisions where layoutSetBranchId = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutRevisionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param layoutSetBranchId the layout set branch ID 130 * @param start the lower bound of the range of layout revisions 131 * @param end the upper bound of the range of layout revisions (not inclusive) 132 * @return the range of matching layout revisions 133 */ 134 public static List<LayoutRevision> findByLayoutSetBranchId( 135 long layoutSetBranchId, int start, int end) { 136 return getPersistence() 137 .findByLayoutSetBranchId(layoutSetBranchId, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ?. 142 * 143 * <p> 144 * 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 LayoutRevisionModelImpl}. 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. 145 * </p> 146 * 147 * @param layoutSetBranchId the layout set branch ID 148 * @param start the lower bound of the range of layout revisions 149 * @param end the upper bound of the range of layout revisions (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching layout revisions 152 */ 153 public static List<LayoutRevision> findByLayoutSetBranchId( 154 long layoutSetBranchId, int start, int end, 155 OrderByComparator<LayoutRevision> orderByComparator) { 156 return getPersistence() 157 .findByLayoutSetBranchId(layoutSetBranchId, start, end, 158 orderByComparator); 159 } 160 161 /** 162 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ?. 163 * 164 * <p> 165 * 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 LayoutRevisionModelImpl}. 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. 166 * </p> 167 * 168 * @param layoutSetBranchId the layout set branch ID 169 * @param start the lower bound of the range of layout revisions 170 * @param end the upper bound of the range of layout revisions (not inclusive) 171 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 172 * @param retrieveFromCache whether to retrieve from the finder cache 173 * @return the ordered range of matching layout revisions 174 */ 175 public static List<LayoutRevision> findByLayoutSetBranchId( 176 long layoutSetBranchId, int start, int end, 177 OrderByComparator<LayoutRevision> orderByComparator, 178 boolean retrieveFromCache) { 179 return getPersistence() 180 .findByLayoutSetBranchId(layoutSetBranchId, start, end, 181 orderByComparator, retrieveFromCache); 182 } 183 184 /** 185 * Returns the first layout revision in the ordered set where layoutSetBranchId = ?. 186 * 187 * @param layoutSetBranchId the layout set branch ID 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the first matching layout revision 190 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 191 */ 192 public static LayoutRevision findByLayoutSetBranchId_First( 193 long layoutSetBranchId, 194 OrderByComparator<LayoutRevision> orderByComparator) 195 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 196 return getPersistence() 197 .findByLayoutSetBranchId_First(layoutSetBranchId, 198 orderByComparator); 199 } 200 201 /** 202 * Returns the first layout revision in the ordered set where layoutSetBranchId = ?. 203 * 204 * @param layoutSetBranchId the layout set branch ID 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 207 */ 208 public static LayoutRevision fetchByLayoutSetBranchId_First( 209 long layoutSetBranchId, 210 OrderByComparator<LayoutRevision> orderByComparator) { 211 return getPersistence() 212 .fetchByLayoutSetBranchId_First(layoutSetBranchId, 213 orderByComparator); 214 } 215 216 /** 217 * Returns the last layout revision in the ordered set where layoutSetBranchId = ?. 218 * 219 * @param layoutSetBranchId the layout set branch ID 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching layout revision 222 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 223 */ 224 public static LayoutRevision findByLayoutSetBranchId_Last( 225 long layoutSetBranchId, 226 OrderByComparator<LayoutRevision> orderByComparator) 227 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 228 return getPersistence() 229 .findByLayoutSetBranchId_Last(layoutSetBranchId, 230 orderByComparator); 231 } 232 233 /** 234 * Returns the last layout revision in the ordered set where layoutSetBranchId = ?. 235 * 236 * @param layoutSetBranchId the layout set branch ID 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 239 */ 240 public static LayoutRevision fetchByLayoutSetBranchId_Last( 241 long layoutSetBranchId, 242 OrderByComparator<LayoutRevision> orderByComparator) { 243 return getPersistence() 244 .fetchByLayoutSetBranchId_Last(layoutSetBranchId, 245 orderByComparator); 246 } 247 248 /** 249 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ?. 250 * 251 * @param layoutRevisionId the primary key of the current layout revision 252 * @param layoutSetBranchId the layout set branch ID 253 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 254 * @return the previous, current, and next layout revision 255 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 256 */ 257 public static LayoutRevision[] findByLayoutSetBranchId_PrevAndNext( 258 long layoutRevisionId, long layoutSetBranchId, 259 OrderByComparator<LayoutRevision> orderByComparator) 260 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 261 return getPersistence() 262 .findByLayoutSetBranchId_PrevAndNext(layoutRevisionId, 263 layoutSetBranchId, orderByComparator); 264 } 265 266 /** 267 * Removes all the layout revisions where layoutSetBranchId = ? from the database. 268 * 269 * @param layoutSetBranchId the layout set branch ID 270 */ 271 public static void removeByLayoutSetBranchId(long layoutSetBranchId) { 272 getPersistence().removeByLayoutSetBranchId(layoutSetBranchId); 273 } 274 275 /** 276 * Returns the number of layout revisions where layoutSetBranchId = ?. 277 * 278 * @param layoutSetBranchId the layout set branch ID 279 * @return the number of matching layout revisions 280 */ 281 public static int countByLayoutSetBranchId(long layoutSetBranchId) { 282 return getPersistence().countByLayoutSetBranchId(layoutSetBranchId); 283 } 284 285 /** 286 * Returns all the layout revisions where plid = ?. 287 * 288 * @param plid the plid 289 * @return the matching layout revisions 290 */ 291 public static List<LayoutRevision> findByPlid(long plid) { 292 return getPersistence().findByPlid(plid); 293 } 294 295 /** 296 * Returns a range of all the layout revisions where plid = ?. 297 * 298 * <p> 299 * 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 LayoutRevisionModelImpl}. 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. 300 * </p> 301 * 302 * @param plid the plid 303 * @param start the lower bound of the range of layout revisions 304 * @param end the upper bound of the range of layout revisions (not inclusive) 305 * @return the range of matching layout revisions 306 */ 307 public static List<LayoutRevision> findByPlid(long plid, int start, int end) { 308 return getPersistence().findByPlid(plid, start, end); 309 } 310 311 /** 312 * Returns an ordered range of all the layout revisions where plid = ?. 313 * 314 * <p> 315 * 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 LayoutRevisionModelImpl}. 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. 316 * </p> 317 * 318 * @param plid the plid 319 * @param start the lower bound of the range of layout revisions 320 * @param end the upper bound of the range of layout revisions (not inclusive) 321 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 322 * @return the ordered range of matching layout revisions 323 */ 324 public static List<LayoutRevision> findByPlid(long plid, int start, 325 int end, OrderByComparator<LayoutRevision> orderByComparator) { 326 return getPersistence().findByPlid(plid, start, end, orderByComparator); 327 } 328 329 /** 330 * Returns an ordered range of all the layout revisions where plid = ?. 331 * 332 * <p> 333 * 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 LayoutRevisionModelImpl}. 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. 334 * </p> 335 * 336 * @param plid the plid 337 * @param start the lower bound of the range of layout revisions 338 * @param end the upper bound of the range of layout revisions (not inclusive) 339 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 340 * @param retrieveFromCache whether to retrieve from the finder cache 341 * @return the ordered range of matching layout revisions 342 */ 343 public static List<LayoutRevision> findByPlid(long plid, int start, 344 int end, OrderByComparator<LayoutRevision> orderByComparator, 345 boolean retrieveFromCache) { 346 return getPersistence() 347 .findByPlid(plid, start, end, orderByComparator, 348 retrieveFromCache); 349 } 350 351 /** 352 * Returns the first layout revision in the ordered set where plid = ?. 353 * 354 * @param plid the plid 355 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 356 * @return the first matching layout revision 357 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 358 */ 359 public static LayoutRevision findByPlid_First(long plid, 360 OrderByComparator<LayoutRevision> orderByComparator) 361 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 362 return getPersistence().findByPlid_First(plid, orderByComparator); 363 } 364 365 /** 366 * Returns the first layout revision in the ordered set where plid = ?. 367 * 368 * @param plid the plid 369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 370 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 371 */ 372 public static LayoutRevision fetchByPlid_First(long plid, 373 OrderByComparator<LayoutRevision> orderByComparator) { 374 return getPersistence().fetchByPlid_First(plid, orderByComparator); 375 } 376 377 /** 378 * Returns the last layout revision in the ordered set where plid = ?. 379 * 380 * @param plid the plid 381 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 382 * @return the last matching layout revision 383 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 384 */ 385 public static LayoutRevision findByPlid_Last(long plid, 386 OrderByComparator<LayoutRevision> orderByComparator) 387 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 388 return getPersistence().findByPlid_Last(plid, orderByComparator); 389 } 390 391 /** 392 * Returns the last layout revision in the ordered set where plid = ?. 393 * 394 * @param plid the plid 395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 396 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 397 */ 398 public static LayoutRevision fetchByPlid_Last(long plid, 399 OrderByComparator<LayoutRevision> orderByComparator) { 400 return getPersistence().fetchByPlid_Last(plid, orderByComparator); 401 } 402 403 /** 404 * Returns the layout revisions before and after the current layout revision in the ordered set where plid = ?. 405 * 406 * @param layoutRevisionId the primary key of the current layout revision 407 * @param plid the plid 408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 409 * @return the previous, current, and next layout revision 410 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 411 */ 412 public static LayoutRevision[] findByPlid_PrevAndNext( 413 long layoutRevisionId, long plid, 414 OrderByComparator<LayoutRevision> orderByComparator) 415 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 416 return getPersistence() 417 .findByPlid_PrevAndNext(layoutRevisionId, plid, 418 orderByComparator); 419 } 420 421 /** 422 * Removes all the layout revisions where plid = ? from the database. 423 * 424 * @param plid the plid 425 */ 426 public static void removeByPlid(long plid) { 427 getPersistence().removeByPlid(plid); 428 } 429 430 /** 431 * Returns the number of layout revisions where plid = ?. 432 * 433 * @param plid the plid 434 * @return the number of matching layout revisions 435 */ 436 public static int countByPlid(long plid) { 437 return getPersistence().countByPlid(plid); 438 } 439 440 /** 441 * Returns all the layout revisions where layoutSetBranchId = ? and head = ?. 442 * 443 * @param layoutSetBranchId the layout set branch ID 444 * @param head the head 445 * @return the matching layout revisions 446 */ 447 public static List<LayoutRevision> findByL_H(long layoutSetBranchId, 448 boolean head) { 449 return getPersistence().findByL_H(layoutSetBranchId, head); 450 } 451 452 /** 453 * Returns a range of all the layout revisions where layoutSetBranchId = ? and head = ?. 454 * 455 * <p> 456 * 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 LayoutRevisionModelImpl}. 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. 457 * </p> 458 * 459 * @param layoutSetBranchId the layout set branch ID 460 * @param head the head 461 * @param start the lower bound of the range of layout revisions 462 * @param end the upper bound of the range of layout revisions (not inclusive) 463 * @return the range of matching layout revisions 464 */ 465 public static List<LayoutRevision> findByL_H(long layoutSetBranchId, 466 boolean head, int start, int end) { 467 return getPersistence().findByL_H(layoutSetBranchId, head, start, end); 468 } 469 470 /** 471 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and head = ?. 472 * 473 * <p> 474 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutRevisionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 475 * </p> 476 * 477 * @param layoutSetBranchId the layout set branch ID 478 * @param head the head 479 * @param start the lower bound of the range of layout revisions 480 * @param end the upper bound of the range of layout revisions (not inclusive) 481 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 482 * @return the ordered range of matching layout revisions 483 */ 484 public static List<LayoutRevision> findByL_H(long layoutSetBranchId, 485 boolean head, int start, int end, 486 OrderByComparator<LayoutRevision> orderByComparator) { 487 return getPersistence() 488 .findByL_H(layoutSetBranchId, head, start, end, 489 orderByComparator); 490 } 491 492 /** 493 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and head = ?. 494 * 495 * <p> 496 * 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 LayoutRevisionModelImpl}. 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. 497 * </p> 498 * 499 * @param layoutSetBranchId the layout set branch ID 500 * @param head the head 501 * @param start the lower bound of the range of layout revisions 502 * @param end the upper bound of the range of layout revisions (not inclusive) 503 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 504 * @param retrieveFromCache whether to retrieve from the finder cache 505 * @return the ordered range of matching layout revisions 506 */ 507 public static List<LayoutRevision> findByL_H(long layoutSetBranchId, 508 boolean head, int start, int end, 509 OrderByComparator<LayoutRevision> orderByComparator, 510 boolean retrieveFromCache) { 511 return getPersistence() 512 .findByL_H(layoutSetBranchId, head, start, end, 513 orderByComparator, retrieveFromCache); 514 } 515 516 /** 517 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 518 * 519 * @param layoutSetBranchId the layout set branch ID 520 * @param head the head 521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 522 * @return the first matching layout revision 523 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 524 */ 525 public static LayoutRevision findByL_H_First(long layoutSetBranchId, 526 boolean head, OrderByComparator<LayoutRevision> orderByComparator) 527 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 528 return getPersistence() 529 .findByL_H_First(layoutSetBranchId, head, orderByComparator); 530 } 531 532 /** 533 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 534 * 535 * @param layoutSetBranchId the layout set branch ID 536 * @param head the head 537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 538 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 539 */ 540 public static LayoutRevision fetchByL_H_First(long layoutSetBranchId, 541 boolean head, OrderByComparator<LayoutRevision> orderByComparator) { 542 return getPersistence() 543 .fetchByL_H_First(layoutSetBranchId, head, orderByComparator); 544 } 545 546 /** 547 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 548 * 549 * @param layoutSetBranchId the layout set branch ID 550 * @param head the head 551 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 552 * @return the last matching layout revision 553 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 554 */ 555 public static LayoutRevision findByL_H_Last(long layoutSetBranchId, 556 boolean head, OrderByComparator<LayoutRevision> orderByComparator) 557 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 558 return getPersistence() 559 .findByL_H_Last(layoutSetBranchId, head, orderByComparator); 560 } 561 562 /** 563 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 564 * 565 * @param layoutSetBranchId the layout set branch ID 566 * @param head the head 567 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 568 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 569 */ 570 public static LayoutRevision fetchByL_H_Last(long layoutSetBranchId, 571 boolean head, OrderByComparator<LayoutRevision> orderByComparator) { 572 return getPersistence() 573 .fetchByL_H_Last(layoutSetBranchId, head, orderByComparator); 574 } 575 576 /** 577 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and head = ?. 578 * 579 * @param layoutRevisionId the primary key of the current layout revision 580 * @param layoutSetBranchId the layout set branch ID 581 * @param head the head 582 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 583 * @return the previous, current, and next layout revision 584 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 585 */ 586 public static LayoutRevision[] findByL_H_PrevAndNext( 587 long layoutRevisionId, long layoutSetBranchId, boolean head, 588 OrderByComparator<LayoutRevision> orderByComparator) 589 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 590 return getPersistence() 591 .findByL_H_PrevAndNext(layoutRevisionId, layoutSetBranchId, 592 head, orderByComparator); 593 } 594 595 /** 596 * Removes all the layout revisions where layoutSetBranchId = ? and head = ? from the database. 597 * 598 * @param layoutSetBranchId the layout set branch ID 599 * @param head the head 600 */ 601 public static void removeByL_H(long layoutSetBranchId, boolean head) { 602 getPersistence().removeByL_H(layoutSetBranchId, head); 603 } 604 605 /** 606 * Returns the number of layout revisions where layoutSetBranchId = ? and head = ?. 607 * 608 * @param layoutSetBranchId the layout set branch ID 609 * @param head the head 610 * @return the number of matching layout revisions 611 */ 612 public static int countByL_H(long layoutSetBranchId, boolean head) { 613 return getPersistence().countByL_H(layoutSetBranchId, head); 614 } 615 616 /** 617 * Returns all the layout revisions where layoutSetBranchId = ? and plid = ?. 618 * 619 * @param layoutSetBranchId the layout set branch ID 620 * @param plid the plid 621 * @return the matching layout revisions 622 */ 623 public static List<LayoutRevision> findByL_P(long layoutSetBranchId, 624 long plid) { 625 return getPersistence().findByL_P(layoutSetBranchId, plid); 626 } 627 628 /** 629 * Returns a range of all the layout revisions where layoutSetBranchId = ? and plid = ?. 630 * 631 * <p> 632 * 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 LayoutRevisionModelImpl}. 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. 633 * </p> 634 * 635 * @param layoutSetBranchId the layout set branch ID 636 * @param plid the plid 637 * @param start the lower bound of the range of layout revisions 638 * @param end the upper bound of the range of layout revisions (not inclusive) 639 * @return the range of matching layout revisions 640 */ 641 public static List<LayoutRevision> findByL_P(long layoutSetBranchId, 642 long plid, int start, int end) { 643 return getPersistence().findByL_P(layoutSetBranchId, plid, start, end); 644 } 645 646 /** 647 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and plid = ?. 648 * 649 * <p> 650 * 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 LayoutRevisionModelImpl}. 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. 651 * </p> 652 * 653 * @param layoutSetBranchId the layout set branch ID 654 * @param plid the plid 655 * @param start the lower bound of the range of layout revisions 656 * @param end the upper bound of the range of layout revisions (not inclusive) 657 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 658 * @return the ordered range of matching layout revisions 659 */ 660 public static List<LayoutRevision> findByL_P(long layoutSetBranchId, 661 long plid, int start, int end, 662 OrderByComparator<LayoutRevision> orderByComparator) { 663 return getPersistence() 664 .findByL_P(layoutSetBranchId, plid, start, end, 665 orderByComparator); 666 } 667 668 /** 669 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and plid = ?. 670 * 671 * <p> 672 * 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 LayoutRevisionModelImpl}. 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. 673 * </p> 674 * 675 * @param layoutSetBranchId the layout set branch ID 676 * @param plid the plid 677 * @param start the lower bound of the range of layout revisions 678 * @param end the upper bound of the range of layout revisions (not inclusive) 679 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 680 * @param retrieveFromCache whether to retrieve from the finder cache 681 * @return the ordered range of matching layout revisions 682 */ 683 public static List<LayoutRevision> findByL_P(long layoutSetBranchId, 684 long plid, int start, int end, 685 OrderByComparator<LayoutRevision> orderByComparator, 686 boolean retrieveFromCache) { 687 return getPersistence() 688 .findByL_P(layoutSetBranchId, plid, start, end, 689 orderByComparator, retrieveFromCache); 690 } 691 692 /** 693 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 694 * 695 * @param layoutSetBranchId the layout set branch ID 696 * @param plid the plid 697 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 698 * @return the first matching layout revision 699 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 700 */ 701 public static LayoutRevision findByL_P_First(long layoutSetBranchId, 702 long plid, OrderByComparator<LayoutRevision> orderByComparator) 703 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 704 return getPersistence() 705 .findByL_P_First(layoutSetBranchId, plid, orderByComparator); 706 } 707 708 /** 709 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 710 * 711 * @param layoutSetBranchId the layout set branch ID 712 * @param plid the plid 713 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 714 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 715 */ 716 public static LayoutRevision fetchByL_P_First(long layoutSetBranchId, 717 long plid, OrderByComparator<LayoutRevision> orderByComparator) { 718 return getPersistence() 719 .fetchByL_P_First(layoutSetBranchId, plid, orderByComparator); 720 } 721 722 /** 723 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 724 * 725 * @param layoutSetBranchId the layout set branch ID 726 * @param plid the plid 727 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 728 * @return the last matching layout revision 729 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 730 */ 731 public static LayoutRevision findByL_P_Last(long layoutSetBranchId, 732 long plid, OrderByComparator<LayoutRevision> orderByComparator) 733 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 734 return getPersistence() 735 .findByL_P_Last(layoutSetBranchId, plid, orderByComparator); 736 } 737 738 /** 739 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 740 * 741 * @param layoutSetBranchId the layout set branch ID 742 * @param plid the plid 743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 744 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 745 */ 746 public static LayoutRevision fetchByL_P_Last(long layoutSetBranchId, 747 long plid, OrderByComparator<LayoutRevision> orderByComparator) { 748 return getPersistence() 749 .fetchByL_P_Last(layoutSetBranchId, plid, orderByComparator); 750 } 751 752 /** 753 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and plid = ?. 754 * 755 * @param layoutRevisionId the primary key of the current layout revision 756 * @param layoutSetBranchId the layout set branch ID 757 * @param plid the plid 758 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 759 * @return the previous, current, and next layout revision 760 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 761 */ 762 public static LayoutRevision[] findByL_P_PrevAndNext( 763 long layoutRevisionId, long layoutSetBranchId, long plid, 764 OrderByComparator<LayoutRevision> orderByComparator) 765 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 766 return getPersistence() 767 .findByL_P_PrevAndNext(layoutRevisionId, layoutSetBranchId, 768 plid, orderByComparator); 769 } 770 771 /** 772 * Removes all the layout revisions where layoutSetBranchId = ? and plid = ? from the database. 773 * 774 * @param layoutSetBranchId the layout set branch ID 775 * @param plid the plid 776 */ 777 public static void removeByL_P(long layoutSetBranchId, long plid) { 778 getPersistence().removeByL_P(layoutSetBranchId, plid); 779 } 780 781 /** 782 * Returns the number of layout revisions where layoutSetBranchId = ? and plid = ?. 783 * 784 * @param layoutSetBranchId the layout set branch ID 785 * @param plid the plid 786 * @return the number of matching layout revisions 787 */ 788 public static int countByL_P(long layoutSetBranchId, long plid) { 789 return getPersistence().countByL_P(layoutSetBranchId, plid); 790 } 791 792 /** 793 * Returns all the layout revisions where layoutSetBranchId = ? and status = ?. 794 * 795 * @param layoutSetBranchId the layout set branch ID 796 * @param status the status 797 * @return the matching layout revisions 798 */ 799 public static List<LayoutRevision> findByL_S(long layoutSetBranchId, 800 int status) { 801 return getPersistence().findByL_S(layoutSetBranchId, status); 802 } 803 804 /** 805 * Returns a range of all the layout revisions where layoutSetBranchId = ? and status = ?. 806 * 807 * <p> 808 * 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 LayoutRevisionModelImpl}. 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. 809 * </p> 810 * 811 * @param layoutSetBranchId the layout set branch ID 812 * @param status the status 813 * @param start the lower bound of the range of layout revisions 814 * @param end the upper bound of the range of layout revisions (not inclusive) 815 * @return the range of matching layout revisions 816 */ 817 public static List<LayoutRevision> findByL_S(long layoutSetBranchId, 818 int status, int start, int end) { 819 return getPersistence().findByL_S(layoutSetBranchId, status, start, end); 820 } 821 822 /** 823 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and status = ?. 824 * 825 * <p> 826 * 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 LayoutRevisionModelImpl}. 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. 827 * </p> 828 * 829 * @param layoutSetBranchId the layout set branch ID 830 * @param status the status 831 * @param start the lower bound of the range of layout revisions 832 * @param end the upper bound of the range of layout revisions (not inclusive) 833 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 834 * @return the ordered range of matching layout revisions 835 */ 836 public static List<LayoutRevision> findByL_S(long layoutSetBranchId, 837 int status, int start, int end, 838 OrderByComparator<LayoutRevision> orderByComparator) { 839 return getPersistence() 840 .findByL_S(layoutSetBranchId, status, start, end, 841 orderByComparator); 842 } 843 844 /** 845 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and status = ?. 846 * 847 * <p> 848 * 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 LayoutRevisionModelImpl}. 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. 849 * </p> 850 * 851 * @param layoutSetBranchId the layout set branch ID 852 * @param status the status 853 * @param start the lower bound of the range of layout revisions 854 * @param end the upper bound of the range of layout revisions (not inclusive) 855 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 856 * @param retrieveFromCache whether to retrieve from the finder cache 857 * @return the ordered range of matching layout revisions 858 */ 859 public static List<LayoutRevision> findByL_S(long layoutSetBranchId, 860 int status, int start, int end, 861 OrderByComparator<LayoutRevision> orderByComparator, 862 boolean retrieveFromCache) { 863 return getPersistence() 864 .findByL_S(layoutSetBranchId, status, start, end, 865 orderByComparator, retrieveFromCache); 866 } 867 868 /** 869 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 870 * 871 * @param layoutSetBranchId the layout set branch ID 872 * @param status the status 873 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 874 * @return the first matching layout revision 875 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 876 */ 877 public static LayoutRevision findByL_S_First(long layoutSetBranchId, 878 int status, OrderByComparator<LayoutRevision> orderByComparator) 879 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 880 return getPersistence() 881 .findByL_S_First(layoutSetBranchId, status, orderByComparator); 882 } 883 884 /** 885 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 886 * 887 * @param layoutSetBranchId the layout set branch ID 888 * @param status the status 889 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 890 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 891 */ 892 public static LayoutRevision fetchByL_S_First(long layoutSetBranchId, 893 int status, OrderByComparator<LayoutRevision> orderByComparator) { 894 return getPersistence() 895 .fetchByL_S_First(layoutSetBranchId, status, 896 orderByComparator); 897 } 898 899 /** 900 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 901 * 902 * @param layoutSetBranchId the layout set branch ID 903 * @param status the status 904 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 905 * @return the last matching layout revision 906 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 907 */ 908 public static LayoutRevision findByL_S_Last(long layoutSetBranchId, 909 int status, OrderByComparator<LayoutRevision> orderByComparator) 910 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 911 return getPersistence() 912 .findByL_S_Last(layoutSetBranchId, status, orderByComparator); 913 } 914 915 /** 916 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 917 * 918 * @param layoutSetBranchId the layout set branch ID 919 * @param status the status 920 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 921 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 922 */ 923 public static LayoutRevision fetchByL_S_Last(long layoutSetBranchId, 924 int status, OrderByComparator<LayoutRevision> orderByComparator) { 925 return getPersistence() 926 .fetchByL_S_Last(layoutSetBranchId, status, orderByComparator); 927 } 928 929 /** 930 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and status = ?. 931 * 932 * @param layoutRevisionId the primary key of the current layout revision 933 * @param layoutSetBranchId the layout set branch ID 934 * @param status the status 935 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 936 * @return the previous, current, and next layout revision 937 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 938 */ 939 public static LayoutRevision[] findByL_S_PrevAndNext( 940 long layoutRevisionId, long layoutSetBranchId, int status, 941 OrderByComparator<LayoutRevision> orderByComparator) 942 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 943 return getPersistence() 944 .findByL_S_PrevAndNext(layoutRevisionId, layoutSetBranchId, 945 status, orderByComparator); 946 } 947 948 /** 949 * Removes all the layout revisions where layoutSetBranchId = ? and status = ? from the database. 950 * 951 * @param layoutSetBranchId the layout set branch ID 952 * @param status the status 953 */ 954 public static void removeByL_S(long layoutSetBranchId, int status) { 955 getPersistence().removeByL_S(layoutSetBranchId, status); 956 } 957 958 /** 959 * Returns the number of layout revisions where layoutSetBranchId = ? and status = ?. 960 * 961 * @param layoutSetBranchId the layout set branch ID 962 * @param status the status 963 * @return the number of matching layout revisions 964 */ 965 public static int countByL_S(long layoutSetBranchId, int status) { 966 return getPersistence().countByL_S(layoutSetBranchId, status); 967 } 968 969 /** 970 * Returns all the layout revisions where head = ? and plid = ?. 971 * 972 * @param head the head 973 * @param plid the plid 974 * @return the matching layout revisions 975 */ 976 public static List<LayoutRevision> findByH_P(boolean head, long plid) { 977 return getPersistence().findByH_P(head, plid); 978 } 979 980 /** 981 * Returns a range of all the layout revisions where head = ? and plid = ?. 982 * 983 * <p> 984 * 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 LayoutRevisionModelImpl}. 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. 985 * </p> 986 * 987 * @param head the head 988 * @param plid the plid 989 * @param start the lower bound of the range of layout revisions 990 * @param end the upper bound of the range of layout revisions (not inclusive) 991 * @return the range of matching layout revisions 992 */ 993 public static List<LayoutRevision> findByH_P(boolean head, long plid, 994 int start, int end) { 995 return getPersistence().findByH_P(head, plid, start, end); 996 } 997 998 /** 999 * Returns an ordered range of all the layout revisions where head = ? and plid = ?. 1000 * 1001 * <p> 1002 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutRevisionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1003 * </p> 1004 * 1005 * @param head the head 1006 * @param plid the plid 1007 * @param start the lower bound of the range of layout revisions 1008 * @param end the upper bound of the range of layout revisions (not inclusive) 1009 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1010 * @return the ordered range of matching layout revisions 1011 */ 1012 public static List<LayoutRevision> findByH_P(boolean head, long plid, 1013 int start, int end, OrderByComparator<LayoutRevision> orderByComparator) { 1014 return getPersistence() 1015 .findByH_P(head, plid, start, end, orderByComparator); 1016 } 1017 1018 /** 1019 * Returns an ordered range of all the layout revisions where head = ? and plid = ?. 1020 * 1021 * <p> 1022 * 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 LayoutRevisionModelImpl}. 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. 1023 * </p> 1024 * 1025 * @param head the head 1026 * @param plid the plid 1027 * @param start the lower bound of the range of layout revisions 1028 * @param end the upper bound of the range of layout revisions (not inclusive) 1029 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1030 * @param retrieveFromCache whether to retrieve from the finder cache 1031 * @return the ordered range of matching layout revisions 1032 */ 1033 public static List<LayoutRevision> findByH_P(boolean head, long plid, 1034 int start, int end, 1035 OrderByComparator<LayoutRevision> orderByComparator, 1036 boolean retrieveFromCache) { 1037 return getPersistence() 1038 .findByH_P(head, plid, start, end, orderByComparator, 1039 retrieveFromCache); 1040 } 1041 1042 /** 1043 * Returns the first layout revision in the ordered set where head = ? and plid = ?. 1044 * 1045 * @param head the head 1046 * @param plid the plid 1047 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1048 * @return the first matching layout revision 1049 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1050 */ 1051 public static LayoutRevision findByH_P_First(boolean head, long plid, 1052 OrderByComparator<LayoutRevision> orderByComparator) 1053 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1054 return getPersistence().findByH_P_First(head, plid, orderByComparator); 1055 } 1056 1057 /** 1058 * Returns the first layout revision in the ordered set where head = ? and plid = ?. 1059 * 1060 * @param head the head 1061 * @param plid the plid 1062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1063 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 1064 */ 1065 public static LayoutRevision fetchByH_P_First(boolean head, long plid, 1066 OrderByComparator<LayoutRevision> orderByComparator) { 1067 return getPersistence().fetchByH_P_First(head, plid, orderByComparator); 1068 } 1069 1070 /** 1071 * Returns the last layout revision in the ordered set where head = ? and plid = ?. 1072 * 1073 * @param head the head 1074 * @param plid the plid 1075 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1076 * @return the last matching layout revision 1077 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1078 */ 1079 public static LayoutRevision findByH_P_Last(boolean head, long plid, 1080 OrderByComparator<LayoutRevision> orderByComparator) 1081 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1082 return getPersistence().findByH_P_Last(head, plid, orderByComparator); 1083 } 1084 1085 /** 1086 * Returns the last layout revision in the ordered set where head = ? and plid = ?. 1087 * 1088 * @param head the head 1089 * @param plid the plid 1090 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1091 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 1092 */ 1093 public static LayoutRevision fetchByH_P_Last(boolean head, long plid, 1094 OrderByComparator<LayoutRevision> orderByComparator) { 1095 return getPersistence().fetchByH_P_Last(head, plid, orderByComparator); 1096 } 1097 1098 /** 1099 * Returns the layout revisions before and after the current layout revision in the ordered set where head = ? and plid = ?. 1100 * 1101 * @param layoutRevisionId the primary key of the current layout revision 1102 * @param head the head 1103 * @param plid the plid 1104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1105 * @return the previous, current, and next layout revision 1106 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1107 */ 1108 public static LayoutRevision[] findByH_P_PrevAndNext( 1109 long layoutRevisionId, boolean head, long plid, 1110 OrderByComparator<LayoutRevision> orderByComparator) 1111 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1112 return getPersistence() 1113 .findByH_P_PrevAndNext(layoutRevisionId, head, plid, 1114 orderByComparator); 1115 } 1116 1117 /** 1118 * Removes all the layout revisions where head = ? and plid = ? from the database. 1119 * 1120 * @param head the head 1121 * @param plid the plid 1122 */ 1123 public static void removeByH_P(boolean head, long plid) { 1124 getPersistence().removeByH_P(head, plid); 1125 } 1126 1127 /** 1128 * Returns the number of layout revisions where head = ? and plid = ?. 1129 * 1130 * @param head the head 1131 * @param plid the plid 1132 * @return the number of matching layout revisions 1133 */ 1134 public static int countByH_P(boolean head, long plid) { 1135 return getPersistence().countByH_P(head, plid); 1136 } 1137 1138 /** 1139 * Returns all the layout revisions where plid = ? and status ≠ ?. 1140 * 1141 * @param plid the plid 1142 * @param status the status 1143 * @return the matching layout revisions 1144 */ 1145 public static List<LayoutRevision> findByP_NotS(long plid, int status) { 1146 return getPersistence().findByP_NotS(plid, status); 1147 } 1148 1149 /** 1150 * Returns a range of all the layout revisions where plid = ? and status ≠ ?. 1151 * 1152 * <p> 1153 * 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 LayoutRevisionModelImpl}. 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. 1154 * </p> 1155 * 1156 * @param plid the plid 1157 * @param status the status 1158 * @param start the lower bound of the range of layout revisions 1159 * @param end the upper bound of the range of layout revisions (not inclusive) 1160 * @return the range of matching layout revisions 1161 */ 1162 public static List<LayoutRevision> findByP_NotS(long plid, int status, 1163 int start, int end) { 1164 return getPersistence().findByP_NotS(plid, status, start, end); 1165 } 1166 1167 /** 1168 * Returns an ordered range of all the layout revisions where plid = ? and status ≠ ?. 1169 * 1170 * <p> 1171 * 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 LayoutRevisionModelImpl}. 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. 1172 * </p> 1173 * 1174 * @param plid the plid 1175 * @param status the status 1176 * @param start the lower bound of the range of layout revisions 1177 * @param end the upper bound of the range of layout revisions (not inclusive) 1178 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1179 * @return the ordered range of matching layout revisions 1180 */ 1181 public static List<LayoutRevision> findByP_NotS(long plid, int status, 1182 int start, int end, OrderByComparator<LayoutRevision> orderByComparator) { 1183 return getPersistence() 1184 .findByP_NotS(plid, status, start, end, orderByComparator); 1185 } 1186 1187 /** 1188 * Returns an ordered range of all the layout revisions where plid = ? and status ≠ ?. 1189 * 1190 * <p> 1191 * 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 LayoutRevisionModelImpl}. 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. 1192 * </p> 1193 * 1194 * @param plid the plid 1195 * @param status the status 1196 * @param start the lower bound of the range of layout revisions 1197 * @param end the upper bound of the range of layout revisions (not inclusive) 1198 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1199 * @param retrieveFromCache whether to retrieve from the finder cache 1200 * @return the ordered range of matching layout revisions 1201 */ 1202 public static List<LayoutRevision> findByP_NotS(long plid, int status, 1203 int start, int end, 1204 OrderByComparator<LayoutRevision> orderByComparator, 1205 boolean retrieveFromCache) { 1206 return getPersistence() 1207 .findByP_NotS(plid, status, start, end, orderByComparator, 1208 retrieveFromCache); 1209 } 1210 1211 /** 1212 * Returns the first layout revision in the ordered set where plid = ? and status ≠ ?. 1213 * 1214 * @param plid the plid 1215 * @param status the status 1216 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1217 * @return the first matching layout revision 1218 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1219 */ 1220 public static LayoutRevision findByP_NotS_First(long plid, int status, 1221 OrderByComparator<LayoutRevision> orderByComparator) 1222 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1223 return getPersistence() 1224 .findByP_NotS_First(plid, status, orderByComparator); 1225 } 1226 1227 /** 1228 * Returns the first layout revision in the ordered set where plid = ? and status ≠ ?. 1229 * 1230 * @param plid the plid 1231 * @param status the status 1232 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1233 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 1234 */ 1235 public static LayoutRevision fetchByP_NotS_First(long plid, int status, 1236 OrderByComparator<LayoutRevision> orderByComparator) { 1237 return getPersistence() 1238 .fetchByP_NotS_First(plid, status, orderByComparator); 1239 } 1240 1241 /** 1242 * Returns the last layout revision in the ordered set where plid = ? and status ≠ ?. 1243 * 1244 * @param plid the plid 1245 * @param status the status 1246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1247 * @return the last matching layout revision 1248 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1249 */ 1250 public static LayoutRevision findByP_NotS_Last(long plid, int status, 1251 OrderByComparator<LayoutRevision> orderByComparator) 1252 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1253 return getPersistence() 1254 .findByP_NotS_Last(plid, status, orderByComparator); 1255 } 1256 1257 /** 1258 * Returns the last layout revision in the ordered set where plid = ? and status ≠ ?. 1259 * 1260 * @param plid the plid 1261 * @param status the status 1262 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1263 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 1264 */ 1265 public static LayoutRevision fetchByP_NotS_Last(long plid, int status, 1266 OrderByComparator<LayoutRevision> orderByComparator) { 1267 return getPersistence() 1268 .fetchByP_NotS_Last(plid, status, orderByComparator); 1269 } 1270 1271 /** 1272 * Returns the layout revisions before and after the current layout revision in the ordered set where plid = ? and status ≠ ?. 1273 * 1274 * @param layoutRevisionId the primary key of the current layout revision 1275 * @param plid the plid 1276 * @param status the status 1277 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1278 * @return the previous, current, and next layout revision 1279 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1280 */ 1281 public static LayoutRevision[] findByP_NotS_PrevAndNext( 1282 long layoutRevisionId, long plid, int status, 1283 OrderByComparator<LayoutRevision> orderByComparator) 1284 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1285 return getPersistence() 1286 .findByP_NotS_PrevAndNext(layoutRevisionId, plid, status, 1287 orderByComparator); 1288 } 1289 1290 /** 1291 * Removes all the layout revisions where plid = ? and status ≠ ? from the database. 1292 * 1293 * @param plid the plid 1294 * @param status the status 1295 */ 1296 public static void removeByP_NotS(long plid, int status) { 1297 getPersistence().removeByP_NotS(plid, status); 1298 } 1299 1300 /** 1301 * Returns the number of layout revisions where plid = ? and status ≠ ?. 1302 * 1303 * @param plid the plid 1304 * @param status the status 1305 * @return the number of matching layout revisions 1306 */ 1307 public static int countByP_NotS(long plid, int status) { 1308 return getPersistence().countByP_NotS(plid, status); 1309 } 1310 1311 /** 1312 * Returns all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1313 * 1314 * @param layoutSetBranchId the layout set branch ID 1315 * @param layoutBranchId the layout branch ID 1316 * @param plid the plid 1317 * @return the matching layout revisions 1318 */ 1319 public static List<LayoutRevision> findByL_L_P(long layoutSetBranchId, 1320 long layoutBranchId, long plid) { 1321 return getPersistence() 1322 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid); 1323 } 1324 1325 /** 1326 * Returns a range of all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1327 * 1328 * <p> 1329 * 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 LayoutRevisionModelImpl}. 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. 1330 * </p> 1331 * 1332 * @param layoutSetBranchId the layout set branch ID 1333 * @param layoutBranchId the layout branch ID 1334 * @param plid the plid 1335 * @param start the lower bound of the range of layout revisions 1336 * @param end the upper bound of the range of layout revisions (not inclusive) 1337 * @return the range of matching layout revisions 1338 */ 1339 public static List<LayoutRevision> findByL_L_P(long layoutSetBranchId, 1340 long layoutBranchId, long plid, int start, int end) { 1341 return getPersistence() 1342 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start, 1343 end); 1344 } 1345 1346 /** 1347 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1348 * 1349 * <p> 1350 * 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 LayoutRevisionModelImpl}. 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. 1351 * </p> 1352 * 1353 * @param layoutSetBranchId the layout set branch ID 1354 * @param layoutBranchId the layout branch ID 1355 * @param plid the plid 1356 * @param start the lower bound of the range of layout revisions 1357 * @param end the upper bound of the range of layout revisions (not inclusive) 1358 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1359 * @return the ordered range of matching layout revisions 1360 */ 1361 public static List<LayoutRevision> findByL_L_P(long layoutSetBranchId, 1362 long layoutBranchId, long plid, int start, int end, 1363 OrderByComparator<LayoutRevision> orderByComparator) { 1364 return getPersistence() 1365 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start, 1366 end, orderByComparator); 1367 } 1368 1369 /** 1370 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1371 * 1372 * <p> 1373 * 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 LayoutRevisionModelImpl}. 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. 1374 * </p> 1375 * 1376 * @param layoutSetBranchId the layout set branch ID 1377 * @param layoutBranchId the layout branch ID 1378 * @param plid the plid 1379 * @param start the lower bound of the range of layout revisions 1380 * @param end the upper bound of the range of layout revisions (not inclusive) 1381 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1382 * @param retrieveFromCache whether to retrieve from the finder cache 1383 * @return the ordered range of matching layout revisions 1384 */ 1385 public static List<LayoutRevision> findByL_L_P(long layoutSetBranchId, 1386 long layoutBranchId, long plid, int start, int end, 1387 OrderByComparator<LayoutRevision> orderByComparator, 1388 boolean retrieveFromCache) { 1389 return getPersistence() 1390 .findByL_L_P(layoutSetBranchId, layoutBranchId, plid, start, 1391 end, orderByComparator, retrieveFromCache); 1392 } 1393 1394 /** 1395 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1396 * 1397 * @param layoutSetBranchId the layout set branch ID 1398 * @param layoutBranchId the layout branch ID 1399 * @param plid the plid 1400 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1401 * @return the first matching layout revision 1402 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1403 */ 1404 public static LayoutRevision findByL_L_P_First(long layoutSetBranchId, 1405 long layoutBranchId, long plid, 1406 OrderByComparator<LayoutRevision> orderByComparator) 1407 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1408 return getPersistence() 1409 .findByL_L_P_First(layoutSetBranchId, layoutBranchId, plid, 1410 orderByComparator); 1411 } 1412 1413 /** 1414 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1415 * 1416 * @param layoutSetBranchId the layout set branch ID 1417 * @param layoutBranchId the layout branch ID 1418 * @param plid the plid 1419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1420 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 1421 */ 1422 public static LayoutRevision fetchByL_L_P_First(long layoutSetBranchId, 1423 long layoutBranchId, long plid, 1424 OrderByComparator<LayoutRevision> orderByComparator) { 1425 return getPersistence() 1426 .fetchByL_L_P_First(layoutSetBranchId, layoutBranchId, plid, 1427 orderByComparator); 1428 } 1429 1430 /** 1431 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1432 * 1433 * @param layoutSetBranchId the layout set branch ID 1434 * @param layoutBranchId the layout branch ID 1435 * @param plid the plid 1436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1437 * @return the last matching layout revision 1438 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1439 */ 1440 public static LayoutRevision findByL_L_P_Last(long layoutSetBranchId, 1441 long layoutBranchId, long plid, 1442 OrderByComparator<LayoutRevision> orderByComparator) 1443 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1444 return getPersistence() 1445 .findByL_L_P_Last(layoutSetBranchId, layoutBranchId, plid, 1446 orderByComparator); 1447 } 1448 1449 /** 1450 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1451 * 1452 * @param layoutSetBranchId the layout set branch ID 1453 * @param layoutBranchId the layout branch ID 1454 * @param plid the plid 1455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1456 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 1457 */ 1458 public static LayoutRevision fetchByL_L_P_Last(long layoutSetBranchId, 1459 long layoutBranchId, long plid, 1460 OrderByComparator<LayoutRevision> orderByComparator) { 1461 return getPersistence() 1462 .fetchByL_L_P_Last(layoutSetBranchId, layoutBranchId, plid, 1463 orderByComparator); 1464 } 1465 1466 /** 1467 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1468 * 1469 * @param layoutRevisionId the primary key of the current layout revision 1470 * @param layoutSetBranchId the layout set branch ID 1471 * @param layoutBranchId the layout branch ID 1472 * @param plid the plid 1473 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1474 * @return the previous, current, and next layout revision 1475 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1476 */ 1477 public static LayoutRevision[] findByL_L_P_PrevAndNext( 1478 long layoutRevisionId, long layoutSetBranchId, long layoutBranchId, 1479 long plid, OrderByComparator<LayoutRevision> orderByComparator) 1480 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1481 return getPersistence() 1482 .findByL_L_P_PrevAndNext(layoutRevisionId, 1483 layoutSetBranchId, layoutBranchId, plid, orderByComparator); 1484 } 1485 1486 /** 1487 * Removes all the layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ? from the database. 1488 * 1489 * @param layoutSetBranchId the layout set branch ID 1490 * @param layoutBranchId the layout branch ID 1491 * @param plid the plid 1492 */ 1493 public static void removeByL_L_P(long layoutSetBranchId, 1494 long layoutBranchId, long plid) { 1495 getPersistence().removeByL_L_P(layoutSetBranchId, layoutBranchId, plid); 1496 } 1497 1498 /** 1499 * Returns the number of layout revisions where layoutSetBranchId = ? and layoutBranchId = ? and plid = ?. 1500 * 1501 * @param layoutSetBranchId the layout set branch ID 1502 * @param layoutBranchId the layout branch ID 1503 * @param plid the plid 1504 * @return the number of matching layout revisions 1505 */ 1506 public static int countByL_L_P(long layoutSetBranchId, long layoutBranchId, 1507 long plid) { 1508 return getPersistence() 1509 .countByL_L_P(layoutSetBranchId, layoutBranchId, plid); 1510 } 1511 1512 /** 1513 * Returns all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1514 * 1515 * @param layoutSetBranchId the layout set branch ID 1516 * @param parentLayoutRevisionId the parent layout revision ID 1517 * @param plid the plid 1518 * @return the matching layout revisions 1519 */ 1520 public static List<LayoutRevision> findByL_P_P(long layoutSetBranchId, 1521 long parentLayoutRevisionId, long plid) { 1522 return getPersistence() 1523 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid); 1524 } 1525 1526 /** 1527 * Returns a range of all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1528 * 1529 * <p> 1530 * 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 LayoutRevisionModelImpl}. 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. 1531 * </p> 1532 * 1533 * @param layoutSetBranchId the layout set branch ID 1534 * @param parentLayoutRevisionId the parent layout revision ID 1535 * @param plid the plid 1536 * @param start the lower bound of the range of layout revisions 1537 * @param end the upper bound of the range of layout revisions (not inclusive) 1538 * @return the range of matching layout revisions 1539 */ 1540 public static List<LayoutRevision> findByL_P_P(long layoutSetBranchId, 1541 long parentLayoutRevisionId, long plid, int start, int end) { 1542 return getPersistence() 1543 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, 1544 plid, start, end); 1545 } 1546 1547 /** 1548 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1549 * 1550 * <p> 1551 * 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 LayoutRevisionModelImpl}. 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. 1552 * </p> 1553 * 1554 * @param layoutSetBranchId the layout set branch ID 1555 * @param parentLayoutRevisionId the parent layout revision ID 1556 * @param plid the plid 1557 * @param start the lower bound of the range of layout revisions 1558 * @param end the upper bound of the range of layout revisions (not inclusive) 1559 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1560 * @return the ordered range of matching layout revisions 1561 */ 1562 public static List<LayoutRevision> findByL_P_P(long layoutSetBranchId, 1563 long parentLayoutRevisionId, long plid, int start, int end, 1564 OrderByComparator<LayoutRevision> orderByComparator) { 1565 return getPersistence() 1566 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, 1567 plid, start, end, orderByComparator); 1568 } 1569 1570 /** 1571 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1572 * 1573 * <p> 1574 * 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 LayoutRevisionModelImpl}. 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. 1575 * </p> 1576 * 1577 * @param layoutSetBranchId the layout set branch ID 1578 * @param parentLayoutRevisionId the parent layout revision ID 1579 * @param plid the plid 1580 * @param start the lower bound of the range of layout revisions 1581 * @param end the upper bound of the range of layout revisions (not inclusive) 1582 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1583 * @param retrieveFromCache whether to retrieve from the finder cache 1584 * @return the ordered range of matching layout revisions 1585 */ 1586 public static List<LayoutRevision> findByL_P_P(long layoutSetBranchId, 1587 long parentLayoutRevisionId, long plid, int start, int end, 1588 OrderByComparator<LayoutRevision> orderByComparator, 1589 boolean retrieveFromCache) { 1590 return getPersistence() 1591 .findByL_P_P(layoutSetBranchId, parentLayoutRevisionId, 1592 plid, start, end, orderByComparator, retrieveFromCache); 1593 } 1594 1595 /** 1596 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1597 * 1598 * @param layoutSetBranchId the layout set branch ID 1599 * @param parentLayoutRevisionId the parent layout revision ID 1600 * @param plid the plid 1601 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1602 * @return the first matching layout revision 1603 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1604 */ 1605 public static LayoutRevision findByL_P_P_First(long layoutSetBranchId, 1606 long parentLayoutRevisionId, long plid, 1607 OrderByComparator<LayoutRevision> orderByComparator) 1608 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1609 return getPersistence() 1610 .findByL_P_P_First(layoutSetBranchId, 1611 parentLayoutRevisionId, plid, orderByComparator); 1612 } 1613 1614 /** 1615 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1616 * 1617 * @param layoutSetBranchId the layout set branch ID 1618 * @param parentLayoutRevisionId the parent layout revision ID 1619 * @param plid the plid 1620 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1621 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 1622 */ 1623 public static LayoutRevision fetchByL_P_P_First(long layoutSetBranchId, 1624 long parentLayoutRevisionId, long plid, 1625 OrderByComparator<LayoutRevision> orderByComparator) { 1626 return getPersistence() 1627 .fetchByL_P_P_First(layoutSetBranchId, 1628 parentLayoutRevisionId, plid, orderByComparator); 1629 } 1630 1631 /** 1632 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1633 * 1634 * @param layoutSetBranchId the layout set branch ID 1635 * @param parentLayoutRevisionId the parent layout revision ID 1636 * @param plid the plid 1637 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1638 * @return the last matching layout revision 1639 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1640 */ 1641 public static LayoutRevision findByL_P_P_Last(long layoutSetBranchId, 1642 long parentLayoutRevisionId, long plid, 1643 OrderByComparator<LayoutRevision> orderByComparator) 1644 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1645 return getPersistence() 1646 .findByL_P_P_Last(layoutSetBranchId, parentLayoutRevisionId, 1647 plid, orderByComparator); 1648 } 1649 1650 /** 1651 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1652 * 1653 * @param layoutSetBranchId the layout set branch ID 1654 * @param parentLayoutRevisionId the parent layout revision ID 1655 * @param plid the plid 1656 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1657 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 1658 */ 1659 public static LayoutRevision fetchByL_P_P_Last(long layoutSetBranchId, 1660 long parentLayoutRevisionId, long plid, 1661 OrderByComparator<LayoutRevision> orderByComparator) { 1662 return getPersistence() 1663 .fetchByL_P_P_Last(layoutSetBranchId, 1664 parentLayoutRevisionId, plid, orderByComparator); 1665 } 1666 1667 /** 1668 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1669 * 1670 * @param layoutRevisionId the primary key of the current layout revision 1671 * @param layoutSetBranchId the layout set branch ID 1672 * @param parentLayoutRevisionId the parent layout revision ID 1673 * @param plid the plid 1674 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1675 * @return the previous, current, and next layout revision 1676 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1677 */ 1678 public static LayoutRevision[] findByL_P_P_PrevAndNext( 1679 long layoutRevisionId, long layoutSetBranchId, 1680 long parentLayoutRevisionId, long plid, 1681 OrderByComparator<LayoutRevision> orderByComparator) 1682 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1683 return getPersistence() 1684 .findByL_P_P_PrevAndNext(layoutRevisionId, 1685 layoutSetBranchId, parentLayoutRevisionId, plid, orderByComparator); 1686 } 1687 1688 /** 1689 * Removes all the layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ? from the database. 1690 * 1691 * @param layoutSetBranchId the layout set branch ID 1692 * @param parentLayoutRevisionId the parent layout revision ID 1693 * @param plid the plid 1694 */ 1695 public static void removeByL_P_P(long layoutSetBranchId, 1696 long parentLayoutRevisionId, long plid) { 1697 getPersistence() 1698 .removeByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid); 1699 } 1700 1701 /** 1702 * Returns the number of layout revisions where layoutSetBranchId = ? and parentLayoutRevisionId = ? and plid = ?. 1703 * 1704 * @param layoutSetBranchId the layout set branch ID 1705 * @param parentLayoutRevisionId the parent layout revision ID 1706 * @param plid the plid 1707 * @return the number of matching layout revisions 1708 */ 1709 public static int countByL_P_P(long layoutSetBranchId, 1710 long parentLayoutRevisionId, long plid) { 1711 return getPersistence() 1712 .countByL_P_P(layoutSetBranchId, parentLayoutRevisionId, plid); 1713 } 1714 1715 /** 1716 * Returns the layout revision where layoutSetBranchId = ? and head = ? and plid = ? or throws a {@link NoSuchLayoutRevisionException} if it could not be found. 1717 * 1718 * @param layoutSetBranchId the layout set branch ID 1719 * @param head the head 1720 * @param plid the plid 1721 * @return the matching layout revision 1722 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1723 */ 1724 public static LayoutRevision findByL_H_P(long layoutSetBranchId, 1725 boolean head, long plid) 1726 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1727 return getPersistence().findByL_H_P(layoutSetBranchId, head, plid); 1728 } 1729 1730 /** 1731 * Returns the layout revision where layoutSetBranchId = ? and head = ? and plid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1732 * 1733 * @param layoutSetBranchId the layout set branch ID 1734 * @param head the head 1735 * @param plid the plid 1736 * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found 1737 */ 1738 public static LayoutRevision fetchByL_H_P(long layoutSetBranchId, 1739 boolean head, long plid) { 1740 return getPersistence().fetchByL_H_P(layoutSetBranchId, head, plid); 1741 } 1742 1743 /** 1744 * Returns the layout revision where layoutSetBranchId = ? and head = ? and plid = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1745 * 1746 * @param layoutSetBranchId the layout set branch ID 1747 * @param head the head 1748 * @param plid the plid 1749 * @param retrieveFromCache whether to retrieve from the finder cache 1750 * @return the matching layout revision, or <code>null</code> if a matching layout revision could not be found 1751 */ 1752 public static LayoutRevision fetchByL_H_P(long layoutSetBranchId, 1753 boolean head, long plid, boolean retrieveFromCache) { 1754 return getPersistence() 1755 .fetchByL_H_P(layoutSetBranchId, head, plid, 1756 retrieveFromCache); 1757 } 1758 1759 /** 1760 * Removes the layout revision where layoutSetBranchId = ? and head = ? and plid = ? from the database. 1761 * 1762 * @param layoutSetBranchId the layout set branch ID 1763 * @param head the head 1764 * @param plid the plid 1765 * @return the layout revision that was removed 1766 */ 1767 public static LayoutRevision removeByL_H_P(long layoutSetBranchId, 1768 boolean head, long plid) 1769 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1770 return getPersistence().removeByL_H_P(layoutSetBranchId, head, plid); 1771 } 1772 1773 /** 1774 * Returns the number of layout revisions where layoutSetBranchId = ? and head = ? and plid = ?. 1775 * 1776 * @param layoutSetBranchId the layout set branch ID 1777 * @param head the head 1778 * @param plid the plid 1779 * @return the number of matching layout revisions 1780 */ 1781 public static int countByL_H_P(long layoutSetBranchId, boolean head, 1782 long plid) { 1783 return getPersistence().countByL_H_P(layoutSetBranchId, head, plid); 1784 } 1785 1786 /** 1787 * Returns all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1788 * 1789 * @param layoutSetBranchId the layout set branch ID 1790 * @param plid the plid 1791 * @param status the status 1792 * @return the matching layout revisions 1793 */ 1794 public static List<LayoutRevision> findByL_P_S(long layoutSetBranchId, 1795 long plid, int status) { 1796 return getPersistence().findByL_P_S(layoutSetBranchId, plid, status); 1797 } 1798 1799 /** 1800 * Returns a range of all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1801 * 1802 * <p> 1803 * 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 LayoutRevisionModelImpl}. 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. 1804 * </p> 1805 * 1806 * @param layoutSetBranchId the layout set branch ID 1807 * @param plid the plid 1808 * @param status the status 1809 * @param start the lower bound of the range of layout revisions 1810 * @param end the upper bound of the range of layout revisions (not inclusive) 1811 * @return the range of matching layout revisions 1812 */ 1813 public static List<LayoutRevision> findByL_P_S(long layoutSetBranchId, 1814 long plid, int status, int start, int end) { 1815 return getPersistence() 1816 .findByL_P_S(layoutSetBranchId, plid, status, start, end); 1817 } 1818 1819 /** 1820 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1821 * 1822 * <p> 1823 * 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 LayoutRevisionModelImpl}. 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. 1824 * </p> 1825 * 1826 * @param layoutSetBranchId the layout set branch ID 1827 * @param plid the plid 1828 * @param status the status 1829 * @param start the lower bound of the range of layout revisions 1830 * @param end the upper bound of the range of layout revisions (not inclusive) 1831 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1832 * @return the ordered range of matching layout revisions 1833 */ 1834 public static List<LayoutRevision> findByL_P_S(long layoutSetBranchId, 1835 long plid, int status, int start, int end, 1836 OrderByComparator<LayoutRevision> orderByComparator) { 1837 return getPersistence() 1838 .findByL_P_S(layoutSetBranchId, plid, status, start, end, 1839 orderByComparator); 1840 } 1841 1842 /** 1843 * Returns an ordered range of all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1844 * 1845 * <p> 1846 * 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 LayoutRevisionModelImpl}. 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. 1847 * </p> 1848 * 1849 * @param layoutSetBranchId the layout set branch ID 1850 * @param plid the plid 1851 * @param status the status 1852 * @param start the lower bound of the range of layout revisions 1853 * @param end the upper bound of the range of layout revisions (not inclusive) 1854 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1855 * @param retrieveFromCache whether to retrieve from the finder cache 1856 * @return the ordered range of matching layout revisions 1857 */ 1858 public static List<LayoutRevision> findByL_P_S(long layoutSetBranchId, 1859 long plid, int status, int start, int end, 1860 OrderByComparator<LayoutRevision> orderByComparator, 1861 boolean retrieveFromCache) { 1862 return getPersistence() 1863 .findByL_P_S(layoutSetBranchId, plid, status, start, end, 1864 orderByComparator, retrieveFromCache); 1865 } 1866 1867 /** 1868 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1869 * 1870 * @param layoutSetBranchId the layout set branch ID 1871 * @param plid the plid 1872 * @param status the status 1873 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1874 * @return the first matching layout revision 1875 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1876 */ 1877 public static LayoutRevision findByL_P_S_First(long layoutSetBranchId, 1878 long plid, int status, 1879 OrderByComparator<LayoutRevision> orderByComparator) 1880 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1881 return getPersistence() 1882 .findByL_P_S_First(layoutSetBranchId, plid, status, 1883 orderByComparator); 1884 } 1885 1886 /** 1887 * Returns the first layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1888 * 1889 * @param layoutSetBranchId the layout set branch ID 1890 * @param plid the plid 1891 * @param status the status 1892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1893 * @return the first matching layout revision, or <code>null</code> if a matching layout revision could not be found 1894 */ 1895 public static LayoutRevision fetchByL_P_S_First(long layoutSetBranchId, 1896 long plid, int status, 1897 OrderByComparator<LayoutRevision> orderByComparator) { 1898 return getPersistence() 1899 .fetchByL_P_S_First(layoutSetBranchId, plid, status, 1900 orderByComparator); 1901 } 1902 1903 /** 1904 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1905 * 1906 * @param layoutSetBranchId the layout set branch ID 1907 * @param plid the plid 1908 * @param status the status 1909 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1910 * @return the last matching layout revision 1911 * @throws NoSuchLayoutRevisionException if a matching layout revision could not be found 1912 */ 1913 public static LayoutRevision findByL_P_S_Last(long layoutSetBranchId, 1914 long plid, int status, 1915 OrderByComparator<LayoutRevision> orderByComparator) 1916 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1917 return getPersistence() 1918 .findByL_P_S_Last(layoutSetBranchId, plid, status, 1919 orderByComparator); 1920 } 1921 1922 /** 1923 * Returns the last layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1924 * 1925 * @param layoutSetBranchId the layout set branch ID 1926 * @param plid the plid 1927 * @param status the status 1928 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1929 * @return the last matching layout revision, or <code>null</code> if a matching layout revision could not be found 1930 */ 1931 public static LayoutRevision fetchByL_P_S_Last(long layoutSetBranchId, 1932 long plid, int status, 1933 OrderByComparator<LayoutRevision> orderByComparator) { 1934 return getPersistence() 1935 .fetchByL_P_S_Last(layoutSetBranchId, plid, status, 1936 orderByComparator); 1937 } 1938 1939 /** 1940 * Returns the layout revisions before and after the current layout revision in the ordered set where layoutSetBranchId = ? and plid = ? and status = ?. 1941 * 1942 * @param layoutRevisionId the primary key of the current layout revision 1943 * @param layoutSetBranchId the layout set branch ID 1944 * @param plid the plid 1945 * @param status the status 1946 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1947 * @return the previous, current, and next layout revision 1948 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 1949 */ 1950 public static LayoutRevision[] findByL_P_S_PrevAndNext( 1951 long layoutRevisionId, long layoutSetBranchId, long plid, int status, 1952 OrderByComparator<LayoutRevision> orderByComparator) 1953 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 1954 return getPersistence() 1955 .findByL_P_S_PrevAndNext(layoutRevisionId, 1956 layoutSetBranchId, plid, status, orderByComparator); 1957 } 1958 1959 /** 1960 * Removes all the layout revisions where layoutSetBranchId = ? and plid = ? and status = ? from the database. 1961 * 1962 * @param layoutSetBranchId the layout set branch ID 1963 * @param plid the plid 1964 * @param status the status 1965 */ 1966 public static void removeByL_P_S(long layoutSetBranchId, long plid, 1967 int status) { 1968 getPersistence().removeByL_P_S(layoutSetBranchId, plid, status); 1969 } 1970 1971 /** 1972 * Returns the number of layout revisions where layoutSetBranchId = ? and plid = ? and status = ?. 1973 * 1974 * @param layoutSetBranchId the layout set branch ID 1975 * @param plid the plid 1976 * @param status the status 1977 * @return the number of matching layout revisions 1978 */ 1979 public static int countByL_P_S(long layoutSetBranchId, long plid, int status) { 1980 return getPersistence().countByL_P_S(layoutSetBranchId, plid, status); 1981 } 1982 1983 /** 1984 * Caches the layout revision in the entity cache if it is enabled. 1985 * 1986 * @param layoutRevision the layout revision 1987 */ 1988 public static void cacheResult(LayoutRevision layoutRevision) { 1989 getPersistence().cacheResult(layoutRevision); 1990 } 1991 1992 /** 1993 * Caches the layout revisions in the entity cache if it is enabled. 1994 * 1995 * @param layoutRevisions the layout revisions 1996 */ 1997 public static void cacheResult(List<LayoutRevision> layoutRevisions) { 1998 getPersistence().cacheResult(layoutRevisions); 1999 } 2000 2001 /** 2002 * Creates a new layout revision with the primary key. Does not add the layout revision to the database. 2003 * 2004 * @param layoutRevisionId the primary key for the new layout revision 2005 * @return the new layout revision 2006 */ 2007 public static LayoutRevision create(long layoutRevisionId) { 2008 return getPersistence().create(layoutRevisionId); 2009 } 2010 2011 /** 2012 * Removes the layout revision with the primary key from the database. Also notifies the appropriate model listeners. 2013 * 2014 * @param layoutRevisionId the primary key of the layout revision 2015 * @return the layout revision that was removed 2016 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 2017 */ 2018 public static LayoutRevision remove(long layoutRevisionId) 2019 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 2020 return getPersistence().remove(layoutRevisionId); 2021 } 2022 2023 public static LayoutRevision updateImpl(LayoutRevision layoutRevision) { 2024 return getPersistence().updateImpl(layoutRevision); 2025 } 2026 2027 /** 2028 * Returns the layout revision with the primary key or throws a {@link NoSuchLayoutRevisionException} if it could not be found. 2029 * 2030 * @param layoutRevisionId the primary key of the layout revision 2031 * @return the layout revision 2032 * @throws NoSuchLayoutRevisionException if a layout revision with the primary key could not be found 2033 */ 2034 public static LayoutRevision findByPrimaryKey(long layoutRevisionId) 2035 throws com.liferay.portal.exception.NoSuchLayoutRevisionException { 2036 return getPersistence().findByPrimaryKey(layoutRevisionId); 2037 } 2038 2039 /** 2040 * Returns the layout revision with the primary key or returns <code>null</code> if it could not be found. 2041 * 2042 * @param layoutRevisionId the primary key of the layout revision 2043 * @return the layout revision, or <code>null</code> if a layout revision with the primary key could not be found 2044 */ 2045 public static LayoutRevision fetchByPrimaryKey(long layoutRevisionId) { 2046 return getPersistence().fetchByPrimaryKey(layoutRevisionId); 2047 } 2048 2049 public static java.util.Map<java.io.Serializable, LayoutRevision> fetchByPrimaryKeys( 2050 java.util.Set<java.io.Serializable> primaryKeys) { 2051 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2052 } 2053 2054 /** 2055 * Returns all the layout revisions. 2056 * 2057 * @return the layout revisions 2058 */ 2059 public static List<LayoutRevision> findAll() { 2060 return getPersistence().findAll(); 2061 } 2062 2063 /** 2064 * Returns a range of all the layout revisions. 2065 * 2066 * <p> 2067 * 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 LayoutRevisionModelImpl}. 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. 2068 * </p> 2069 * 2070 * @param start the lower bound of the range of layout revisions 2071 * @param end the upper bound of the range of layout revisions (not inclusive) 2072 * @return the range of layout revisions 2073 */ 2074 public static List<LayoutRevision> findAll(int start, int end) { 2075 return getPersistence().findAll(start, end); 2076 } 2077 2078 /** 2079 * Returns an ordered range of all the layout revisions. 2080 * 2081 * <p> 2082 * 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 LayoutRevisionModelImpl}. 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. 2083 * </p> 2084 * 2085 * @param start the lower bound of the range of layout revisions 2086 * @param end the upper bound of the range of layout revisions (not inclusive) 2087 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2088 * @return the ordered range of layout revisions 2089 */ 2090 public static List<LayoutRevision> findAll(int start, int end, 2091 OrderByComparator<LayoutRevision> orderByComparator) { 2092 return getPersistence().findAll(start, end, orderByComparator); 2093 } 2094 2095 /** 2096 * Returns an ordered range of all the layout revisions. 2097 * 2098 * <p> 2099 * 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 LayoutRevisionModelImpl}. 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. 2100 * </p> 2101 * 2102 * @param start the lower bound of the range of layout revisions 2103 * @param end the upper bound of the range of layout revisions (not inclusive) 2104 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2105 * @param retrieveFromCache whether to retrieve from the finder cache 2106 * @return the ordered range of layout revisions 2107 */ 2108 public static List<LayoutRevision> findAll(int start, int end, 2109 OrderByComparator<LayoutRevision> orderByComparator, 2110 boolean retrieveFromCache) { 2111 return getPersistence() 2112 .findAll(start, end, orderByComparator, retrieveFromCache); 2113 } 2114 2115 /** 2116 * Removes all the layout revisions from the database. 2117 */ 2118 public static void removeAll() { 2119 getPersistence().removeAll(); 2120 } 2121 2122 /** 2123 * Returns the number of layout revisions. 2124 * 2125 * @return the number of layout revisions 2126 */ 2127 public static int countAll() { 2128 return getPersistence().countAll(); 2129 } 2130 2131 public static LayoutRevisionPersistence getPersistence() { 2132 if (_persistence == null) { 2133 _persistence = (LayoutRevisionPersistence)PortalBeanLocatorUtil.locate(LayoutRevisionPersistence.class.getName()); 2134 2135 ReferenceRegistry.registerReference(LayoutRevisionUtil.class, 2136 "_persistence"); 2137 } 2138 2139 return _persistence; 2140 } 2141 2142 private static LayoutRevisionPersistence _persistence; 2143 }