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