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