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