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