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