001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.LayoutSetBranch; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the layout set branch service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutSetBranchPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see LayoutSetBranchPersistence 037 * @see com.liferay.portal.service.persistence.impl.LayoutSetBranchPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class LayoutSetBranchUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(LayoutSetBranch layoutSetBranch) { 059 getPersistence().clearCache(layoutSetBranch); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<LayoutSetBranch> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<LayoutSetBranch> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<LayoutSetBranch> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<LayoutSetBranch> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static LayoutSetBranch update(LayoutSetBranch layoutSetBranch) { 100 return getPersistence().update(layoutSetBranch); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static LayoutSetBranch update(LayoutSetBranch layoutSetBranch, 107 ServiceContext serviceContext) { 108 return getPersistence().update(layoutSetBranch, serviceContext); 109 } 110 111 /** 112 * Returns all the layout set branchs where groupId = ?. 113 * 114 * @param groupId the group ID 115 * @return the matching layout set branchs 116 */ 117 public static List<LayoutSetBranch> findByGroupId(long groupId) { 118 return getPersistence().findByGroupId(groupId); 119 } 120 121 /** 122 * Returns a range of all the layout set branchs where groupId = ?. 123 * 124 * <p> 125 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 126 * </p> 127 * 128 * @param groupId the group ID 129 * @param start the lower bound of the range of layout set branchs 130 * @param end the upper bound of the range of layout set branchs (not inclusive) 131 * @return the range of matching layout set branchs 132 */ 133 public static List<LayoutSetBranch> findByGroupId(long groupId, int start, 134 int end) { 135 return getPersistence().findByGroupId(groupId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the layout set branchs where groupId = ?. 140 * 141 * <p> 142 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 143 * </p> 144 * 145 * @param groupId the group ID 146 * @param start the lower bound of the range of layout set branchs 147 * @param end the upper bound of the range of layout set branchs (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching layout set branchs 150 */ 151 public static List<LayoutSetBranch> findByGroupId(long groupId, int start, 152 int end, OrderByComparator<LayoutSetBranch> orderByComparator) { 153 return getPersistence() 154 .findByGroupId(groupId, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first layout set branch in the ordered set where groupId = ?. 159 * 160 * @param groupId the group ID 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching layout set branch 163 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 164 */ 165 public static LayoutSetBranch findByGroupId_First(long groupId, 166 OrderByComparator<LayoutSetBranch> orderByComparator) 167 throws com.liferay.portal.NoSuchLayoutSetBranchException { 168 return getPersistence().findByGroupId_First(groupId, orderByComparator); 169 } 170 171 /** 172 * Returns the first layout set branch in the ordered set where groupId = ?. 173 * 174 * @param groupId the group ID 175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 176 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 177 */ 178 public static LayoutSetBranch fetchByGroupId_First(long groupId, 179 OrderByComparator<LayoutSetBranch> orderByComparator) { 180 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 181 } 182 183 /** 184 * Returns the last layout set branch in the ordered set where groupId = ?. 185 * 186 * @param groupId the group ID 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the last matching layout set branch 189 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 190 */ 191 public static LayoutSetBranch findByGroupId_Last(long groupId, 192 OrderByComparator<LayoutSetBranch> orderByComparator) 193 throws com.liferay.portal.NoSuchLayoutSetBranchException { 194 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 195 } 196 197 /** 198 * Returns the last layout set branch in the ordered set where groupId = ?. 199 * 200 * @param groupId the group ID 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 203 */ 204 public static LayoutSetBranch fetchByGroupId_Last(long groupId, 205 OrderByComparator<LayoutSetBranch> orderByComparator) { 206 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 207 } 208 209 /** 210 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ?. 211 * 212 * @param layoutSetBranchId the primary key of the current layout set branch 213 * @param groupId the group ID 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next layout set branch 216 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 217 */ 218 public static LayoutSetBranch[] findByGroupId_PrevAndNext( 219 long layoutSetBranchId, long groupId, 220 OrderByComparator<LayoutSetBranch> orderByComparator) 221 throws com.liferay.portal.NoSuchLayoutSetBranchException { 222 return getPersistence() 223 .findByGroupId_PrevAndNext(layoutSetBranchId, groupId, 224 orderByComparator); 225 } 226 227 /** 228 * Returns all the layout set branchs that the user has permission to view where groupId = ?. 229 * 230 * @param groupId the group ID 231 * @return the matching layout set branchs that the user has permission to view 232 */ 233 public static List<LayoutSetBranch> filterFindByGroupId(long groupId) { 234 return getPersistence().filterFindByGroupId(groupId); 235 } 236 237 /** 238 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ?. 239 * 240 * <p> 241 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 242 * </p> 243 * 244 * @param groupId the group ID 245 * @param start the lower bound of the range of layout set branchs 246 * @param end the upper bound of the range of layout set branchs (not inclusive) 247 * @return the range of matching layout set branchs that the user has permission to view 248 */ 249 public static List<LayoutSetBranch> filterFindByGroupId(long groupId, 250 int start, int end) { 251 return getPersistence().filterFindByGroupId(groupId, start, end); 252 } 253 254 /** 255 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ?. 256 * 257 * <p> 258 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 259 * </p> 260 * 261 * @param groupId the group ID 262 * @param start the lower bound of the range of layout set branchs 263 * @param end the upper bound of the range of layout set branchs (not inclusive) 264 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 265 * @return the ordered range of matching layout set branchs that the user has permission to view 266 */ 267 public static List<LayoutSetBranch> filterFindByGroupId(long groupId, 268 int start, int end, OrderByComparator<LayoutSetBranch> orderByComparator) { 269 return getPersistence() 270 .filterFindByGroupId(groupId, start, end, orderByComparator); 271 } 272 273 /** 274 * Returns the layout set branchs before and after the current layout set branch in the ordered set of layout set branchs that the user has permission to view where groupId = ?. 275 * 276 * @param layoutSetBranchId the primary key of the current layout set branch 277 * @param groupId the group ID 278 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 279 * @return the previous, current, and next layout set branch 280 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 281 */ 282 public static LayoutSetBranch[] filterFindByGroupId_PrevAndNext( 283 long layoutSetBranchId, long groupId, 284 OrderByComparator<LayoutSetBranch> orderByComparator) 285 throws com.liferay.portal.NoSuchLayoutSetBranchException { 286 return getPersistence() 287 .filterFindByGroupId_PrevAndNext(layoutSetBranchId, groupId, 288 orderByComparator); 289 } 290 291 /** 292 * Removes all the layout set branchs where groupId = ? from the database. 293 * 294 * @param groupId the group ID 295 */ 296 public static void removeByGroupId(long groupId) { 297 getPersistence().removeByGroupId(groupId); 298 } 299 300 /** 301 * Returns the number of layout set branchs where groupId = ?. 302 * 303 * @param groupId the group ID 304 * @return the number of matching layout set branchs 305 */ 306 public static int countByGroupId(long groupId) { 307 return getPersistence().countByGroupId(groupId); 308 } 309 310 /** 311 * Returns the number of layout set branchs that the user has permission to view where groupId = ?. 312 * 313 * @param groupId the group ID 314 * @return the number of matching layout set branchs that the user has permission to view 315 */ 316 public static int filterCountByGroupId(long groupId) { 317 return getPersistence().filterCountByGroupId(groupId); 318 } 319 320 /** 321 * Returns all the layout set branchs where groupId = ? and privateLayout = ?. 322 * 323 * @param groupId the group ID 324 * @param privateLayout the private layout 325 * @return the matching layout set branchs 326 */ 327 public static List<LayoutSetBranch> findByG_P(long groupId, 328 boolean privateLayout) { 329 return getPersistence().findByG_P(groupId, privateLayout); 330 } 331 332 /** 333 * Returns a range of all the layout set branchs where groupId = ? and privateLayout = ?. 334 * 335 * <p> 336 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 337 * </p> 338 * 339 * @param groupId the group ID 340 * @param privateLayout the private layout 341 * @param start the lower bound of the range of layout set branchs 342 * @param end the upper bound of the range of layout set branchs (not inclusive) 343 * @return the range of matching layout set branchs 344 */ 345 public static List<LayoutSetBranch> findByG_P(long groupId, 346 boolean privateLayout, int start, int end) { 347 return getPersistence().findByG_P(groupId, privateLayout, start, end); 348 } 349 350 /** 351 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ?. 352 * 353 * <p> 354 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 355 * </p> 356 * 357 * @param groupId the group ID 358 * @param privateLayout the private layout 359 * @param start the lower bound of the range of layout set branchs 360 * @param end the upper bound of the range of layout set branchs (not inclusive) 361 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 362 * @return the ordered range of matching layout set branchs 363 */ 364 public static List<LayoutSetBranch> findByG_P(long groupId, 365 boolean privateLayout, int start, int end, 366 OrderByComparator<LayoutSetBranch> orderByComparator) { 367 return getPersistence() 368 .findByG_P(groupId, privateLayout, start, end, 369 orderByComparator); 370 } 371 372 /** 373 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ?. 374 * 375 * @param groupId the group ID 376 * @param privateLayout the private layout 377 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 378 * @return the first matching layout set branch 379 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 380 */ 381 public static LayoutSetBranch findByG_P_First(long groupId, 382 boolean privateLayout, 383 OrderByComparator<LayoutSetBranch> orderByComparator) 384 throws com.liferay.portal.NoSuchLayoutSetBranchException { 385 return getPersistence() 386 .findByG_P_First(groupId, privateLayout, orderByComparator); 387 } 388 389 /** 390 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ?. 391 * 392 * @param groupId the group ID 393 * @param privateLayout the private layout 394 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 395 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 396 */ 397 public static LayoutSetBranch fetchByG_P_First(long groupId, 398 boolean privateLayout, 399 OrderByComparator<LayoutSetBranch> orderByComparator) { 400 return getPersistence() 401 .fetchByG_P_First(groupId, privateLayout, orderByComparator); 402 } 403 404 /** 405 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ?. 406 * 407 * @param groupId the group ID 408 * @param privateLayout the private layout 409 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 410 * @return the last matching layout set branch 411 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 412 */ 413 public static LayoutSetBranch findByG_P_Last(long groupId, 414 boolean privateLayout, 415 OrderByComparator<LayoutSetBranch> orderByComparator) 416 throws com.liferay.portal.NoSuchLayoutSetBranchException { 417 return getPersistence() 418 .findByG_P_Last(groupId, privateLayout, orderByComparator); 419 } 420 421 /** 422 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ?. 423 * 424 * @param groupId the group ID 425 * @param privateLayout the private layout 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 428 */ 429 public static LayoutSetBranch fetchByG_P_Last(long groupId, 430 boolean privateLayout, 431 OrderByComparator<LayoutSetBranch> orderByComparator) { 432 return getPersistence() 433 .fetchByG_P_Last(groupId, privateLayout, orderByComparator); 434 } 435 436 /** 437 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ? and privateLayout = ?. 438 * 439 * @param layoutSetBranchId the primary key of the current layout set branch 440 * @param groupId the group ID 441 * @param privateLayout the private layout 442 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 443 * @return the previous, current, and next layout set branch 444 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 445 */ 446 public static LayoutSetBranch[] findByG_P_PrevAndNext( 447 long layoutSetBranchId, long groupId, boolean privateLayout, 448 OrderByComparator<LayoutSetBranch> orderByComparator) 449 throws com.liferay.portal.NoSuchLayoutSetBranchException { 450 return getPersistence() 451 .findByG_P_PrevAndNext(layoutSetBranchId, groupId, 452 privateLayout, orderByComparator); 453 } 454 455 /** 456 * Returns all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 457 * 458 * @param groupId the group ID 459 * @param privateLayout the private layout 460 * @return the matching layout set branchs that the user has permission to view 461 */ 462 public static List<LayoutSetBranch> filterFindByG_P(long groupId, 463 boolean privateLayout) { 464 return getPersistence().filterFindByG_P(groupId, privateLayout); 465 } 466 467 /** 468 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 469 * 470 * <p> 471 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 472 * </p> 473 * 474 * @param groupId the group ID 475 * @param privateLayout the private layout 476 * @param start the lower bound of the range of layout set branchs 477 * @param end the upper bound of the range of layout set branchs (not inclusive) 478 * @return the range of matching layout set branchs that the user has permission to view 479 */ 480 public static List<LayoutSetBranch> filterFindByG_P(long groupId, 481 boolean privateLayout, int start, int end) { 482 return getPersistence() 483 .filterFindByG_P(groupId, privateLayout, start, end); 484 } 485 486 /** 487 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ? and privateLayout = ?. 488 * 489 * <p> 490 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 491 * </p> 492 * 493 * @param groupId the group ID 494 * @param privateLayout the private layout 495 * @param start the lower bound of the range of layout set branchs 496 * @param end the upper bound of the range of layout set branchs (not inclusive) 497 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 498 * @return the ordered range of matching layout set branchs that the user has permission to view 499 */ 500 public static List<LayoutSetBranch> filterFindByG_P(long groupId, 501 boolean privateLayout, int start, int end, 502 OrderByComparator<LayoutSetBranch> orderByComparator) { 503 return getPersistence() 504 .filterFindByG_P(groupId, privateLayout, start, end, 505 orderByComparator); 506 } 507 508 /** 509 * Returns the layout set branchs before and after the current layout set branch in the ordered set of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 510 * 511 * @param layoutSetBranchId the primary key of the current layout set branch 512 * @param groupId the group ID 513 * @param privateLayout the private layout 514 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 515 * @return the previous, current, and next layout set branch 516 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 517 */ 518 public static LayoutSetBranch[] filterFindByG_P_PrevAndNext( 519 long layoutSetBranchId, long groupId, boolean privateLayout, 520 OrderByComparator<LayoutSetBranch> orderByComparator) 521 throws com.liferay.portal.NoSuchLayoutSetBranchException { 522 return getPersistence() 523 .filterFindByG_P_PrevAndNext(layoutSetBranchId, groupId, 524 privateLayout, orderByComparator); 525 } 526 527 /** 528 * Removes all the layout set branchs where groupId = ? and privateLayout = ? from the database. 529 * 530 * @param groupId the group ID 531 * @param privateLayout the private layout 532 */ 533 public static void removeByG_P(long groupId, boolean privateLayout) { 534 getPersistence().removeByG_P(groupId, privateLayout); 535 } 536 537 /** 538 * Returns the number of layout set branchs where groupId = ? and privateLayout = ?. 539 * 540 * @param groupId the group ID 541 * @param privateLayout the private layout 542 * @return the number of matching layout set branchs 543 */ 544 public static int countByG_P(long groupId, boolean privateLayout) { 545 return getPersistence().countByG_P(groupId, privateLayout); 546 } 547 548 /** 549 * Returns the number of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 550 * 551 * @param groupId the group ID 552 * @param privateLayout the private layout 553 * @return the number of matching layout set branchs that the user has permission to view 554 */ 555 public static int filterCountByG_P(long groupId, boolean privateLayout) { 556 return getPersistence().filterCountByG_P(groupId, privateLayout); 557 } 558 559 /** 560 * Returns the layout set branch where groupId = ? and privateLayout = ? and name = ? or throws a {@link NoSuchLayoutSetBranchException} if it could not be found. 561 * 562 * @param groupId the group ID 563 * @param privateLayout the private layout 564 * @param name the name 565 * @return the matching layout set branch 566 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 567 */ 568 public static LayoutSetBranch findByG_P_N(long groupId, 569 boolean privateLayout, java.lang.String name) 570 throws com.liferay.portal.NoSuchLayoutSetBranchException { 571 return getPersistence().findByG_P_N(groupId, privateLayout, name); 572 } 573 574 /** 575 * Returns the layout set branch where groupId = ? and privateLayout = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 576 * 577 * @param groupId the group ID 578 * @param privateLayout the private layout 579 * @param name the name 580 * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 581 */ 582 public static LayoutSetBranch fetchByG_P_N(long groupId, 583 boolean privateLayout, java.lang.String name) { 584 return getPersistence().fetchByG_P_N(groupId, privateLayout, name); 585 } 586 587 /** 588 * Returns the layout set branch where groupId = ? and privateLayout = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 589 * 590 * @param groupId the group ID 591 * @param privateLayout the private layout 592 * @param name the name 593 * @param retrieveFromCache whether to use the finder cache 594 * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 595 */ 596 public static LayoutSetBranch fetchByG_P_N(long groupId, 597 boolean privateLayout, java.lang.String name, boolean retrieveFromCache) { 598 return getPersistence() 599 .fetchByG_P_N(groupId, privateLayout, name, retrieveFromCache); 600 } 601 602 /** 603 * Removes the layout set branch where groupId = ? and privateLayout = ? and name = ? from the database. 604 * 605 * @param groupId the group ID 606 * @param privateLayout the private layout 607 * @param name the name 608 * @return the layout set branch that was removed 609 */ 610 public static LayoutSetBranch removeByG_P_N(long groupId, 611 boolean privateLayout, java.lang.String name) 612 throws com.liferay.portal.NoSuchLayoutSetBranchException { 613 return getPersistence().removeByG_P_N(groupId, privateLayout, name); 614 } 615 616 /** 617 * Returns the number of layout set branchs where groupId = ? and privateLayout = ? and name = ?. 618 * 619 * @param groupId the group ID 620 * @param privateLayout the private layout 621 * @param name the name 622 * @return the number of matching layout set branchs 623 */ 624 public static int countByG_P_N(long groupId, boolean privateLayout, 625 java.lang.String name) { 626 return getPersistence().countByG_P_N(groupId, privateLayout, name); 627 } 628 629 /** 630 * Returns all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 631 * 632 * @param groupId the group ID 633 * @param privateLayout the private layout 634 * @param master the master 635 * @return the matching layout set branchs 636 */ 637 public static List<LayoutSetBranch> findByG_P_M(long groupId, 638 boolean privateLayout, boolean master) { 639 return getPersistence().findByG_P_M(groupId, privateLayout, master); 640 } 641 642 /** 643 * Returns a range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 644 * 645 * <p> 646 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 647 * </p> 648 * 649 * @param groupId the group ID 650 * @param privateLayout the private layout 651 * @param master the master 652 * @param start the lower bound of the range of layout set branchs 653 * @param end the upper bound of the range of layout set branchs (not inclusive) 654 * @return the range of matching layout set branchs 655 */ 656 public static List<LayoutSetBranch> findByG_P_M(long groupId, 657 boolean privateLayout, boolean master, int start, int end) { 658 return getPersistence() 659 .findByG_P_M(groupId, privateLayout, master, start, end); 660 } 661 662 /** 663 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 664 * 665 * <p> 666 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 667 * </p> 668 * 669 * @param groupId the group ID 670 * @param privateLayout the private layout 671 * @param master the master 672 * @param start the lower bound of the range of layout set branchs 673 * @param end the upper bound of the range of layout set branchs (not inclusive) 674 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 675 * @return the ordered range of matching layout set branchs 676 */ 677 public static List<LayoutSetBranch> findByG_P_M(long groupId, 678 boolean privateLayout, boolean master, int start, int end, 679 OrderByComparator<LayoutSetBranch> orderByComparator) { 680 return getPersistence() 681 .findByG_P_M(groupId, privateLayout, master, start, end, 682 orderByComparator); 683 } 684 685 /** 686 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 687 * 688 * @param groupId the group ID 689 * @param privateLayout the private layout 690 * @param master the master 691 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 692 * @return the first matching layout set branch 693 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 694 */ 695 public static LayoutSetBranch findByG_P_M_First(long groupId, 696 boolean privateLayout, boolean master, 697 OrderByComparator<LayoutSetBranch> orderByComparator) 698 throws com.liferay.portal.NoSuchLayoutSetBranchException { 699 return getPersistence() 700 .findByG_P_M_First(groupId, privateLayout, master, 701 orderByComparator); 702 } 703 704 /** 705 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 706 * 707 * @param groupId the group ID 708 * @param privateLayout the private layout 709 * @param master the master 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 712 */ 713 public static LayoutSetBranch fetchByG_P_M_First(long groupId, 714 boolean privateLayout, boolean master, 715 OrderByComparator<LayoutSetBranch> orderByComparator) { 716 return getPersistence() 717 .fetchByG_P_M_First(groupId, privateLayout, master, 718 orderByComparator); 719 } 720 721 /** 722 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 723 * 724 * @param groupId the group ID 725 * @param privateLayout the private layout 726 * @param master the master 727 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 728 * @return the last matching layout set branch 729 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 730 */ 731 public static LayoutSetBranch findByG_P_M_Last(long groupId, 732 boolean privateLayout, boolean master, 733 OrderByComparator<LayoutSetBranch> orderByComparator) 734 throws com.liferay.portal.NoSuchLayoutSetBranchException { 735 return getPersistence() 736 .findByG_P_M_Last(groupId, privateLayout, master, 737 orderByComparator); 738 } 739 740 /** 741 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 742 * 743 * @param groupId the group ID 744 * @param privateLayout the private layout 745 * @param master the master 746 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 747 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 748 */ 749 public static LayoutSetBranch fetchByG_P_M_Last(long groupId, 750 boolean privateLayout, boolean master, 751 OrderByComparator<LayoutSetBranch> orderByComparator) { 752 return getPersistence() 753 .fetchByG_P_M_Last(groupId, privateLayout, master, 754 orderByComparator); 755 } 756 757 /** 758 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 759 * 760 * @param layoutSetBranchId the primary key of the current layout set branch 761 * @param groupId the group ID 762 * @param privateLayout the private layout 763 * @param master the master 764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 765 * @return the previous, current, and next layout set branch 766 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 767 */ 768 public static LayoutSetBranch[] findByG_P_M_PrevAndNext( 769 long layoutSetBranchId, long groupId, boolean privateLayout, 770 boolean master, OrderByComparator<LayoutSetBranch> orderByComparator) 771 throws com.liferay.portal.NoSuchLayoutSetBranchException { 772 return getPersistence() 773 .findByG_P_M_PrevAndNext(layoutSetBranchId, groupId, 774 privateLayout, master, orderByComparator); 775 } 776 777 /** 778 * Returns all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 779 * 780 * @param groupId the group ID 781 * @param privateLayout the private layout 782 * @param master the master 783 * @return the matching layout set branchs that the user has permission to view 784 */ 785 public static List<LayoutSetBranch> filterFindByG_P_M(long groupId, 786 boolean privateLayout, boolean master) { 787 return getPersistence().filterFindByG_P_M(groupId, privateLayout, master); 788 } 789 790 /** 791 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 792 * 793 * <p> 794 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 795 * </p> 796 * 797 * @param groupId the group ID 798 * @param privateLayout the private layout 799 * @param master the master 800 * @param start the lower bound of the range of layout set branchs 801 * @param end the upper bound of the range of layout set branchs (not inclusive) 802 * @return the range of matching layout set branchs that the user has permission to view 803 */ 804 public static List<LayoutSetBranch> filterFindByG_P_M(long groupId, 805 boolean privateLayout, boolean master, int start, int end) { 806 return getPersistence() 807 .filterFindByG_P_M(groupId, privateLayout, master, start, end); 808 } 809 810 /** 811 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ? and privateLayout = ? and master = ?. 812 * 813 * <p> 814 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 815 * </p> 816 * 817 * @param groupId the group ID 818 * @param privateLayout the private layout 819 * @param master the master 820 * @param start the lower bound of the range of layout set branchs 821 * @param end the upper bound of the range of layout set branchs (not inclusive) 822 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 823 * @return the ordered range of matching layout set branchs that the user has permission to view 824 */ 825 public static List<LayoutSetBranch> filterFindByG_P_M(long groupId, 826 boolean privateLayout, boolean master, int start, int end, 827 OrderByComparator<LayoutSetBranch> orderByComparator) { 828 return getPersistence() 829 .filterFindByG_P_M(groupId, privateLayout, master, start, 830 end, orderByComparator); 831 } 832 833 /** 834 * Returns the layout set branchs before and after the current layout set branch in the ordered set of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 835 * 836 * @param layoutSetBranchId the primary key of the current layout set branch 837 * @param groupId the group ID 838 * @param privateLayout the private layout 839 * @param master the master 840 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 841 * @return the previous, current, and next layout set branch 842 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 843 */ 844 public static LayoutSetBranch[] filterFindByG_P_M_PrevAndNext( 845 long layoutSetBranchId, long groupId, boolean privateLayout, 846 boolean master, OrderByComparator<LayoutSetBranch> orderByComparator) 847 throws com.liferay.portal.NoSuchLayoutSetBranchException { 848 return getPersistence() 849 .filterFindByG_P_M_PrevAndNext(layoutSetBranchId, groupId, 850 privateLayout, master, orderByComparator); 851 } 852 853 /** 854 * Removes all the layout set branchs where groupId = ? and privateLayout = ? and master = ? from the database. 855 * 856 * @param groupId the group ID 857 * @param privateLayout the private layout 858 * @param master the master 859 */ 860 public static void removeByG_P_M(long groupId, boolean privateLayout, 861 boolean master) { 862 getPersistence().removeByG_P_M(groupId, privateLayout, master); 863 } 864 865 /** 866 * Returns the number of layout set branchs where groupId = ? and privateLayout = ? and master = ?. 867 * 868 * @param groupId the group ID 869 * @param privateLayout the private layout 870 * @param master the master 871 * @return the number of matching layout set branchs 872 */ 873 public static int countByG_P_M(long groupId, boolean privateLayout, 874 boolean master) { 875 return getPersistence().countByG_P_M(groupId, privateLayout, master); 876 } 877 878 /** 879 * Returns the number of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 880 * 881 * @param groupId the group ID 882 * @param privateLayout the private layout 883 * @param master the master 884 * @return the number of matching layout set branchs that the user has permission to view 885 */ 886 public static int filterCountByG_P_M(long groupId, boolean privateLayout, 887 boolean master) { 888 return getPersistence() 889 .filterCountByG_P_M(groupId, privateLayout, master); 890 } 891 892 /** 893 * Caches the layout set branch in the entity cache if it is enabled. 894 * 895 * @param layoutSetBranch the layout set branch 896 */ 897 public static void cacheResult(LayoutSetBranch layoutSetBranch) { 898 getPersistence().cacheResult(layoutSetBranch); 899 } 900 901 /** 902 * Caches the layout set branchs in the entity cache if it is enabled. 903 * 904 * @param layoutSetBranchs the layout set branchs 905 */ 906 public static void cacheResult(List<LayoutSetBranch> layoutSetBranchs) { 907 getPersistence().cacheResult(layoutSetBranchs); 908 } 909 910 /** 911 * Creates a new layout set branch with the primary key. Does not add the layout set branch to the database. 912 * 913 * @param layoutSetBranchId the primary key for the new layout set branch 914 * @return the new layout set branch 915 */ 916 public static LayoutSetBranch create(long layoutSetBranchId) { 917 return getPersistence().create(layoutSetBranchId); 918 } 919 920 /** 921 * Removes the layout set branch with the primary key from the database. Also notifies the appropriate model listeners. 922 * 923 * @param layoutSetBranchId the primary key of the layout set branch 924 * @return the layout set branch that was removed 925 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 926 */ 927 public static LayoutSetBranch remove(long layoutSetBranchId) 928 throws com.liferay.portal.NoSuchLayoutSetBranchException { 929 return getPersistence().remove(layoutSetBranchId); 930 } 931 932 public static LayoutSetBranch updateImpl(LayoutSetBranch layoutSetBranch) { 933 return getPersistence().updateImpl(layoutSetBranch); 934 } 935 936 /** 937 * Returns the layout set branch with the primary key or throws a {@link NoSuchLayoutSetBranchException} if it could not be found. 938 * 939 * @param layoutSetBranchId the primary key of the layout set branch 940 * @return the layout set branch 941 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 942 */ 943 public static LayoutSetBranch findByPrimaryKey(long layoutSetBranchId) 944 throws com.liferay.portal.NoSuchLayoutSetBranchException { 945 return getPersistence().findByPrimaryKey(layoutSetBranchId); 946 } 947 948 /** 949 * Returns the layout set branch with the primary key or returns <code>null</code> if it could not be found. 950 * 951 * @param layoutSetBranchId the primary key of the layout set branch 952 * @return the layout set branch, or <code>null</code> if a layout set branch with the primary key could not be found 953 */ 954 public static LayoutSetBranch fetchByPrimaryKey(long layoutSetBranchId) { 955 return getPersistence().fetchByPrimaryKey(layoutSetBranchId); 956 } 957 958 public static java.util.Map<java.io.Serializable, LayoutSetBranch> fetchByPrimaryKeys( 959 java.util.Set<java.io.Serializable> primaryKeys) { 960 return getPersistence().fetchByPrimaryKeys(primaryKeys); 961 } 962 963 /** 964 * Returns all the layout set branchs. 965 * 966 * @return the layout set branchs 967 */ 968 public static List<LayoutSetBranch> findAll() { 969 return getPersistence().findAll(); 970 } 971 972 /** 973 * Returns a range of all the layout set branchs. 974 * 975 * <p> 976 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 977 * </p> 978 * 979 * @param start the lower bound of the range of layout set branchs 980 * @param end the upper bound of the range of layout set branchs (not inclusive) 981 * @return the range of layout set branchs 982 */ 983 public static List<LayoutSetBranch> findAll(int start, int end) { 984 return getPersistence().findAll(start, end); 985 } 986 987 /** 988 * Returns an ordered range of all the layout set branchs. 989 * 990 * <p> 991 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetBranchModelImpl}. 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. 992 * </p> 993 * 994 * @param start the lower bound of the range of layout set branchs 995 * @param end the upper bound of the range of layout set branchs (not inclusive) 996 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 997 * @return the ordered range of layout set branchs 998 */ 999 public static List<LayoutSetBranch> findAll(int start, int end, 1000 OrderByComparator<LayoutSetBranch> orderByComparator) { 1001 return getPersistence().findAll(start, end, orderByComparator); 1002 } 1003 1004 /** 1005 * Removes all the layout set branchs from the database. 1006 */ 1007 public static void removeAll() { 1008 getPersistence().removeAll(); 1009 } 1010 1011 /** 1012 * Returns the number of layout set branchs. 1013 * 1014 * @return the number of layout set branchs 1015 */ 1016 public static int countAll() { 1017 return getPersistence().countAll(); 1018 } 1019 1020 public static LayoutSetBranchPersistence getPersistence() { 1021 if (_persistence == null) { 1022 _persistence = (LayoutSetBranchPersistence)PortalBeanLocatorUtil.locate(LayoutSetBranchPersistence.class.getName()); 1023 1024 ReferenceRegistry.registerReference(LayoutSetBranchUtil.class, 1025 "_persistence"); 1026 } 1027 1028 return _persistence; 1029 } 1030 1031 /** 1032 * @deprecated As of 6.2.0 1033 */ 1034 @Deprecated 1035 public void setPersistence(LayoutSetBranchPersistence persistence) { 1036 } 1037 1038 private static LayoutSetBranchPersistence _persistence; 1039 }