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