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