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