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