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