001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.Layout; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the layout service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see LayoutPersistence 037 * @see com.liferay.portal.service.persistence.impl.LayoutPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class LayoutUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(Layout layout) { 059 getPersistence().clearCache(layout); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery) { 073 return getPersistence().findWithDynamicQuery(dynamicQuery); 074 } 075 076 /** 077 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 078 */ 079 public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery, 080 int start, int end) { 081 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 082 } 083 084 /** 085 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 086 */ 087 public static List<Layout> findWithDynamicQuery(DynamicQuery dynamicQuery, 088 int start, int end, OrderByComparator<Layout> orderByComparator) { 089 return getPersistence() 090 .findWithDynamicQuery(dynamicQuery, start, end, 091 orderByComparator); 092 } 093 094 /** 095 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 096 */ 097 public static Layout update(Layout layout) { 098 return getPersistence().update(layout); 099 } 100 101 /** 102 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 103 */ 104 public static Layout update(Layout layout, ServiceContext serviceContext) { 105 return getPersistence().update(layout, serviceContext); 106 } 107 108 /** 109 * Returns all the layouts where uuid = ?. 110 * 111 * @param uuid the uuid 112 * @return the matching layouts 113 */ 114 public static List<Layout> findByUuid(java.lang.String uuid) { 115 return getPersistence().findByUuid(uuid); 116 } 117 118 /** 119 * Returns a range of all the layouts where uuid = ?. 120 * 121 * <p> 122 * 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 LayoutModelImpl}. 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. 123 * </p> 124 * 125 * @param uuid the uuid 126 * @param start the lower bound of the range of layouts 127 * @param end the upper bound of the range of layouts (not inclusive) 128 * @return the range of matching layouts 129 */ 130 public static List<Layout> findByUuid(java.lang.String uuid, int start, 131 int end) { 132 return getPersistence().findByUuid(uuid, start, end); 133 } 134 135 /** 136 * Returns an ordered range of all the layouts where uuid = ?. 137 * 138 * <p> 139 * 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 LayoutModelImpl}. 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. 140 * </p> 141 * 142 * @param uuid the uuid 143 * @param start the lower bound of the range of layouts 144 * @param end the upper bound of the range of layouts (not inclusive) 145 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 146 * @return the ordered range of matching layouts 147 */ 148 public static List<Layout> findByUuid(java.lang.String uuid, int start, 149 int end, OrderByComparator<Layout> orderByComparator) { 150 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 151 } 152 153 /** 154 * Returns an ordered range of all the layouts where uuid = ?. 155 * 156 * <p> 157 * 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 LayoutModelImpl}. 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. 158 * </p> 159 * 160 * @param uuid the uuid 161 * @param start the lower bound of the range of layouts 162 * @param end the upper bound of the range of layouts (not inclusive) 163 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 164 * @param retrieveFromCache whether to retrieve from the finder cache 165 * @return the ordered range of matching layouts 166 */ 167 public static List<Layout> findByUuid(java.lang.String uuid, int start, 168 int end, OrderByComparator<Layout> orderByComparator, 169 boolean retrieveFromCache) { 170 return getPersistence() 171 .findByUuid(uuid, start, end, orderByComparator, 172 retrieveFromCache); 173 } 174 175 /** 176 * Returns the first layout in the ordered set where uuid = ?. 177 * 178 * @param uuid the uuid 179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 180 * @return the first matching layout 181 * @throws NoSuchLayoutException if a matching layout could not be found 182 */ 183 public static Layout findByUuid_First(java.lang.String uuid, 184 OrderByComparator<Layout> orderByComparator) 185 throws com.liferay.portal.NoSuchLayoutException { 186 return getPersistence().findByUuid_First(uuid, orderByComparator); 187 } 188 189 /** 190 * Returns the first layout in the ordered set where uuid = ?. 191 * 192 * @param uuid the uuid 193 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 194 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 195 */ 196 public static Layout fetchByUuid_First(java.lang.String uuid, 197 OrderByComparator<Layout> orderByComparator) { 198 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 199 } 200 201 /** 202 * Returns the last layout in the ordered set where uuid = ?. 203 * 204 * @param uuid the uuid 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the last matching layout 207 * @throws NoSuchLayoutException if a matching layout could not be found 208 */ 209 public static Layout findByUuid_Last(java.lang.String uuid, 210 OrderByComparator<Layout> orderByComparator) 211 throws com.liferay.portal.NoSuchLayoutException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last layout in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 221 */ 222 public static Layout fetchByUuid_Last(java.lang.String uuid, 223 OrderByComparator<Layout> orderByComparator) { 224 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 225 } 226 227 /** 228 * Returns the layouts before and after the current layout in the ordered set where uuid = ?. 229 * 230 * @param plid the primary key of the current layout 231 * @param uuid the uuid 232 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 233 * @return the previous, current, and next layout 234 * @throws NoSuchLayoutException if a layout with the primary key could not be found 235 */ 236 public static Layout[] findByUuid_PrevAndNext(long plid, 237 java.lang.String uuid, OrderByComparator<Layout> orderByComparator) 238 throws com.liferay.portal.NoSuchLayoutException { 239 return getPersistence() 240 .findByUuid_PrevAndNext(plid, uuid, orderByComparator); 241 } 242 243 /** 244 * Removes all the layouts where uuid = ? from the database. 245 * 246 * @param uuid the uuid 247 */ 248 public static void removeByUuid(java.lang.String uuid) { 249 getPersistence().removeByUuid(uuid); 250 } 251 252 /** 253 * Returns the number of layouts where uuid = ?. 254 * 255 * @param uuid the uuid 256 * @return the number of matching layouts 257 */ 258 public static int countByUuid(java.lang.String uuid) { 259 return getPersistence().countByUuid(uuid); 260 } 261 262 /** 263 * Returns the layout where uuid = ? and groupId = ? and privateLayout = ? or throws a {@link NoSuchLayoutException} if it could not be found. 264 * 265 * @param uuid the uuid 266 * @param groupId the group ID 267 * @param privateLayout the private layout 268 * @return the matching layout 269 * @throws NoSuchLayoutException if a matching layout could not be found 270 */ 271 public static Layout findByUUID_G_P(java.lang.String uuid, long groupId, 272 boolean privateLayout) throws com.liferay.portal.NoSuchLayoutException { 273 return getPersistence().findByUUID_G_P(uuid, groupId, privateLayout); 274 } 275 276 /** 277 * Returns the layout where uuid = ? and groupId = ? and privateLayout = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 278 * 279 * @param uuid the uuid 280 * @param groupId the group ID 281 * @param privateLayout the private layout 282 * @return the matching layout, or <code>null</code> if a matching layout could not be found 283 */ 284 public static Layout fetchByUUID_G_P(java.lang.String uuid, long groupId, 285 boolean privateLayout) { 286 return getPersistence().fetchByUUID_G_P(uuid, groupId, privateLayout); 287 } 288 289 /** 290 * Returns the layout where uuid = ? and groupId = ? and privateLayout = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 291 * 292 * @param uuid the uuid 293 * @param groupId the group ID 294 * @param privateLayout the private layout 295 * @param retrieveFromCache whether to retrieve from the finder cache 296 * @return the matching layout, or <code>null</code> if a matching layout could not be found 297 */ 298 public static Layout fetchByUUID_G_P(java.lang.String uuid, long groupId, 299 boolean privateLayout, boolean retrieveFromCache) { 300 return getPersistence() 301 .fetchByUUID_G_P(uuid, groupId, privateLayout, 302 retrieveFromCache); 303 } 304 305 /** 306 * Removes the layout where uuid = ? and groupId = ? and privateLayout = ? from the database. 307 * 308 * @param uuid the uuid 309 * @param groupId the group ID 310 * @param privateLayout the private layout 311 * @return the layout that was removed 312 */ 313 public static Layout removeByUUID_G_P(java.lang.String uuid, long groupId, 314 boolean privateLayout) throws com.liferay.portal.NoSuchLayoutException { 315 return getPersistence().removeByUUID_G_P(uuid, groupId, privateLayout); 316 } 317 318 /** 319 * Returns the number of layouts where uuid = ? and groupId = ? and privateLayout = ?. 320 * 321 * @param uuid the uuid 322 * @param groupId the group ID 323 * @param privateLayout the private layout 324 * @return the number of matching layouts 325 */ 326 public static int countByUUID_G_P(java.lang.String uuid, long groupId, 327 boolean privateLayout) { 328 return getPersistence().countByUUID_G_P(uuid, groupId, privateLayout); 329 } 330 331 /** 332 * Returns all the layouts where uuid = ? and companyId = ?. 333 * 334 * @param uuid the uuid 335 * @param companyId the company ID 336 * @return the matching layouts 337 */ 338 public static List<Layout> findByUuid_C(java.lang.String uuid, 339 long companyId) { 340 return getPersistence().findByUuid_C(uuid, companyId); 341 } 342 343 /** 344 * Returns a range of all the layouts where uuid = ? and companyId = ?. 345 * 346 * <p> 347 * 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 LayoutModelImpl}. 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. 348 * </p> 349 * 350 * @param uuid the uuid 351 * @param companyId the company ID 352 * @param start the lower bound of the range of layouts 353 * @param end the upper bound of the range of layouts (not inclusive) 354 * @return the range of matching layouts 355 */ 356 public static List<Layout> findByUuid_C(java.lang.String uuid, 357 long companyId, int start, int end) { 358 return getPersistence().findByUuid_C(uuid, companyId, start, end); 359 } 360 361 /** 362 * Returns an ordered range of all the layouts where uuid = ? and companyId = ?. 363 * 364 * <p> 365 * 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 LayoutModelImpl}. 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. 366 * </p> 367 * 368 * @param uuid the uuid 369 * @param companyId the company ID 370 * @param start the lower bound of the range of layouts 371 * @param end the upper bound of the range of layouts (not inclusive) 372 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 373 * @return the ordered range of matching layouts 374 */ 375 public static List<Layout> findByUuid_C(java.lang.String uuid, 376 long companyId, int start, int end, 377 OrderByComparator<Layout> orderByComparator) { 378 return getPersistence() 379 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 380 } 381 382 /** 383 * Returns an ordered range of all the layouts where uuid = ? and companyId = ?. 384 * 385 * <p> 386 * 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 LayoutModelImpl}. 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. 387 * </p> 388 * 389 * @param uuid the uuid 390 * @param companyId the company ID 391 * @param start the lower bound of the range of layouts 392 * @param end the upper bound of the range of layouts (not inclusive) 393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 394 * @param retrieveFromCache whether to retrieve from the finder cache 395 * @return the ordered range of matching layouts 396 */ 397 public static List<Layout> findByUuid_C(java.lang.String uuid, 398 long companyId, int start, int end, 399 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 400 return getPersistence() 401 .findByUuid_C(uuid, companyId, start, end, 402 orderByComparator, retrieveFromCache); 403 } 404 405 /** 406 * Returns the first layout in the ordered set where uuid = ? and companyId = ?. 407 * 408 * @param uuid the uuid 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the first matching layout 412 * @throws NoSuchLayoutException if a matching layout could not be found 413 */ 414 public static Layout findByUuid_C_First(java.lang.String uuid, 415 long companyId, OrderByComparator<Layout> orderByComparator) 416 throws com.liferay.portal.NoSuchLayoutException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first layout in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 428 */ 429 public static Layout fetchByUuid_C_First(java.lang.String uuid, 430 long companyId, OrderByComparator<Layout> orderByComparator) { 431 return getPersistence() 432 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 433 } 434 435 /** 436 * Returns the last layout in the ordered set where uuid = ? and companyId = ?. 437 * 438 * @param uuid the uuid 439 * @param companyId the company ID 440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 441 * @return the last matching layout 442 * @throws NoSuchLayoutException if a matching layout could not be found 443 */ 444 public static Layout findByUuid_C_Last(java.lang.String uuid, 445 long companyId, OrderByComparator<Layout> orderByComparator) 446 throws com.liferay.portal.NoSuchLayoutException { 447 return getPersistence() 448 .findByUuid_C_Last(uuid, companyId, orderByComparator); 449 } 450 451 /** 452 * Returns the last layout in the ordered set where uuid = ? and companyId = ?. 453 * 454 * @param uuid the uuid 455 * @param companyId the company ID 456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 457 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 458 */ 459 public static Layout fetchByUuid_C_Last(java.lang.String uuid, 460 long companyId, OrderByComparator<Layout> orderByComparator) { 461 return getPersistence() 462 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 463 } 464 465 /** 466 * Returns the layouts before and after the current layout in the ordered set where uuid = ? and companyId = ?. 467 * 468 * @param plid the primary key of the current layout 469 * @param uuid the uuid 470 * @param companyId the company ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the previous, current, and next layout 473 * @throws NoSuchLayoutException if a layout with the primary key could not be found 474 */ 475 public static Layout[] findByUuid_C_PrevAndNext(long plid, 476 java.lang.String uuid, long companyId, 477 OrderByComparator<Layout> orderByComparator) 478 throws com.liferay.portal.NoSuchLayoutException { 479 return getPersistence() 480 .findByUuid_C_PrevAndNext(plid, uuid, companyId, 481 orderByComparator); 482 } 483 484 /** 485 * Removes all the layouts where uuid = ? and companyId = ? from the database. 486 * 487 * @param uuid the uuid 488 * @param companyId the company ID 489 */ 490 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 491 getPersistence().removeByUuid_C(uuid, companyId); 492 } 493 494 /** 495 * Returns the number of layouts where uuid = ? and companyId = ?. 496 * 497 * @param uuid the uuid 498 * @param companyId the company ID 499 * @return the number of matching layouts 500 */ 501 public static int countByUuid_C(java.lang.String uuid, long companyId) { 502 return getPersistence().countByUuid_C(uuid, companyId); 503 } 504 505 /** 506 * Returns all the layouts where groupId = ?. 507 * 508 * @param groupId the group ID 509 * @return the matching layouts 510 */ 511 public static List<Layout> findByGroupId(long groupId) { 512 return getPersistence().findByGroupId(groupId); 513 } 514 515 /** 516 * Returns a range of all the layouts where groupId = ?. 517 * 518 * <p> 519 * 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 LayoutModelImpl}. 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. 520 * </p> 521 * 522 * @param groupId the group ID 523 * @param start the lower bound of the range of layouts 524 * @param end the upper bound of the range of layouts (not inclusive) 525 * @return the range of matching layouts 526 */ 527 public static List<Layout> findByGroupId(long groupId, int start, int end) { 528 return getPersistence().findByGroupId(groupId, start, end); 529 } 530 531 /** 532 * Returns an ordered range of all the layouts where groupId = ?. 533 * 534 * <p> 535 * 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 LayoutModelImpl}. 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. 536 * </p> 537 * 538 * @param groupId the group ID 539 * @param start the lower bound of the range of layouts 540 * @param end the upper bound of the range of layouts (not inclusive) 541 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 542 * @return the ordered range of matching layouts 543 */ 544 public static List<Layout> findByGroupId(long groupId, int start, int end, 545 OrderByComparator<Layout> orderByComparator) { 546 return getPersistence() 547 .findByGroupId(groupId, start, end, orderByComparator); 548 } 549 550 /** 551 * Returns an ordered range of all the layouts where groupId = ?. 552 * 553 * <p> 554 * 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 LayoutModelImpl}. 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. 555 * </p> 556 * 557 * @param groupId the group ID 558 * @param start the lower bound of the range of layouts 559 * @param end the upper bound of the range of layouts (not inclusive) 560 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 561 * @param retrieveFromCache whether to retrieve from the finder cache 562 * @return the ordered range of matching layouts 563 */ 564 public static List<Layout> findByGroupId(long groupId, int start, int end, 565 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 566 return getPersistence() 567 .findByGroupId(groupId, start, end, orderByComparator, 568 retrieveFromCache); 569 } 570 571 /** 572 * Returns the first layout in the ordered set where groupId = ?. 573 * 574 * @param groupId the group ID 575 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 576 * @return the first matching layout 577 * @throws NoSuchLayoutException if a matching layout could not be found 578 */ 579 public static Layout findByGroupId_First(long groupId, 580 OrderByComparator<Layout> orderByComparator) 581 throws com.liferay.portal.NoSuchLayoutException { 582 return getPersistence().findByGroupId_First(groupId, orderByComparator); 583 } 584 585 /** 586 * Returns the first layout in the ordered set where groupId = ?. 587 * 588 * @param groupId the group ID 589 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 590 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 591 */ 592 public static Layout fetchByGroupId_First(long groupId, 593 OrderByComparator<Layout> orderByComparator) { 594 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 595 } 596 597 /** 598 * Returns the last layout in the ordered set where groupId = ?. 599 * 600 * @param groupId the group ID 601 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 602 * @return the last matching layout 603 * @throws NoSuchLayoutException if a matching layout could not be found 604 */ 605 public static Layout findByGroupId_Last(long groupId, 606 OrderByComparator<Layout> orderByComparator) 607 throws com.liferay.portal.NoSuchLayoutException { 608 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 609 } 610 611 /** 612 * Returns the last layout in the ordered set where groupId = ?. 613 * 614 * @param groupId the group ID 615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 616 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 617 */ 618 public static Layout fetchByGroupId_Last(long groupId, 619 OrderByComparator<Layout> orderByComparator) { 620 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the layouts before and after the current layout in the ordered set where groupId = ?. 625 * 626 * @param plid the primary key of the current layout 627 * @param groupId the group ID 628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 629 * @return the previous, current, and next layout 630 * @throws NoSuchLayoutException if a layout with the primary key could not be found 631 */ 632 public static Layout[] findByGroupId_PrevAndNext(long plid, long groupId, 633 OrderByComparator<Layout> orderByComparator) 634 throws com.liferay.portal.NoSuchLayoutException { 635 return getPersistence() 636 .findByGroupId_PrevAndNext(plid, groupId, orderByComparator); 637 } 638 639 /** 640 * Returns all the layouts that the user has permission to view where groupId = ?. 641 * 642 * @param groupId the group ID 643 * @return the matching layouts that the user has permission to view 644 */ 645 public static List<Layout> filterFindByGroupId(long groupId) { 646 return getPersistence().filterFindByGroupId(groupId); 647 } 648 649 /** 650 * Returns a range of all the layouts that the user has permission to view where groupId = ?. 651 * 652 * <p> 653 * 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 LayoutModelImpl}. 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. 654 * </p> 655 * 656 * @param groupId the group ID 657 * @param start the lower bound of the range of layouts 658 * @param end the upper bound of the range of layouts (not inclusive) 659 * @return the range of matching layouts that the user has permission to view 660 */ 661 public static List<Layout> filterFindByGroupId(long groupId, int start, 662 int end) { 663 return getPersistence().filterFindByGroupId(groupId, start, end); 664 } 665 666 /** 667 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ?. 668 * 669 * <p> 670 * 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 LayoutModelImpl}. 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. 671 * </p> 672 * 673 * @param groupId the group ID 674 * @param start the lower bound of the range of layouts 675 * @param end the upper bound of the range of layouts (not inclusive) 676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 677 * @return the ordered range of matching layouts that the user has permission to view 678 */ 679 public static List<Layout> filterFindByGroupId(long groupId, int start, 680 int end, OrderByComparator<Layout> orderByComparator) { 681 return getPersistence() 682 .filterFindByGroupId(groupId, start, end, orderByComparator); 683 } 684 685 /** 686 * Returns the layouts before and after the current layout in the ordered set of layouts that the user has permission to view where groupId = ?. 687 * 688 * @param plid the primary key of the current layout 689 * @param groupId the group ID 690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 691 * @return the previous, current, and next layout 692 * @throws NoSuchLayoutException if a layout with the primary key could not be found 693 */ 694 public static Layout[] filterFindByGroupId_PrevAndNext(long plid, 695 long groupId, OrderByComparator<Layout> orderByComparator) 696 throws com.liferay.portal.NoSuchLayoutException { 697 return getPersistence() 698 .filterFindByGroupId_PrevAndNext(plid, groupId, 699 orderByComparator); 700 } 701 702 /** 703 * Removes all the layouts where groupId = ? from the database. 704 * 705 * @param groupId the group ID 706 */ 707 public static void removeByGroupId(long groupId) { 708 getPersistence().removeByGroupId(groupId); 709 } 710 711 /** 712 * Returns the number of layouts where groupId = ?. 713 * 714 * @param groupId the group ID 715 * @return the number of matching layouts 716 */ 717 public static int countByGroupId(long groupId) { 718 return getPersistence().countByGroupId(groupId); 719 } 720 721 /** 722 * Returns the number of layouts that the user has permission to view where groupId = ?. 723 * 724 * @param groupId the group ID 725 * @return the number of matching layouts that the user has permission to view 726 */ 727 public static int filterCountByGroupId(long groupId) { 728 return getPersistence().filterCountByGroupId(groupId); 729 } 730 731 /** 732 * Returns all the layouts where companyId = ?. 733 * 734 * @param companyId the company ID 735 * @return the matching layouts 736 */ 737 public static List<Layout> findByCompanyId(long companyId) { 738 return getPersistence().findByCompanyId(companyId); 739 } 740 741 /** 742 * Returns a range of all the layouts where companyId = ?. 743 * 744 * <p> 745 * 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 LayoutModelImpl}. 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. 746 * </p> 747 * 748 * @param companyId the company ID 749 * @param start the lower bound of the range of layouts 750 * @param end the upper bound of the range of layouts (not inclusive) 751 * @return the range of matching layouts 752 */ 753 public static List<Layout> findByCompanyId(long companyId, int start, 754 int end) { 755 return getPersistence().findByCompanyId(companyId, start, end); 756 } 757 758 /** 759 * Returns an ordered range of all the layouts where companyId = ?. 760 * 761 * <p> 762 * 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 LayoutModelImpl}. 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. 763 * </p> 764 * 765 * @param companyId the company ID 766 * @param start the lower bound of the range of layouts 767 * @param end the upper bound of the range of layouts (not inclusive) 768 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 769 * @return the ordered range of matching layouts 770 */ 771 public static List<Layout> findByCompanyId(long companyId, int start, 772 int end, OrderByComparator<Layout> orderByComparator) { 773 return getPersistence() 774 .findByCompanyId(companyId, start, end, orderByComparator); 775 } 776 777 /** 778 * Returns an ordered range of all the layouts where companyId = ?. 779 * 780 * <p> 781 * 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 LayoutModelImpl}. 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. 782 * </p> 783 * 784 * @param companyId the company ID 785 * @param start the lower bound of the range of layouts 786 * @param end the upper bound of the range of layouts (not inclusive) 787 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 788 * @param retrieveFromCache whether to retrieve from the finder cache 789 * @return the ordered range of matching layouts 790 */ 791 public static List<Layout> findByCompanyId(long companyId, int start, 792 int end, OrderByComparator<Layout> orderByComparator, 793 boolean retrieveFromCache) { 794 return getPersistence() 795 .findByCompanyId(companyId, start, end, orderByComparator, 796 retrieveFromCache); 797 } 798 799 /** 800 * Returns the first layout in the ordered set where companyId = ?. 801 * 802 * @param companyId the company ID 803 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 804 * @return the first matching layout 805 * @throws NoSuchLayoutException if a matching layout could not be found 806 */ 807 public static Layout findByCompanyId_First(long companyId, 808 OrderByComparator<Layout> orderByComparator) 809 throws com.liferay.portal.NoSuchLayoutException { 810 return getPersistence() 811 .findByCompanyId_First(companyId, orderByComparator); 812 } 813 814 /** 815 * Returns the first layout in the ordered set where companyId = ?. 816 * 817 * @param companyId the company ID 818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 819 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 820 */ 821 public static Layout fetchByCompanyId_First(long companyId, 822 OrderByComparator<Layout> orderByComparator) { 823 return getPersistence() 824 .fetchByCompanyId_First(companyId, orderByComparator); 825 } 826 827 /** 828 * Returns the last layout in the ordered set where companyId = ?. 829 * 830 * @param companyId the company ID 831 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 832 * @return the last matching layout 833 * @throws NoSuchLayoutException if a matching layout could not be found 834 */ 835 public static Layout findByCompanyId_Last(long companyId, 836 OrderByComparator<Layout> orderByComparator) 837 throws com.liferay.portal.NoSuchLayoutException { 838 return getPersistence() 839 .findByCompanyId_Last(companyId, orderByComparator); 840 } 841 842 /** 843 * Returns the last layout in the ordered set where companyId = ?. 844 * 845 * @param companyId the company ID 846 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 847 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 848 */ 849 public static Layout fetchByCompanyId_Last(long companyId, 850 OrderByComparator<Layout> orderByComparator) { 851 return getPersistence() 852 .fetchByCompanyId_Last(companyId, orderByComparator); 853 } 854 855 /** 856 * Returns the layouts before and after the current layout in the ordered set where companyId = ?. 857 * 858 * @param plid the primary key of the current layout 859 * @param companyId the company ID 860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 861 * @return the previous, current, and next layout 862 * @throws NoSuchLayoutException if a layout with the primary key could not be found 863 */ 864 public static Layout[] findByCompanyId_PrevAndNext(long plid, 865 long companyId, OrderByComparator<Layout> orderByComparator) 866 throws com.liferay.portal.NoSuchLayoutException { 867 return getPersistence() 868 .findByCompanyId_PrevAndNext(plid, companyId, 869 orderByComparator); 870 } 871 872 /** 873 * Removes all the layouts where companyId = ? from the database. 874 * 875 * @param companyId the company ID 876 */ 877 public static void removeByCompanyId(long companyId) { 878 getPersistence().removeByCompanyId(companyId); 879 } 880 881 /** 882 * Returns the number of layouts where companyId = ?. 883 * 884 * @param companyId the company ID 885 * @return the number of matching layouts 886 */ 887 public static int countByCompanyId(long companyId) { 888 return getPersistence().countByCompanyId(companyId); 889 } 890 891 /** 892 * Returns the layout where iconImageId = ? or throws a {@link NoSuchLayoutException} if it could not be found. 893 * 894 * @param iconImageId the icon image ID 895 * @return the matching layout 896 * @throws NoSuchLayoutException if a matching layout could not be found 897 */ 898 public static Layout findByIconImageId(long iconImageId) 899 throws com.liferay.portal.NoSuchLayoutException { 900 return getPersistence().findByIconImageId(iconImageId); 901 } 902 903 /** 904 * Returns the layout where iconImageId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 905 * 906 * @param iconImageId the icon image ID 907 * @return the matching layout, or <code>null</code> if a matching layout could not be found 908 */ 909 public static Layout fetchByIconImageId(long iconImageId) { 910 return getPersistence().fetchByIconImageId(iconImageId); 911 } 912 913 /** 914 * Returns the layout where iconImageId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 915 * 916 * @param iconImageId the icon image ID 917 * @param retrieveFromCache whether to retrieve from the finder cache 918 * @return the matching layout, or <code>null</code> if a matching layout could not be found 919 */ 920 public static Layout fetchByIconImageId(long iconImageId, 921 boolean retrieveFromCache) { 922 return getPersistence() 923 .fetchByIconImageId(iconImageId, retrieveFromCache); 924 } 925 926 /** 927 * Removes the layout where iconImageId = ? from the database. 928 * 929 * @param iconImageId the icon image ID 930 * @return the layout that was removed 931 */ 932 public static Layout removeByIconImageId(long iconImageId) 933 throws com.liferay.portal.NoSuchLayoutException { 934 return getPersistence().removeByIconImageId(iconImageId); 935 } 936 937 /** 938 * Returns the number of layouts where iconImageId = ?. 939 * 940 * @param iconImageId the icon image ID 941 * @return the number of matching layouts 942 */ 943 public static int countByIconImageId(long iconImageId) { 944 return getPersistence().countByIconImageId(iconImageId); 945 } 946 947 /** 948 * Returns all the layouts where layoutPrototypeUuid = ?. 949 * 950 * @param layoutPrototypeUuid the layout prototype uuid 951 * @return the matching layouts 952 */ 953 public static List<Layout> findByLayoutPrototypeUuid( 954 java.lang.String layoutPrototypeUuid) { 955 return getPersistence().findByLayoutPrototypeUuid(layoutPrototypeUuid); 956 } 957 958 /** 959 * Returns a range of all the layouts where layoutPrototypeUuid = ?. 960 * 961 * <p> 962 * 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 LayoutModelImpl}. 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. 963 * </p> 964 * 965 * @param layoutPrototypeUuid the layout prototype uuid 966 * @param start the lower bound of the range of layouts 967 * @param end the upper bound of the range of layouts (not inclusive) 968 * @return the range of matching layouts 969 */ 970 public static List<Layout> findByLayoutPrototypeUuid( 971 java.lang.String layoutPrototypeUuid, int start, int end) { 972 return getPersistence() 973 .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end); 974 } 975 976 /** 977 * Returns an ordered range of all the layouts where layoutPrototypeUuid = ?. 978 * 979 * <p> 980 * 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 LayoutModelImpl}. 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. 981 * </p> 982 * 983 * @param layoutPrototypeUuid the layout prototype uuid 984 * @param start the lower bound of the range of layouts 985 * @param end the upper bound of the range of layouts (not inclusive) 986 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 987 * @return the ordered range of matching layouts 988 */ 989 public static List<Layout> findByLayoutPrototypeUuid( 990 java.lang.String layoutPrototypeUuid, int start, int end, 991 OrderByComparator<Layout> orderByComparator) { 992 return getPersistence() 993 .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end, 994 orderByComparator); 995 } 996 997 /** 998 * Returns an ordered range of all the layouts where layoutPrototypeUuid = ?. 999 * 1000 * <p> 1001 * 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 LayoutModelImpl}. 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. 1002 * </p> 1003 * 1004 * @param layoutPrototypeUuid the layout prototype uuid 1005 * @param start the lower bound of the range of layouts 1006 * @param end the upper bound of the range of layouts (not inclusive) 1007 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1008 * @param retrieveFromCache whether to retrieve from the finder cache 1009 * @return the ordered range of matching layouts 1010 */ 1011 public static List<Layout> findByLayoutPrototypeUuid( 1012 java.lang.String layoutPrototypeUuid, int start, int end, 1013 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 1014 return getPersistence() 1015 .findByLayoutPrototypeUuid(layoutPrototypeUuid, start, end, 1016 orderByComparator, retrieveFromCache); 1017 } 1018 1019 /** 1020 * Returns the first layout in the ordered set where layoutPrototypeUuid = ?. 1021 * 1022 * @param layoutPrototypeUuid the layout prototype uuid 1023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1024 * @return the first matching layout 1025 * @throws NoSuchLayoutException if a matching layout could not be found 1026 */ 1027 public static Layout findByLayoutPrototypeUuid_First( 1028 java.lang.String layoutPrototypeUuid, 1029 OrderByComparator<Layout> orderByComparator) 1030 throws com.liferay.portal.NoSuchLayoutException { 1031 return getPersistence() 1032 .findByLayoutPrototypeUuid_First(layoutPrototypeUuid, 1033 orderByComparator); 1034 } 1035 1036 /** 1037 * Returns the first layout in the ordered set where layoutPrototypeUuid = ?. 1038 * 1039 * @param layoutPrototypeUuid the layout prototype uuid 1040 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1041 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1042 */ 1043 public static Layout fetchByLayoutPrototypeUuid_First( 1044 java.lang.String layoutPrototypeUuid, 1045 OrderByComparator<Layout> orderByComparator) { 1046 return getPersistence() 1047 .fetchByLayoutPrototypeUuid_First(layoutPrototypeUuid, 1048 orderByComparator); 1049 } 1050 1051 /** 1052 * Returns the last layout in the ordered set where layoutPrototypeUuid = ?. 1053 * 1054 * @param layoutPrototypeUuid the layout prototype uuid 1055 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1056 * @return the last matching layout 1057 * @throws NoSuchLayoutException if a matching layout could not be found 1058 */ 1059 public static Layout findByLayoutPrototypeUuid_Last( 1060 java.lang.String layoutPrototypeUuid, 1061 OrderByComparator<Layout> orderByComparator) 1062 throws com.liferay.portal.NoSuchLayoutException { 1063 return getPersistence() 1064 .findByLayoutPrototypeUuid_Last(layoutPrototypeUuid, 1065 orderByComparator); 1066 } 1067 1068 /** 1069 * Returns the last layout in the ordered set where layoutPrototypeUuid = ?. 1070 * 1071 * @param layoutPrototypeUuid the layout prototype uuid 1072 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1073 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1074 */ 1075 public static Layout fetchByLayoutPrototypeUuid_Last( 1076 java.lang.String layoutPrototypeUuid, 1077 OrderByComparator<Layout> orderByComparator) { 1078 return getPersistence() 1079 .fetchByLayoutPrototypeUuid_Last(layoutPrototypeUuid, 1080 orderByComparator); 1081 } 1082 1083 /** 1084 * Returns the layouts before and after the current layout in the ordered set where layoutPrototypeUuid = ?. 1085 * 1086 * @param plid the primary key of the current layout 1087 * @param layoutPrototypeUuid the layout prototype uuid 1088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1089 * @return the previous, current, and next layout 1090 * @throws NoSuchLayoutException if a layout with the primary key could not be found 1091 */ 1092 public static Layout[] findByLayoutPrototypeUuid_PrevAndNext(long plid, 1093 java.lang.String layoutPrototypeUuid, 1094 OrderByComparator<Layout> orderByComparator) 1095 throws com.liferay.portal.NoSuchLayoutException { 1096 return getPersistence() 1097 .findByLayoutPrototypeUuid_PrevAndNext(plid, 1098 layoutPrototypeUuid, orderByComparator); 1099 } 1100 1101 /** 1102 * Removes all the layouts where layoutPrototypeUuid = ? from the database. 1103 * 1104 * @param layoutPrototypeUuid the layout prototype uuid 1105 */ 1106 public static void removeByLayoutPrototypeUuid( 1107 java.lang.String layoutPrototypeUuid) { 1108 getPersistence().removeByLayoutPrototypeUuid(layoutPrototypeUuid); 1109 } 1110 1111 /** 1112 * Returns the number of layouts where layoutPrototypeUuid = ?. 1113 * 1114 * @param layoutPrototypeUuid the layout prototype uuid 1115 * @return the number of matching layouts 1116 */ 1117 public static int countByLayoutPrototypeUuid( 1118 java.lang.String layoutPrototypeUuid) { 1119 return getPersistence().countByLayoutPrototypeUuid(layoutPrototypeUuid); 1120 } 1121 1122 /** 1123 * Returns all the layouts where sourcePrototypeLayoutUuid = ?. 1124 * 1125 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1126 * @return the matching layouts 1127 */ 1128 public static List<Layout> findBySourcePrototypeLayoutUuid( 1129 java.lang.String sourcePrototypeLayoutUuid) { 1130 return getPersistence() 1131 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid); 1132 } 1133 1134 /** 1135 * Returns a range of all the layouts where sourcePrototypeLayoutUuid = ?. 1136 * 1137 * <p> 1138 * 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 LayoutModelImpl}. 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. 1139 * </p> 1140 * 1141 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1142 * @param start the lower bound of the range of layouts 1143 * @param end the upper bound of the range of layouts (not inclusive) 1144 * @return the range of matching layouts 1145 */ 1146 public static List<Layout> findBySourcePrototypeLayoutUuid( 1147 java.lang.String sourcePrototypeLayoutUuid, int start, int end) { 1148 return getPersistence() 1149 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid, 1150 start, end); 1151 } 1152 1153 /** 1154 * Returns an ordered range of all the layouts where sourcePrototypeLayoutUuid = ?. 1155 * 1156 * <p> 1157 * 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 LayoutModelImpl}. 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. 1158 * </p> 1159 * 1160 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1161 * @param start the lower bound of the range of layouts 1162 * @param end the upper bound of the range of layouts (not inclusive) 1163 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1164 * @return the ordered range of matching layouts 1165 */ 1166 public static List<Layout> findBySourcePrototypeLayoutUuid( 1167 java.lang.String sourcePrototypeLayoutUuid, int start, int end, 1168 OrderByComparator<Layout> orderByComparator) { 1169 return getPersistence() 1170 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid, 1171 start, end, orderByComparator); 1172 } 1173 1174 /** 1175 * Returns an ordered range of all the layouts where sourcePrototypeLayoutUuid = ?. 1176 * 1177 * <p> 1178 * 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 LayoutModelImpl}. 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. 1179 * </p> 1180 * 1181 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1182 * @param start the lower bound of the range of layouts 1183 * @param end the upper bound of the range of layouts (not inclusive) 1184 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1185 * @param retrieveFromCache whether to retrieve from the finder cache 1186 * @return the ordered range of matching layouts 1187 */ 1188 public static List<Layout> findBySourcePrototypeLayoutUuid( 1189 java.lang.String sourcePrototypeLayoutUuid, int start, int end, 1190 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 1191 return getPersistence() 1192 .findBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid, 1193 start, end, orderByComparator, retrieveFromCache); 1194 } 1195 1196 /** 1197 * Returns the first layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1198 * 1199 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1201 * @return the first matching layout 1202 * @throws NoSuchLayoutException if a matching layout could not be found 1203 */ 1204 public static Layout findBySourcePrototypeLayoutUuid_First( 1205 java.lang.String sourcePrototypeLayoutUuid, 1206 OrderByComparator<Layout> orderByComparator) 1207 throws com.liferay.portal.NoSuchLayoutException { 1208 return getPersistence() 1209 .findBySourcePrototypeLayoutUuid_First(sourcePrototypeLayoutUuid, 1210 orderByComparator); 1211 } 1212 1213 /** 1214 * Returns the first layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1215 * 1216 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1217 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1218 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1219 */ 1220 public static Layout fetchBySourcePrototypeLayoutUuid_First( 1221 java.lang.String sourcePrototypeLayoutUuid, 1222 OrderByComparator<Layout> orderByComparator) { 1223 return getPersistence() 1224 .fetchBySourcePrototypeLayoutUuid_First(sourcePrototypeLayoutUuid, 1225 orderByComparator); 1226 } 1227 1228 /** 1229 * Returns the last layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1230 * 1231 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1232 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1233 * @return the last matching layout 1234 * @throws NoSuchLayoutException if a matching layout could not be found 1235 */ 1236 public static Layout findBySourcePrototypeLayoutUuid_Last( 1237 java.lang.String sourcePrototypeLayoutUuid, 1238 OrderByComparator<Layout> orderByComparator) 1239 throws com.liferay.portal.NoSuchLayoutException { 1240 return getPersistence() 1241 .findBySourcePrototypeLayoutUuid_Last(sourcePrototypeLayoutUuid, 1242 orderByComparator); 1243 } 1244 1245 /** 1246 * Returns the last layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1247 * 1248 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1249 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1250 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1251 */ 1252 public static Layout fetchBySourcePrototypeLayoutUuid_Last( 1253 java.lang.String sourcePrototypeLayoutUuid, 1254 OrderByComparator<Layout> orderByComparator) { 1255 return getPersistence() 1256 .fetchBySourcePrototypeLayoutUuid_Last(sourcePrototypeLayoutUuid, 1257 orderByComparator); 1258 } 1259 1260 /** 1261 * Returns the layouts before and after the current layout in the ordered set where sourcePrototypeLayoutUuid = ?. 1262 * 1263 * @param plid the primary key of the current layout 1264 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1265 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1266 * @return the previous, current, and next layout 1267 * @throws NoSuchLayoutException if a layout with the primary key could not be found 1268 */ 1269 public static Layout[] findBySourcePrototypeLayoutUuid_PrevAndNext( 1270 long plid, java.lang.String sourcePrototypeLayoutUuid, 1271 OrderByComparator<Layout> orderByComparator) 1272 throws com.liferay.portal.NoSuchLayoutException { 1273 return getPersistence() 1274 .findBySourcePrototypeLayoutUuid_PrevAndNext(plid, 1275 sourcePrototypeLayoutUuid, orderByComparator); 1276 } 1277 1278 /** 1279 * Removes all the layouts where sourcePrototypeLayoutUuid = ? from the database. 1280 * 1281 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1282 */ 1283 public static void removeBySourcePrototypeLayoutUuid( 1284 java.lang.String sourcePrototypeLayoutUuid) { 1285 getPersistence() 1286 .removeBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid); 1287 } 1288 1289 /** 1290 * Returns the number of layouts where sourcePrototypeLayoutUuid = ?. 1291 * 1292 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 1293 * @return the number of matching layouts 1294 */ 1295 public static int countBySourcePrototypeLayoutUuid( 1296 java.lang.String sourcePrototypeLayoutUuid) { 1297 return getPersistence() 1298 .countBySourcePrototypeLayoutUuid(sourcePrototypeLayoutUuid); 1299 } 1300 1301 /** 1302 * Returns all the layouts where groupId = ? and privateLayout = ?. 1303 * 1304 * @param groupId the group ID 1305 * @param privateLayout the private layout 1306 * @return the matching layouts 1307 */ 1308 public static List<Layout> findByG_P(long groupId, boolean privateLayout) { 1309 return getPersistence().findByG_P(groupId, privateLayout); 1310 } 1311 1312 /** 1313 * Returns a range of all the layouts where groupId = ? and privateLayout = ?. 1314 * 1315 * <p> 1316 * 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 LayoutModelImpl}. 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. 1317 * </p> 1318 * 1319 * @param groupId the group ID 1320 * @param privateLayout the private layout 1321 * @param start the lower bound of the range of layouts 1322 * @param end the upper bound of the range of layouts (not inclusive) 1323 * @return the range of matching layouts 1324 */ 1325 public static List<Layout> findByG_P(long groupId, boolean privateLayout, 1326 int start, int end) { 1327 return getPersistence().findByG_P(groupId, privateLayout, start, end); 1328 } 1329 1330 /** 1331 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ?. 1332 * 1333 * <p> 1334 * 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 LayoutModelImpl}. 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. 1335 * </p> 1336 * 1337 * @param groupId the group ID 1338 * @param privateLayout the private layout 1339 * @param start the lower bound of the range of layouts 1340 * @param end the upper bound of the range of layouts (not inclusive) 1341 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1342 * @return the ordered range of matching layouts 1343 */ 1344 public static List<Layout> findByG_P(long groupId, boolean privateLayout, 1345 int start, int end, OrderByComparator<Layout> orderByComparator) { 1346 return getPersistence() 1347 .findByG_P(groupId, privateLayout, start, end, 1348 orderByComparator); 1349 } 1350 1351 /** 1352 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ?. 1353 * 1354 * <p> 1355 * 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 LayoutModelImpl}. 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. 1356 * </p> 1357 * 1358 * @param groupId the group ID 1359 * @param privateLayout the private layout 1360 * @param start the lower bound of the range of layouts 1361 * @param end the upper bound of the range of layouts (not inclusive) 1362 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1363 * @param retrieveFromCache whether to retrieve from the finder cache 1364 * @return the ordered range of matching layouts 1365 */ 1366 public static List<Layout> findByG_P(long groupId, boolean privateLayout, 1367 int start, int end, OrderByComparator<Layout> orderByComparator, 1368 boolean retrieveFromCache) { 1369 return getPersistence() 1370 .findByG_P(groupId, privateLayout, start, end, 1371 orderByComparator, retrieveFromCache); 1372 } 1373 1374 /** 1375 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ?. 1376 * 1377 * @param groupId the group ID 1378 * @param privateLayout the private layout 1379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1380 * @return the first matching layout 1381 * @throws NoSuchLayoutException if a matching layout could not be found 1382 */ 1383 public static Layout findByG_P_First(long groupId, boolean privateLayout, 1384 OrderByComparator<Layout> orderByComparator) 1385 throws com.liferay.portal.NoSuchLayoutException { 1386 return getPersistence() 1387 .findByG_P_First(groupId, privateLayout, orderByComparator); 1388 } 1389 1390 /** 1391 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ?. 1392 * 1393 * @param groupId the group ID 1394 * @param privateLayout the private layout 1395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1396 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1397 */ 1398 public static Layout fetchByG_P_First(long groupId, boolean privateLayout, 1399 OrderByComparator<Layout> orderByComparator) { 1400 return getPersistence() 1401 .fetchByG_P_First(groupId, privateLayout, orderByComparator); 1402 } 1403 1404 /** 1405 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ?. 1406 * 1407 * @param groupId the group ID 1408 * @param privateLayout the private layout 1409 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1410 * @return the last matching layout 1411 * @throws NoSuchLayoutException if a matching layout could not be found 1412 */ 1413 public static Layout findByG_P_Last(long groupId, boolean privateLayout, 1414 OrderByComparator<Layout> orderByComparator) 1415 throws com.liferay.portal.NoSuchLayoutException { 1416 return getPersistence() 1417 .findByG_P_Last(groupId, privateLayout, orderByComparator); 1418 } 1419 1420 /** 1421 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ?. 1422 * 1423 * @param groupId the group ID 1424 * @param privateLayout the private layout 1425 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1426 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1427 */ 1428 public static Layout fetchByG_P_Last(long groupId, boolean privateLayout, 1429 OrderByComparator<Layout> orderByComparator) { 1430 return getPersistence() 1431 .fetchByG_P_Last(groupId, privateLayout, orderByComparator); 1432 } 1433 1434 /** 1435 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ?. 1436 * 1437 * @param plid the primary key of the current layout 1438 * @param groupId the group ID 1439 * @param privateLayout the private layout 1440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1441 * @return the previous, current, and next layout 1442 * @throws NoSuchLayoutException if a layout with the primary key could not be found 1443 */ 1444 public static Layout[] findByG_P_PrevAndNext(long plid, long groupId, 1445 boolean privateLayout, OrderByComparator<Layout> orderByComparator) 1446 throws com.liferay.portal.NoSuchLayoutException { 1447 return getPersistence() 1448 .findByG_P_PrevAndNext(plid, groupId, privateLayout, 1449 orderByComparator); 1450 } 1451 1452 /** 1453 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1454 * 1455 * @param groupId the group ID 1456 * @param privateLayout the private layout 1457 * @return the matching layouts that the user has permission to view 1458 */ 1459 public static List<Layout> filterFindByG_P(long groupId, 1460 boolean privateLayout) { 1461 return getPersistence().filterFindByG_P(groupId, privateLayout); 1462 } 1463 1464 /** 1465 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1466 * 1467 * <p> 1468 * 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 LayoutModelImpl}. 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. 1469 * </p> 1470 * 1471 * @param groupId the group ID 1472 * @param privateLayout the private layout 1473 * @param start the lower bound of the range of layouts 1474 * @param end the upper bound of the range of layouts (not inclusive) 1475 * @return the range of matching layouts that the user has permission to view 1476 */ 1477 public static List<Layout> filterFindByG_P(long groupId, 1478 boolean privateLayout, int start, int end) { 1479 return getPersistence() 1480 .filterFindByG_P(groupId, privateLayout, start, end); 1481 } 1482 1483 /** 1484 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ?. 1485 * 1486 * <p> 1487 * 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 LayoutModelImpl}. 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. 1488 * </p> 1489 * 1490 * @param groupId the group ID 1491 * @param privateLayout the private layout 1492 * @param start the lower bound of the range of layouts 1493 * @param end the upper bound of the range of layouts (not inclusive) 1494 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1495 * @return the ordered range of matching layouts that the user has permission to view 1496 */ 1497 public static List<Layout> filterFindByG_P(long groupId, 1498 boolean privateLayout, int start, int end, 1499 OrderByComparator<Layout> orderByComparator) { 1500 return getPersistence() 1501 .filterFindByG_P(groupId, privateLayout, start, end, 1502 orderByComparator); 1503 } 1504 1505 /** 1506 * Returns the layouts before and after the current layout in the ordered set of layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1507 * 1508 * @param plid the primary key of the current layout 1509 * @param groupId the group ID 1510 * @param privateLayout the private layout 1511 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1512 * @return the previous, current, and next layout 1513 * @throws NoSuchLayoutException if a layout with the primary key could not be found 1514 */ 1515 public static Layout[] filterFindByG_P_PrevAndNext(long plid, long groupId, 1516 boolean privateLayout, OrderByComparator<Layout> orderByComparator) 1517 throws com.liferay.portal.NoSuchLayoutException { 1518 return getPersistence() 1519 .filterFindByG_P_PrevAndNext(plid, groupId, privateLayout, 1520 orderByComparator); 1521 } 1522 1523 /** 1524 * Removes all the layouts where groupId = ? and privateLayout = ? from the database. 1525 * 1526 * @param groupId the group ID 1527 * @param privateLayout the private layout 1528 */ 1529 public static void removeByG_P(long groupId, boolean privateLayout) { 1530 getPersistence().removeByG_P(groupId, privateLayout); 1531 } 1532 1533 /** 1534 * Returns the number of layouts where groupId = ? and privateLayout = ?. 1535 * 1536 * @param groupId the group ID 1537 * @param privateLayout the private layout 1538 * @return the number of matching layouts 1539 */ 1540 public static int countByG_P(long groupId, boolean privateLayout) { 1541 return getPersistence().countByG_P(groupId, privateLayout); 1542 } 1543 1544 /** 1545 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ?. 1546 * 1547 * @param groupId the group ID 1548 * @param privateLayout the private layout 1549 * @return the number of matching layouts that the user has permission to view 1550 */ 1551 public static int filterCountByG_P(long groupId, boolean privateLayout) { 1552 return getPersistence().filterCountByG_P(groupId, privateLayout); 1553 } 1554 1555 /** 1556 * Returns the layout where groupId = ? and privateLayout = ? and layoutId = ? or throws a {@link NoSuchLayoutException} if it could not be found. 1557 * 1558 * @param groupId the group ID 1559 * @param privateLayout the private layout 1560 * @param layoutId the layout ID 1561 * @return the matching layout 1562 * @throws NoSuchLayoutException if a matching layout could not be found 1563 */ 1564 public static Layout findByG_P_L(long groupId, boolean privateLayout, 1565 long layoutId) throws com.liferay.portal.NoSuchLayoutException { 1566 return getPersistence().findByG_P_L(groupId, privateLayout, layoutId); 1567 } 1568 1569 /** 1570 * Returns the layout where groupId = ? and privateLayout = ? and layoutId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1571 * 1572 * @param groupId the group ID 1573 * @param privateLayout the private layout 1574 * @param layoutId the layout ID 1575 * @return the matching layout, or <code>null</code> if a matching layout could not be found 1576 */ 1577 public static Layout fetchByG_P_L(long groupId, boolean privateLayout, 1578 long layoutId) { 1579 return getPersistence().fetchByG_P_L(groupId, privateLayout, layoutId); 1580 } 1581 1582 /** 1583 * Returns the layout where groupId = ? and privateLayout = ? and layoutId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1584 * 1585 * @param groupId the group ID 1586 * @param privateLayout the private layout 1587 * @param layoutId the layout ID 1588 * @param retrieveFromCache whether to retrieve from the finder cache 1589 * @return the matching layout, or <code>null</code> if a matching layout could not be found 1590 */ 1591 public static Layout fetchByG_P_L(long groupId, boolean privateLayout, 1592 long layoutId, boolean retrieveFromCache) { 1593 return getPersistence() 1594 .fetchByG_P_L(groupId, privateLayout, layoutId, 1595 retrieveFromCache); 1596 } 1597 1598 /** 1599 * Removes the layout where groupId = ? and privateLayout = ? and layoutId = ? from the database. 1600 * 1601 * @param groupId the group ID 1602 * @param privateLayout the private layout 1603 * @param layoutId the layout ID 1604 * @return the layout that was removed 1605 */ 1606 public static Layout removeByG_P_L(long groupId, boolean privateLayout, 1607 long layoutId) throws com.liferay.portal.NoSuchLayoutException { 1608 return getPersistence().removeByG_P_L(groupId, privateLayout, layoutId); 1609 } 1610 1611 /** 1612 * Returns the number of layouts where groupId = ? and privateLayout = ? and layoutId = ?. 1613 * 1614 * @param groupId the group ID 1615 * @param privateLayout the private layout 1616 * @param layoutId the layout ID 1617 * @return the number of matching layouts 1618 */ 1619 public static int countByG_P_L(long groupId, boolean privateLayout, 1620 long layoutId) { 1621 return getPersistence().countByG_P_L(groupId, privateLayout, layoutId); 1622 } 1623 1624 /** 1625 * Returns all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1626 * 1627 * @param groupId the group ID 1628 * @param privateLayout the private layout 1629 * @param parentLayoutId the parent layout ID 1630 * @return the matching layouts 1631 */ 1632 public static List<Layout> findByG_P_P(long groupId, boolean privateLayout, 1633 long parentLayoutId) { 1634 return getPersistence() 1635 .findByG_P_P(groupId, privateLayout, parentLayoutId); 1636 } 1637 1638 /** 1639 * Returns a range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1640 * 1641 * <p> 1642 * 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 LayoutModelImpl}. 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. 1643 * </p> 1644 * 1645 * @param groupId the group ID 1646 * @param privateLayout the private layout 1647 * @param parentLayoutId the parent layout ID 1648 * @param start the lower bound of the range of layouts 1649 * @param end the upper bound of the range of layouts (not inclusive) 1650 * @return the range of matching layouts 1651 */ 1652 public static List<Layout> findByG_P_P(long groupId, boolean privateLayout, 1653 long parentLayoutId, int start, int end) { 1654 return getPersistence() 1655 .findByG_P_P(groupId, privateLayout, parentLayoutId, start, 1656 end); 1657 } 1658 1659 /** 1660 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1661 * 1662 * <p> 1663 * 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 LayoutModelImpl}. 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. 1664 * </p> 1665 * 1666 * @param groupId the group ID 1667 * @param privateLayout the private layout 1668 * @param parentLayoutId the parent layout ID 1669 * @param start the lower bound of the range of layouts 1670 * @param end the upper bound of the range of layouts (not inclusive) 1671 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1672 * @return the ordered range of matching layouts 1673 */ 1674 public static List<Layout> findByG_P_P(long groupId, boolean privateLayout, 1675 long parentLayoutId, int start, int end, 1676 OrderByComparator<Layout> orderByComparator) { 1677 return getPersistence() 1678 .findByG_P_P(groupId, privateLayout, parentLayoutId, start, 1679 end, orderByComparator); 1680 } 1681 1682 /** 1683 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1684 * 1685 * <p> 1686 * 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 LayoutModelImpl}. 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. 1687 * </p> 1688 * 1689 * @param groupId the group ID 1690 * @param privateLayout the private layout 1691 * @param parentLayoutId the parent layout ID 1692 * @param start the lower bound of the range of layouts 1693 * @param end the upper bound of the range of layouts (not inclusive) 1694 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1695 * @param retrieveFromCache whether to retrieve from the finder cache 1696 * @return the ordered range of matching layouts 1697 */ 1698 public static List<Layout> findByG_P_P(long groupId, boolean privateLayout, 1699 long parentLayoutId, int start, int end, 1700 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 1701 return getPersistence() 1702 .findByG_P_P(groupId, privateLayout, parentLayoutId, start, 1703 end, orderByComparator, retrieveFromCache); 1704 } 1705 1706 /** 1707 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1708 * 1709 * @param groupId the group ID 1710 * @param privateLayout the private layout 1711 * @param parentLayoutId the parent layout ID 1712 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1713 * @return the first matching layout 1714 * @throws NoSuchLayoutException if a matching layout could not be found 1715 */ 1716 public static Layout findByG_P_P_First(long groupId, boolean privateLayout, 1717 long parentLayoutId, OrderByComparator<Layout> orderByComparator) 1718 throws com.liferay.portal.NoSuchLayoutException { 1719 return getPersistence() 1720 .findByG_P_P_First(groupId, privateLayout, parentLayoutId, 1721 orderByComparator); 1722 } 1723 1724 /** 1725 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1726 * 1727 * @param groupId the group ID 1728 * @param privateLayout the private layout 1729 * @param parentLayoutId the parent layout ID 1730 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1731 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 1732 */ 1733 public static Layout fetchByG_P_P_First(long groupId, 1734 boolean privateLayout, long parentLayoutId, 1735 OrderByComparator<Layout> orderByComparator) { 1736 return getPersistence() 1737 .fetchByG_P_P_First(groupId, privateLayout, parentLayoutId, 1738 orderByComparator); 1739 } 1740 1741 /** 1742 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1743 * 1744 * @param groupId the group ID 1745 * @param privateLayout the private layout 1746 * @param parentLayoutId the parent layout ID 1747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1748 * @return the last matching layout 1749 * @throws NoSuchLayoutException if a matching layout could not be found 1750 */ 1751 public static Layout findByG_P_P_Last(long groupId, boolean privateLayout, 1752 long parentLayoutId, OrderByComparator<Layout> orderByComparator) 1753 throws com.liferay.portal.NoSuchLayoutException { 1754 return getPersistence() 1755 .findByG_P_P_Last(groupId, privateLayout, parentLayoutId, 1756 orderByComparator); 1757 } 1758 1759 /** 1760 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1761 * 1762 * @param groupId the group ID 1763 * @param privateLayout the private layout 1764 * @param parentLayoutId the parent layout ID 1765 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1766 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 1767 */ 1768 public static Layout fetchByG_P_P_Last(long groupId, boolean privateLayout, 1769 long parentLayoutId, OrderByComparator<Layout> orderByComparator) { 1770 return getPersistence() 1771 .fetchByG_P_P_Last(groupId, privateLayout, parentLayoutId, 1772 orderByComparator); 1773 } 1774 1775 /** 1776 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1777 * 1778 * @param plid the primary key of the current layout 1779 * @param groupId the group ID 1780 * @param privateLayout the private layout 1781 * @param parentLayoutId the parent layout ID 1782 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1783 * @return the previous, current, and next layout 1784 * @throws NoSuchLayoutException if a layout with the primary key could not be found 1785 */ 1786 public static Layout[] findByG_P_P_PrevAndNext(long plid, long groupId, 1787 boolean privateLayout, long parentLayoutId, 1788 OrderByComparator<Layout> orderByComparator) 1789 throws com.liferay.portal.NoSuchLayoutException { 1790 return getPersistence() 1791 .findByG_P_P_PrevAndNext(plid, groupId, privateLayout, 1792 parentLayoutId, orderByComparator); 1793 } 1794 1795 /** 1796 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1797 * 1798 * @param groupId the group ID 1799 * @param privateLayout the private layout 1800 * @param parentLayoutId the parent layout ID 1801 * @return the matching layouts that the user has permission to view 1802 */ 1803 public static List<Layout> filterFindByG_P_P(long groupId, 1804 boolean privateLayout, long parentLayoutId) { 1805 return getPersistence() 1806 .filterFindByG_P_P(groupId, privateLayout, parentLayoutId); 1807 } 1808 1809 /** 1810 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1811 * 1812 * <p> 1813 * 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 LayoutModelImpl}. 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. 1814 * </p> 1815 * 1816 * @param groupId the group ID 1817 * @param privateLayout the private layout 1818 * @param parentLayoutId the parent layout ID 1819 * @param start the lower bound of the range of layouts 1820 * @param end the upper bound of the range of layouts (not inclusive) 1821 * @return the range of matching layouts that the user has permission to view 1822 */ 1823 public static List<Layout> filterFindByG_P_P(long groupId, 1824 boolean privateLayout, long parentLayoutId, int start, int end) { 1825 return getPersistence() 1826 .filterFindByG_P_P(groupId, privateLayout, parentLayoutId, 1827 start, end); 1828 } 1829 1830 /** 1831 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1832 * 1833 * <p> 1834 * 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 LayoutModelImpl}. 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. 1835 * </p> 1836 * 1837 * @param groupId the group ID 1838 * @param privateLayout the private layout 1839 * @param parentLayoutId the parent layout ID 1840 * @param start the lower bound of the range of layouts 1841 * @param end the upper bound of the range of layouts (not inclusive) 1842 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1843 * @return the ordered range of matching layouts that the user has permission to view 1844 */ 1845 public static List<Layout> filterFindByG_P_P(long groupId, 1846 boolean privateLayout, long parentLayoutId, int start, int end, 1847 OrderByComparator<Layout> orderByComparator) { 1848 return getPersistence() 1849 .filterFindByG_P_P(groupId, privateLayout, parentLayoutId, 1850 start, end, orderByComparator); 1851 } 1852 1853 /** 1854 * Returns the layouts before and after the current layout in the ordered set of layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1855 * 1856 * @param plid the primary key of the current layout 1857 * @param groupId the group ID 1858 * @param privateLayout the private layout 1859 * @param parentLayoutId the parent layout ID 1860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1861 * @return the previous, current, and next layout 1862 * @throws NoSuchLayoutException if a layout with the primary key could not be found 1863 */ 1864 public static Layout[] filterFindByG_P_P_PrevAndNext(long plid, 1865 long groupId, boolean privateLayout, long parentLayoutId, 1866 OrderByComparator<Layout> orderByComparator) 1867 throws com.liferay.portal.NoSuchLayoutException { 1868 return getPersistence() 1869 .filterFindByG_P_P_PrevAndNext(plid, groupId, privateLayout, 1870 parentLayoutId, orderByComparator); 1871 } 1872 1873 /** 1874 * Removes all the layouts where groupId = ? and privateLayout = ? and parentLayoutId = ? from the database. 1875 * 1876 * @param groupId the group ID 1877 * @param privateLayout the private layout 1878 * @param parentLayoutId the parent layout ID 1879 */ 1880 public static void removeByG_P_P(long groupId, boolean privateLayout, 1881 long parentLayoutId) { 1882 getPersistence().removeByG_P_P(groupId, privateLayout, parentLayoutId); 1883 } 1884 1885 /** 1886 * Returns the number of layouts where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1887 * 1888 * @param groupId the group ID 1889 * @param privateLayout the private layout 1890 * @param parentLayoutId the parent layout ID 1891 * @return the number of matching layouts 1892 */ 1893 public static int countByG_P_P(long groupId, boolean privateLayout, 1894 long parentLayoutId) { 1895 return getPersistence() 1896 .countByG_P_P(groupId, privateLayout, parentLayoutId); 1897 } 1898 1899 /** 1900 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ? and parentLayoutId = ?. 1901 * 1902 * @param groupId the group ID 1903 * @param privateLayout the private layout 1904 * @param parentLayoutId the parent layout ID 1905 * @return the number of matching layouts that the user has permission to view 1906 */ 1907 public static int filterCountByG_P_P(long groupId, boolean privateLayout, 1908 long parentLayoutId) { 1909 return getPersistence() 1910 .filterCountByG_P_P(groupId, privateLayout, parentLayoutId); 1911 } 1912 1913 /** 1914 * Returns all the layouts where groupId = ? and privateLayout = ? and type = ?. 1915 * 1916 * @param groupId the group ID 1917 * @param privateLayout the private layout 1918 * @param type the type 1919 * @return the matching layouts 1920 */ 1921 public static List<Layout> findByG_P_T(long groupId, boolean privateLayout, 1922 java.lang.String type) { 1923 return getPersistence().findByG_P_T(groupId, privateLayout, type); 1924 } 1925 1926 /** 1927 * Returns a range of all the layouts where groupId = ? and privateLayout = ? and type = ?. 1928 * 1929 * <p> 1930 * 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 LayoutModelImpl}. 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. 1931 * </p> 1932 * 1933 * @param groupId the group ID 1934 * @param privateLayout the private layout 1935 * @param type the type 1936 * @param start the lower bound of the range of layouts 1937 * @param end the upper bound of the range of layouts (not inclusive) 1938 * @return the range of matching layouts 1939 */ 1940 public static List<Layout> findByG_P_T(long groupId, boolean privateLayout, 1941 java.lang.String type, int start, int end) { 1942 return getPersistence() 1943 .findByG_P_T(groupId, privateLayout, type, start, end); 1944 } 1945 1946 /** 1947 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and type = ?. 1948 * 1949 * <p> 1950 * 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 LayoutModelImpl}. 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. 1951 * </p> 1952 * 1953 * @param groupId the group ID 1954 * @param privateLayout the private layout 1955 * @param type the type 1956 * @param start the lower bound of the range of layouts 1957 * @param end the upper bound of the range of layouts (not inclusive) 1958 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1959 * @return the ordered range of matching layouts 1960 */ 1961 public static List<Layout> findByG_P_T(long groupId, boolean privateLayout, 1962 java.lang.String type, int start, int end, 1963 OrderByComparator<Layout> orderByComparator) { 1964 return getPersistence() 1965 .findByG_P_T(groupId, privateLayout, type, start, end, 1966 orderByComparator); 1967 } 1968 1969 /** 1970 * Returns an ordered range of all the layouts where groupId = ? and privateLayout = ? and type = ?. 1971 * 1972 * <p> 1973 * 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 LayoutModelImpl}. 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. 1974 * </p> 1975 * 1976 * @param groupId the group ID 1977 * @param privateLayout the private layout 1978 * @param type the type 1979 * @param start the lower bound of the range of layouts 1980 * @param end the upper bound of the range of layouts (not inclusive) 1981 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1982 * @param retrieveFromCache whether to retrieve from the finder cache 1983 * @return the ordered range of matching layouts 1984 */ 1985 public static List<Layout> findByG_P_T(long groupId, boolean privateLayout, 1986 java.lang.String type, int start, int end, 1987 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 1988 return getPersistence() 1989 .findByG_P_T(groupId, privateLayout, type, start, end, 1990 orderByComparator, retrieveFromCache); 1991 } 1992 1993 /** 1994 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 1995 * 1996 * @param groupId the group ID 1997 * @param privateLayout the private layout 1998 * @param type the type 1999 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2000 * @return the first matching layout 2001 * @throws NoSuchLayoutException if a matching layout could not be found 2002 */ 2003 public static Layout findByG_P_T_First(long groupId, boolean privateLayout, 2004 java.lang.String type, OrderByComparator<Layout> orderByComparator) 2005 throws com.liferay.portal.NoSuchLayoutException { 2006 return getPersistence() 2007 .findByG_P_T_First(groupId, privateLayout, type, 2008 orderByComparator); 2009 } 2010 2011 /** 2012 * Returns the first layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2013 * 2014 * @param groupId the group ID 2015 * @param privateLayout the private layout 2016 * @param type the type 2017 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2018 * @return the first matching layout, or <code>null</code> if a matching layout could not be found 2019 */ 2020 public static Layout fetchByG_P_T_First(long groupId, 2021 boolean privateLayout, java.lang.String type, 2022 OrderByComparator<Layout> orderByComparator) { 2023 return getPersistence() 2024 .fetchByG_P_T_First(groupId, privateLayout, type, 2025 orderByComparator); 2026 } 2027 2028 /** 2029 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2030 * 2031 * @param groupId the group ID 2032 * @param privateLayout the private layout 2033 * @param type the type 2034 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2035 * @return the last matching layout 2036 * @throws NoSuchLayoutException if a matching layout could not be found 2037 */ 2038 public static Layout findByG_P_T_Last(long groupId, boolean privateLayout, 2039 java.lang.String type, OrderByComparator<Layout> orderByComparator) 2040 throws com.liferay.portal.NoSuchLayoutException { 2041 return getPersistence() 2042 .findByG_P_T_Last(groupId, privateLayout, type, 2043 orderByComparator); 2044 } 2045 2046 /** 2047 * Returns the last layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2048 * 2049 * @param groupId the group ID 2050 * @param privateLayout the private layout 2051 * @param type the type 2052 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2053 * @return the last matching layout, or <code>null</code> if a matching layout could not be found 2054 */ 2055 public static Layout fetchByG_P_T_Last(long groupId, boolean privateLayout, 2056 java.lang.String type, OrderByComparator<Layout> orderByComparator) { 2057 return getPersistence() 2058 .fetchByG_P_T_Last(groupId, privateLayout, type, 2059 orderByComparator); 2060 } 2061 2062 /** 2063 * Returns the layouts before and after the current layout in the ordered set where groupId = ? and privateLayout = ? and type = ?. 2064 * 2065 * @param plid the primary key of the current layout 2066 * @param groupId the group ID 2067 * @param privateLayout the private layout 2068 * @param type the type 2069 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2070 * @return the previous, current, and next layout 2071 * @throws NoSuchLayoutException if a layout with the primary key could not be found 2072 */ 2073 public static Layout[] findByG_P_T_PrevAndNext(long plid, long groupId, 2074 boolean privateLayout, java.lang.String type, 2075 OrderByComparator<Layout> orderByComparator) 2076 throws com.liferay.portal.NoSuchLayoutException { 2077 return getPersistence() 2078 .findByG_P_T_PrevAndNext(plid, groupId, privateLayout, type, 2079 orderByComparator); 2080 } 2081 2082 /** 2083 * Returns all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2084 * 2085 * @param groupId the group ID 2086 * @param privateLayout the private layout 2087 * @param type the type 2088 * @return the matching layouts that the user has permission to view 2089 */ 2090 public static List<Layout> filterFindByG_P_T(long groupId, 2091 boolean privateLayout, java.lang.String type) { 2092 return getPersistence().filterFindByG_P_T(groupId, privateLayout, type); 2093 } 2094 2095 /** 2096 * Returns a range of all the layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2097 * 2098 * <p> 2099 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2100 * </p> 2101 * 2102 * @param groupId the group ID 2103 * @param privateLayout the private layout 2104 * @param type the type 2105 * @param start the lower bound of the range of layouts 2106 * @param end the upper bound of the range of layouts (not inclusive) 2107 * @return the range of matching layouts that the user has permission to view 2108 */ 2109 public static List<Layout> filterFindByG_P_T(long groupId, 2110 boolean privateLayout, java.lang.String type, int start, int end) { 2111 return getPersistence() 2112 .filterFindByG_P_T(groupId, privateLayout, type, start, end); 2113 } 2114 2115 /** 2116 * Returns an ordered range of all the layouts that the user has permissions to view where groupId = ? and privateLayout = ? and type = ?. 2117 * 2118 * <p> 2119 * 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 LayoutModelImpl}. 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. 2120 * </p> 2121 * 2122 * @param groupId the group ID 2123 * @param privateLayout the private layout 2124 * @param type the type 2125 * @param start the lower bound of the range of layouts 2126 * @param end the upper bound of the range of layouts (not inclusive) 2127 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2128 * @return the ordered range of matching layouts that the user has permission to view 2129 */ 2130 public static List<Layout> filterFindByG_P_T(long groupId, 2131 boolean privateLayout, java.lang.String type, int start, int end, 2132 OrderByComparator<Layout> orderByComparator) { 2133 return getPersistence() 2134 .filterFindByG_P_T(groupId, privateLayout, type, start, end, 2135 orderByComparator); 2136 } 2137 2138 /** 2139 * Returns the layouts before and after the current layout in the ordered set of layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2140 * 2141 * @param plid the primary key of the current layout 2142 * @param groupId the group ID 2143 * @param privateLayout the private layout 2144 * @param type the type 2145 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2146 * @return the previous, current, and next layout 2147 * @throws NoSuchLayoutException if a layout with the primary key could not be found 2148 */ 2149 public static Layout[] filterFindByG_P_T_PrevAndNext(long plid, 2150 long groupId, boolean privateLayout, java.lang.String type, 2151 OrderByComparator<Layout> orderByComparator) 2152 throws com.liferay.portal.NoSuchLayoutException { 2153 return getPersistence() 2154 .filterFindByG_P_T_PrevAndNext(plid, groupId, privateLayout, 2155 type, orderByComparator); 2156 } 2157 2158 /** 2159 * Removes all the layouts where groupId = ? and privateLayout = ? and type = ? from the database. 2160 * 2161 * @param groupId the group ID 2162 * @param privateLayout the private layout 2163 * @param type the type 2164 */ 2165 public static void removeByG_P_T(long groupId, boolean privateLayout, 2166 java.lang.String type) { 2167 getPersistence().removeByG_P_T(groupId, privateLayout, type); 2168 } 2169 2170 /** 2171 * Returns the number of layouts where groupId = ? and privateLayout = ? and type = ?. 2172 * 2173 * @param groupId the group ID 2174 * @param privateLayout the private layout 2175 * @param type the type 2176 * @return the number of matching layouts 2177 */ 2178 public static int countByG_P_T(long groupId, boolean privateLayout, 2179 java.lang.String type) { 2180 return getPersistence().countByG_P_T(groupId, privateLayout, type); 2181 } 2182 2183 /** 2184 * Returns the number of layouts that the user has permission to view where groupId = ? and privateLayout = ? and type = ?. 2185 * 2186 * @param groupId the group ID 2187 * @param privateLayout the private layout 2188 * @param type the type 2189 * @return the number of matching layouts that the user has permission to view 2190 */ 2191 public static int filterCountByG_P_T(long groupId, boolean privateLayout, 2192 java.lang.String type) { 2193 return getPersistence().filterCountByG_P_T(groupId, privateLayout, type); 2194 } 2195 2196 /** 2197 * Returns the layout where groupId = ? and privateLayout = ? and friendlyURL = ? or throws a {@link NoSuchLayoutException} if it could not be found. 2198 * 2199 * @param groupId the group ID 2200 * @param privateLayout the private layout 2201 * @param friendlyURL the friendly u r l 2202 * @return the matching layout 2203 * @throws NoSuchLayoutException if a matching layout could not be found 2204 */ 2205 public static Layout findByG_P_F(long groupId, boolean privateLayout, 2206 java.lang.String friendlyURL) 2207 throws com.liferay.portal.NoSuchLayoutException { 2208 return getPersistence().findByG_P_F(groupId, privateLayout, friendlyURL); 2209 } 2210 2211 /** 2212 * Returns the layout where groupId = ? and privateLayout = ? and friendlyURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2213 * 2214 * @param groupId the group ID 2215 * @param privateLayout the private layout 2216 * @param friendlyURL the friendly u r l 2217 * @return the matching layout, or <code>null</code> if a matching layout could not be found 2218 */ 2219 public static Layout fetchByG_P_F(long groupId, boolean privateLayout, 2220 java.lang.String friendlyURL) { 2221 return getPersistence().fetchByG_P_F(groupId, privateLayout, friendlyURL); 2222 } 2223 2224 /** 2225 * Returns the layout where groupId = ? and privateLayout = ? and friendlyURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2226 * 2227 * @param groupId the group ID 2228 * @param privateLayout the private layout 2229 * @param friendlyURL the friendly u r l 2230 * @param retrieveFromCache whether to retrieve from the finder cache 2231 * @return the matching layout, or <code>null</code> if a matching layout could not be found 2232 */ 2233 public static Layout fetchByG_P_F(long groupId, boolean privateLayout, 2234 java.lang.String friendlyURL, boolean retrieveFromCache) { 2235 return getPersistence() 2236 .fetchByG_P_F(groupId, privateLayout, friendlyURL, 2237 retrieveFromCache); 2238 } 2239 2240 /** 2241 * Removes the layout where groupId = ? and privateLayout = ? and friendlyURL = ? from the database. 2242 * 2243 * @param groupId the group ID 2244 * @param privateLayout the private layout 2245 * @param friendlyURL the friendly u r l 2246 * @return the layout that was removed 2247 */ 2248 public static Layout removeByG_P_F(long groupId, boolean privateLayout, 2249 java.lang.String friendlyURL) 2250 throws com.liferay.portal.NoSuchLayoutException { 2251 return getPersistence() 2252 .removeByG_P_F(groupId, privateLayout, friendlyURL); 2253 } 2254 2255 /** 2256 * Returns the number of layouts where groupId = ? and privateLayout = ? and friendlyURL = ?. 2257 * 2258 * @param groupId the group ID 2259 * @param privateLayout the private layout 2260 * @param friendlyURL the friendly u r l 2261 * @return the number of matching layouts 2262 */ 2263 public static int countByG_P_F(long groupId, boolean privateLayout, 2264 java.lang.String friendlyURL) { 2265 return getPersistence().countByG_P_F(groupId, privateLayout, friendlyURL); 2266 } 2267 2268 /** 2269 * Returns the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? or throws a {@link NoSuchLayoutException} if it could not be found. 2270 * 2271 * @param groupId the group ID 2272 * @param privateLayout the private layout 2273 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2274 * @return the matching layout 2275 * @throws NoSuchLayoutException if a matching layout could not be found 2276 */ 2277 public static Layout findByG_P_SPLU(long groupId, boolean privateLayout, 2278 java.lang.String sourcePrototypeLayoutUuid) 2279 throws com.liferay.portal.NoSuchLayoutException { 2280 return getPersistence() 2281 .findByG_P_SPLU(groupId, privateLayout, 2282 sourcePrototypeLayoutUuid); 2283 } 2284 2285 /** 2286 * Returns the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2287 * 2288 * @param groupId the group ID 2289 * @param privateLayout the private layout 2290 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2291 * @return the matching layout, or <code>null</code> if a matching layout could not be found 2292 */ 2293 public static Layout fetchByG_P_SPLU(long groupId, boolean privateLayout, 2294 java.lang.String sourcePrototypeLayoutUuid) { 2295 return getPersistence() 2296 .fetchByG_P_SPLU(groupId, privateLayout, 2297 sourcePrototypeLayoutUuid); 2298 } 2299 2300 /** 2301 * Returns the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2302 * 2303 * @param groupId the group ID 2304 * @param privateLayout the private layout 2305 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2306 * @param retrieveFromCache whether to retrieve from the finder cache 2307 * @return the matching layout, or <code>null</code> if a matching layout could not be found 2308 */ 2309 public static Layout fetchByG_P_SPLU(long groupId, boolean privateLayout, 2310 java.lang.String sourcePrototypeLayoutUuid, boolean retrieveFromCache) { 2311 return getPersistence() 2312 .fetchByG_P_SPLU(groupId, privateLayout, 2313 sourcePrototypeLayoutUuid, retrieveFromCache); 2314 } 2315 2316 /** 2317 * Removes the layout where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ? from the database. 2318 * 2319 * @param groupId the group ID 2320 * @param privateLayout the private layout 2321 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2322 * @return the layout that was removed 2323 */ 2324 public static Layout removeByG_P_SPLU(long groupId, boolean privateLayout, 2325 java.lang.String sourcePrototypeLayoutUuid) 2326 throws com.liferay.portal.NoSuchLayoutException { 2327 return getPersistence() 2328 .removeByG_P_SPLU(groupId, privateLayout, 2329 sourcePrototypeLayoutUuid); 2330 } 2331 2332 /** 2333 * Returns the number of layouts where groupId = ? and privateLayout = ? and sourcePrototypeLayoutUuid = ?. 2334 * 2335 * @param groupId the group ID 2336 * @param privateLayout the private layout 2337 * @param sourcePrototypeLayoutUuid the source prototype layout uuid 2338 * @return the number of matching layouts 2339 */ 2340 public static int countByG_P_SPLU(long groupId, boolean privateLayout, 2341 java.lang.String sourcePrototypeLayoutUuid) { 2342 return getPersistence() 2343 .countByG_P_SPLU(groupId, privateLayout, 2344 sourcePrototypeLayoutUuid); 2345 } 2346 2347 /** 2348 * Caches the layout in the entity cache if it is enabled. 2349 * 2350 * @param layout the layout 2351 */ 2352 public static void cacheResult(Layout layout) { 2353 getPersistence().cacheResult(layout); 2354 } 2355 2356 /** 2357 * Caches the layouts in the entity cache if it is enabled. 2358 * 2359 * @param layouts the layouts 2360 */ 2361 public static void cacheResult(List<Layout> layouts) { 2362 getPersistence().cacheResult(layouts); 2363 } 2364 2365 /** 2366 * Creates a new layout with the primary key. Does not add the layout to the database. 2367 * 2368 * @param plid the primary key for the new layout 2369 * @return the new layout 2370 */ 2371 public static Layout create(long plid) { 2372 return getPersistence().create(plid); 2373 } 2374 2375 /** 2376 * Removes the layout with the primary key from the database. Also notifies the appropriate model listeners. 2377 * 2378 * @param plid the primary key of the layout 2379 * @return the layout that was removed 2380 * @throws NoSuchLayoutException if a layout with the primary key could not be found 2381 */ 2382 public static Layout remove(long plid) 2383 throws com.liferay.portal.NoSuchLayoutException { 2384 return getPersistence().remove(plid); 2385 } 2386 2387 public static Layout updateImpl(Layout layout) { 2388 return getPersistence().updateImpl(layout); 2389 } 2390 2391 /** 2392 * Returns the layout with the primary key or throws a {@link NoSuchLayoutException} if it could not be found. 2393 * 2394 * @param plid the primary key of the layout 2395 * @return the layout 2396 * @throws NoSuchLayoutException if a layout with the primary key could not be found 2397 */ 2398 public static Layout findByPrimaryKey(long plid) 2399 throws com.liferay.portal.NoSuchLayoutException { 2400 return getPersistence().findByPrimaryKey(plid); 2401 } 2402 2403 /** 2404 * Returns the layout with the primary key or returns <code>null</code> if it could not be found. 2405 * 2406 * @param plid the primary key of the layout 2407 * @return the layout, or <code>null</code> if a layout with the primary key could not be found 2408 */ 2409 public static Layout fetchByPrimaryKey(long plid) { 2410 return getPersistence().fetchByPrimaryKey(plid); 2411 } 2412 2413 public static java.util.Map<java.io.Serializable, Layout> fetchByPrimaryKeys( 2414 java.util.Set<java.io.Serializable> primaryKeys) { 2415 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2416 } 2417 2418 /** 2419 * Returns all the layouts. 2420 * 2421 * @return the layouts 2422 */ 2423 public static List<Layout> findAll() { 2424 return getPersistence().findAll(); 2425 } 2426 2427 /** 2428 * Returns a range of all the layouts. 2429 * 2430 * <p> 2431 * 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 LayoutModelImpl}. 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. 2432 * </p> 2433 * 2434 * @param start the lower bound of the range of layouts 2435 * @param end the upper bound of the range of layouts (not inclusive) 2436 * @return the range of layouts 2437 */ 2438 public static List<Layout> findAll(int start, int end) { 2439 return getPersistence().findAll(start, end); 2440 } 2441 2442 /** 2443 * Returns an ordered range of all the layouts. 2444 * 2445 * <p> 2446 * 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 LayoutModelImpl}. 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. 2447 * </p> 2448 * 2449 * @param start the lower bound of the range of layouts 2450 * @param end the upper bound of the range of layouts (not inclusive) 2451 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2452 * @return the ordered range of layouts 2453 */ 2454 public static List<Layout> findAll(int start, int end, 2455 OrderByComparator<Layout> orderByComparator) { 2456 return getPersistence().findAll(start, end, orderByComparator); 2457 } 2458 2459 /** 2460 * Returns an ordered range of all the layouts. 2461 * 2462 * <p> 2463 * 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 LayoutModelImpl}. 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. 2464 * </p> 2465 * 2466 * @param start the lower bound of the range of layouts 2467 * @param end the upper bound of the range of layouts (not inclusive) 2468 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2469 * @param retrieveFromCache whether to retrieve from the finder cache 2470 * @return the ordered range of layouts 2471 */ 2472 public static List<Layout> findAll(int start, int end, 2473 OrderByComparator<Layout> orderByComparator, boolean retrieveFromCache) { 2474 return getPersistence() 2475 .findAll(start, end, orderByComparator, retrieveFromCache); 2476 } 2477 2478 /** 2479 * Removes all the layouts from the database. 2480 */ 2481 public static void removeAll() { 2482 getPersistence().removeAll(); 2483 } 2484 2485 /** 2486 * Returns the number of layouts. 2487 * 2488 * @return the number of layouts 2489 */ 2490 public static int countAll() { 2491 return getPersistence().countAll(); 2492 } 2493 2494 public static java.util.Set<java.lang.String> getBadColumnNames() { 2495 return getPersistence().getBadColumnNames(); 2496 } 2497 2498 public static LayoutPersistence getPersistence() { 2499 if (_persistence == null) { 2500 _persistence = (LayoutPersistence)PortalBeanLocatorUtil.locate(LayoutPersistence.class.getName()); 2501 2502 ReferenceRegistry.registerReference(LayoutUtil.class, "_persistence"); 2503 } 2504 2505 return _persistence; 2506 } 2507 2508 /** 2509 * @deprecated As of 6.2.0 2510 */ 2511 @Deprecated 2512 public void setPersistence(LayoutPersistence persistence) { 2513 } 2514 2515 private static LayoutPersistence _persistence; 2516 }