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 an ordered range of all the layout set branchs where groupId = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param groupId the group ID 165 * @param start the lower bound of the range of layout set branchs 166 * @param end the upper bound of the range of layout set branchs (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching layout set branchs 170 */ 171 public static List<LayoutSetBranch> findByGroupId(long groupId, int start, 172 int end, OrderByComparator<LayoutSetBranch> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByGroupId(groupId, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first layout set branch in the ordered set where groupId = ?. 181 * 182 * @param groupId the group ID 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching layout set branch 185 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 186 */ 187 public static LayoutSetBranch findByGroupId_First(long groupId, 188 OrderByComparator<LayoutSetBranch> orderByComparator) 189 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 190 return getPersistence().findByGroupId_First(groupId, orderByComparator); 191 } 192 193 /** 194 * Returns the first layout set branch in the ordered set where groupId = ?. 195 * 196 * @param groupId the group ID 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 199 */ 200 public static LayoutSetBranch fetchByGroupId_First(long groupId, 201 OrderByComparator<LayoutSetBranch> orderByComparator) { 202 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 203 } 204 205 /** 206 * Returns the last layout set branch in the ordered set where groupId = ?. 207 * 208 * @param groupId the group ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching layout set branch 211 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 212 */ 213 public static LayoutSetBranch findByGroupId_Last(long groupId, 214 OrderByComparator<LayoutSetBranch> orderByComparator) 215 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 216 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 217 } 218 219 /** 220 * Returns the last layout set branch in the ordered set where groupId = ?. 221 * 222 * @param groupId the group ID 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 225 */ 226 public static LayoutSetBranch fetchByGroupId_Last(long groupId, 227 OrderByComparator<LayoutSetBranch> orderByComparator) { 228 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 229 } 230 231 /** 232 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ?. 233 * 234 * @param layoutSetBranchId the primary key of the current layout set branch 235 * @param groupId the group ID 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next layout set branch 238 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 239 */ 240 public static LayoutSetBranch[] findByGroupId_PrevAndNext( 241 long layoutSetBranchId, long groupId, 242 OrderByComparator<LayoutSetBranch> orderByComparator) 243 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 244 return getPersistence() 245 .findByGroupId_PrevAndNext(layoutSetBranchId, groupId, 246 orderByComparator); 247 } 248 249 /** 250 * Returns all the layout set branchs that the user has permission to view where groupId = ?. 251 * 252 * @param groupId the group ID 253 * @return the matching layout set branchs that the user has permission to view 254 */ 255 public static List<LayoutSetBranch> filterFindByGroupId(long groupId) { 256 return getPersistence().filterFindByGroupId(groupId); 257 } 258 259 /** 260 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ?. 261 * 262 * <p> 263 * 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. 264 * </p> 265 * 266 * @param groupId the group ID 267 * @param start the lower bound of the range of layout set branchs 268 * @param end the upper bound of the range of layout set branchs (not inclusive) 269 * @return the range of matching layout set branchs that the user has permission to view 270 */ 271 public static List<LayoutSetBranch> filterFindByGroupId(long groupId, 272 int start, int end) { 273 return getPersistence().filterFindByGroupId(groupId, start, end); 274 } 275 276 /** 277 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ?. 278 * 279 * <p> 280 * 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. 281 * </p> 282 * 283 * @param groupId the group ID 284 * @param start the lower bound of the range of layout set branchs 285 * @param end the upper bound of the range of layout set branchs (not inclusive) 286 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 287 * @return the ordered range of matching layout set branchs that the user has permission to view 288 */ 289 public static List<LayoutSetBranch> filterFindByGroupId(long groupId, 290 int start, int end, OrderByComparator<LayoutSetBranch> orderByComparator) { 291 return getPersistence() 292 .filterFindByGroupId(groupId, start, end, orderByComparator); 293 } 294 295 /** 296 * 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 = ?. 297 * 298 * @param layoutSetBranchId the primary key of the current layout set branch 299 * @param groupId the group ID 300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 301 * @return the previous, current, and next layout set branch 302 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 303 */ 304 public static LayoutSetBranch[] filterFindByGroupId_PrevAndNext( 305 long layoutSetBranchId, long groupId, 306 OrderByComparator<LayoutSetBranch> orderByComparator) 307 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 308 return getPersistence() 309 .filterFindByGroupId_PrevAndNext(layoutSetBranchId, groupId, 310 orderByComparator); 311 } 312 313 /** 314 * Removes all the layout set branchs where groupId = ? from the database. 315 * 316 * @param groupId the group ID 317 */ 318 public static void removeByGroupId(long groupId) { 319 getPersistence().removeByGroupId(groupId); 320 } 321 322 /** 323 * Returns the number of layout set branchs where groupId = ?. 324 * 325 * @param groupId the group ID 326 * @return the number of matching layout set branchs 327 */ 328 public static int countByGroupId(long groupId) { 329 return getPersistence().countByGroupId(groupId); 330 } 331 332 /** 333 * Returns the number of layout set branchs that the user has permission to view where groupId = ?. 334 * 335 * @param groupId the group ID 336 * @return the number of matching layout set branchs that the user has permission to view 337 */ 338 public static int filterCountByGroupId(long groupId) { 339 return getPersistence().filterCountByGroupId(groupId); 340 } 341 342 /** 343 * Returns all the layout set branchs where groupId = ? and privateLayout = ?. 344 * 345 * @param groupId the group ID 346 * @param privateLayout the private layout 347 * @return the matching layout set branchs 348 */ 349 public static List<LayoutSetBranch> findByG_P(long groupId, 350 boolean privateLayout) { 351 return getPersistence().findByG_P(groupId, privateLayout); 352 } 353 354 /** 355 * Returns a range of all the layout set branchs where groupId = ? and privateLayout = ?. 356 * 357 * <p> 358 * 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. 359 * </p> 360 * 361 * @param groupId the group ID 362 * @param privateLayout the private layout 363 * @param start the lower bound of the range of layout set branchs 364 * @param end the upper bound of the range of layout set branchs (not inclusive) 365 * @return the range of matching layout set branchs 366 */ 367 public static List<LayoutSetBranch> findByG_P(long groupId, 368 boolean privateLayout, int start, int end) { 369 return getPersistence().findByG_P(groupId, privateLayout, start, end); 370 } 371 372 /** 373 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ?. 374 * 375 * <p> 376 * 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. 377 * </p> 378 * 379 * @param groupId the group ID 380 * @param privateLayout the private layout 381 * @param start the lower bound of the range of layout set branchs 382 * @param end the upper bound of the range of layout set branchs (not inclusive) 383 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 384 * @return the ordered range of matching layout set branchs 385 */ 386 public static List<LayoutSetBranch> findByG_P(long groupId, 387 boolean privateLayout, int start, int end, 388 OrderByComparator<LayoutSetBranch> orderByComparator) { 389 return getPersistence() 390 .findByG_P(groupId, privateLayout, start, end, 391 orderByComparator); 392 } 393 394 /** 395 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ?. 396 * 397 * <p> 398 * 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. 399 * </p> 400 * 401 * @param groupId the group ID 402 * @param privateLayout the private layout 403 * @param start the lower bound of the range of layout set branchs 404 * @param end the upper bound of the range of layout set branchs (not inclusive) 405 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 406 * @param retrieveFromCache whether to retrieve from the finder cache 407 * @return the ordered range of matching layout set branchs 408 */ 409 public static List<LayoutSetBranch> findByG_P(long groupId, 410 boolean privateLayout, int start, int end, 411 OrderByComparator<LayoutSetBranch> orderByComparator, 412 boolean retrieveFromCache) { 413 return getPersistence() 414 .findByG_P(groupId, privateLayout, start, end, 415 orderByComparator, retrieveFromCache); 416 } 417 418 /** 419 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ?. 420 * 421 * @param groupId the group ID 422 * @param privateLayout the private layout 423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 424 * @return the first matching layout set branch 425 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 426 */ 427 public static LayoutSetBranch findByG_P_First(long groupId, 428 boolean privateLayout, 429 OrderByComparator<LayoutSetBranch> orderByComparator) 430 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 431 return getPersistence() 432 .findByG_P_First(groupId, privateLayout, orderByComparator); 433 } 434 435 /** 436 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ?. 437 * 438 * @param groupId the group ID 439 * @param privateLayout the private layout 440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 441 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 442 */ 443 public static LayoutSetBranch fetchByG_P_First(long groupId, 444 boolean privateLayout, 445 OrderByComparator<LayoutSetBranch> orderByComparator) { 446 return getPersistence() 447 .fetchByG_P_First(groupId, privateLayout, orderByComparator); 448 } 449 450 /** 451 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ?. 452 * 453 * @param groupId the group ID 454 * @param privateLayout the private layout 455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 456 * @return the last matching layout set branch 457 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 458 */ 459 public static LayoutSetBranch findByG_P_Last(long groupId, 460 boolean privateLayout, 461 OrderByComparator<LayoutSetBranch> orderByComparator) 462 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 463 return getPersistence() 464 .findByG_P_Last(groupId, privateLayout, orderByComparator); 465 } 466 467 /** 468 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ?. 469 * 470 * @param groupId the group ID 471 * @param privateLayout the private layout 472 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 473 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 474 */ 475 public static LayoutSetBranch fetchByG_P_Last(long groupId, 476 boolean privateLayout, 477 OrderByComparator<LayoutSetBranch> orderByComparator) { 478 return getPersistence() 479 .fetchByG_P_Last(groupId, privateLayout, orderByComparator); 480 } 481 482 /** 483 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ? and privateLayout = ?. 484 * 485 * @param layoutSetBranchId the primary key of the current layout set branch 486 * @param groupId the group ID 487 * @param privateLayout the private layout 488 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 489 * @return the previous, current, and next layout set branch 490 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 491 */ 492 public static LayoutSetBranch[] findByG_P_PrevAndNext( 493 long layoutSetBranchId, long groupId, boolean privateLayout, 494 OrderByComparator<LayoutSetBranch> orderByComparator) 495 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 496 return getPersistence() 497 .findByG_P_PrevAndNext(layoutSetBranchId, groupId, 498 privateLayout, orderByComparator); 499 } 500 501 /** 502 * Returns all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 503 * 504 * @param groupId the group ID 505 * @param privateLayout the private layout 506 * @return the matching layout set branchs that the user has permission to view 507 */ 508 public static List<LayoutSetBranch> filterFindByG_P(long groupId, 509 boolean privateLayout) { 510 return getPersistence().filterFindByG_P(groupId, privateLayout); 511 } 512 513 /** 514 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 515 * 516 * <p> 517 * 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. 518 * </p> 519 * 520 * @param groupId the group ID 521 * @param privateLayout the private layout 522 * @param start the lower bound of the range of layout set branchs 523 * @param end the upper bound of the range of layout set branchs (not inclusive) 524 * @return the range of matching layout set branchs that the user has permission to view 525 */ 526 public static List<LayoutSetBranch> filterFindByG_P(long groupId, 527 boolean privateLayout, int start, int end) { 528 return getPersistence() 529 .filterFindByG_P(groupId, privateLayout, start, end); 530 } 531 532 /** 533 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ? and privateLayout = ?. 534 * 535 * <p> 536 * 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. 537 * </p> 538 * 539 * @param groupId the group ID 540 * @param privateLayout the private layout 541 * @param start the lower bound of the range of layout set branchs 542 * @param end the upper bound of the range of layout set branchs (not inclusive) 543 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 544 * @return the ordered range of matching layout set branchs that the user has permission to view 545 */ 546 public static List<LayoutSetBranch> filterFindByG_P(long groupId, 547 boolean privateLayout, int start, int end, 548 OrderByComparator<LayoutSetBranch> orderByComparator) { 549 return getPersistence() 550 .filterFindByG_P(groupId, privateLayout, start, end, 551 orderByComparator); 552 } 553 554 /** 555 * 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 = ?. 556 * 557 * @param layoutSetBranchId the primary key of the current layout set branch 558 * @param groupId the group ID 559 * @param privateLayout the private layout 560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 561 * @return the previous, current, and next layout set branch 562 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 563 */ 564 public static LayoutSetBranch[] filterFindByG_P_PrevAndNext( 565 long layoutSetBranchId, long groupId, boolean privateLayout, 566 OrderByComparator<LayoutSetBranch> orderByComparator) 567 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 568 return getPersistence() 569 .filterFindByG_P_PrevAndNext(layoutSetBranchId, groupId, 570 privateLayout, orderByComparator); 571 } 572 573 /** 574 * Removes all the layout set branchs where groupId = ? and privateLayout = ? from the database. 575 * 576 * @param groupId the group ID 577 * @param privateLayout the private layout 578 */ 579 public static void removeByG_P(long groupId, boolean privateLayout) { 580 getPersistence().removeByG_P(groupId, privateLayout); 581 } 582 583 /** 584 * Returns the number of layout set branchs where groupId = ? and privateLayout = ?. 585 * 586 * @param groupId the group ID 587 * @param privateLayout the private layout 588 * @return the number of matching layout set branchs 589 */ 590 public static int countByG_P(long groupId, boolean privateLayout) { 591 return getPersistence().countByG_P(groupId, privateLayout); 592 } 593 594 /** 595 * Returns the number of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 596 * 597 * @param groupId the group ID 598 * @param privateLayout the private layout 599 * @return the number of matching layout set branchs that the user has permission to view 600 */ 601 public static int filterCountByG_P(long groupId, boolean privateLayout) { 602 return getPersistence().filterCountByG_P(groupId, privateLayout); 603 } 604 605 /** 606 * Returns the layout set branch where groupId = ? and privateLayout = ? and name = ? or throws a {@link NoSuchLayoutSetBranchException} if it could not be found. 607 * 608 * @param groupId the group ID 609 * @param privateLayout the private layout 610 * @param name the name 611 * @return the matching layout set branch 612 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 613 */ 614 public static LayoutSetBranch findByG_P_N(long groupId, 615 boolean privateLayout, java.lang.String name) 616 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 617 return getPersistence().findByG_P_N(groupId, privateLayout, name); 618 } 619 620 /** 621 * 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. 622 * 623 * @param groupId the group ID 624 * @param privateLayout the private layout 625 * @param name the name 626 * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 627 */ 628 public static LayoutSetBranch fetchByG_P_N(long groupId, 629 boolean privateLayout, java.lang.String name) { 630 return getPersistence().fetchByG_P_N(groupId, privateLayout, name); 631 } 632 633 /** 634 * 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. 635 * 636 * @param groupId the group ID 637 * @param privateLayout the private layout 638 * @param name the name 639 * @param retrieveFromCache whether to retrieve from the finder cache 640 * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 641 */ 642 public static LayoutSetBranch fetchByG_P_N(long groupId, 643 boolean privateLayout, java.lang.String name, boolean retrieveFromCache) { 644 return getPersistence() 645 .fetchByG_P_N(groupId, privateLayout, name, retrieveFromCache); 646 } 647 648 /** 649 * Removes the layout set branch where groupId = ? and privateLayout = ? and name = ? from the database. 650 * 651 * @param groupId the group ID 652 * @param privateLayout the private layout 653 * @param name the name 654 * @return the layout set branch that was removed 655 */ 656 public static LayoutSetBranch removeByG_P_N(long groupId, 657 boolean privateLayout, java.lang.String name) 658 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 659 return getPersistence().removeByG_P_N(groupId, privateLayout, name); 660 } 661 662 /** 663 * Returns the number of layout set branchs where groupId = ? and privateLayout = ? and name = ?. 664 * 665 * @param groupId the group ID 666 * @param privateLayout the private layout 667 * @param name the name 668 * @return the number of matching layout set branchs 669 */ 670 public static int countByG_P_N(long groupId, boolean privateLayout, 671 java.lang.String name) { 672 return getPersistence().countByG_P_N(groupId, privateLayout, name); 673 } 674 675 /** 676 * Returns all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 677 * 678 * @param groupId the group ID 679 * @param privateLayout the private layout 680 * @param master the master 681 * @return the matching layout set branchs 682 */ 683 public static List<LayoutSetBranch> findByG_P_M(long groupId, 684 boolean privateLayout, boolean master) { 685 return getPersistence().findByG_P_M(groupId, privateLayout, master); 686 } 687 688 /** 689 * Returns a range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 690 * 691 * <p> 692 * 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. 693 * </p> 694 * 695 * @param groupId the group ID 696 * @param privateLayout the private layout 697 * @param master the master 698 * @param start the lower bound of the range of layout set branchs 699 * @param end the upper bound of the range of layout set branchs (not inclusive) 700 * @return the range of matching layout set branchs 701 */ 702 public static List<LayoutSetBranch> findByG_P_M(long groupId, 703 boolean privateLayout, boolean master, int start, int end) { 704 return getPersistence() 705 .findByG_P_M(groupId, privateLayout, master, start, end); 706 } 707 708 /** 709 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 710 * 711 * <p> 712 * 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. 713 * </p> 714 * 715 * @param groupId the group ID 716 * @param privateLayout the private layout 717 * @param master the master 718 * @param start the lower bound of the range of layout set branchs 719 * @param end the upper bound of the range of layout set branchs (not inclusive) 720 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 721 * @return the ordered range of matching layout set branchs 722 */ 723 public static List<LayoutSetBranch> findByG_P_M(long groupId, 724 boolean privateLayout, boolean master, int start, int end, 725 OrderByComparator<LayoutSetBranch> orderByComparator) { 726 return getPersistence() 727 .findByG_P_M(groupId, privateLayout, master, start, end, 728 orderByComparator); 729 } 730 731 /** 732 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 733 * 734 * <p> 735 * 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. 736 * </p> 737 * 738 * @param groupId the group ID 739 * @param privateLayout the private layout 740 * @param master the master 741 * @param start the lower bound of the range of layout set branchs 742 * @param end the upper bound of the range of layout set branchs (not inclusive) 743 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 744 * @param retrieveFromCache whether to retrieve from the finder cache 745 * @return the ordered range of matching layout set branchs 746 */ 747 public static List<LayoutSetBranch> findByG_P_M(long groupId, 748 boolean privateLayout, boolean master, int start, int end, 749 OrderByComparator<LayoutSetBranch> orderByComparator, 750 boolean retrieveFromCache) { 751 return getPersistence() 752 .findByG_P_M(groupId, privateLayout, master, start, end, 753 orderByComparator, retrieveFromCache); 754 } 755 756 /** 757 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 758 * 759 * @param groupId the group ID 760 * @param privateLayout the private layout 761 * @param master the master 762 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 763 * @return the first matching layout set branch 764 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 765 */ 766 public static LayoutSetBranch findByG_P_M_First(long groupId, 767 boolean privateLayout, boolean master, 768 OrderByComparator<LayoutSetBranch> orderByComparator) 769 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 770 return getPersistence() 771 .findByG_P_M_First(groupId, privateLayout, master, 772 orderByComparator); 773 } 774 775 /** 776 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 777 * 778 * @param groupId the group ID 779 * @param privateLayout the private layout 780 * @param master the master 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 783 */ 784 public static LayoutSetBranch fetchByG_P_M_First(long groupId, 785 boolean privateLayout, boolean master, 786 OrderByComparator<LayoutSetBranch> orderByComparator) { 787 return getPersistence() 788 .fetchByG_P_M_First(groupId, privateLayout, master, 789 orderByComparator); 790 } 791 792 /** 793 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 794 * 795 * @param groupId the group ID 796 * @param privateLayout the private layout 797 * @param master the master 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching layout set branch 800 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 801 */ 802 public static LayoutSetBranch findByG_P_M_Last(long groupId, 803 boolean privateLayout, boolean master, 804 OrderByComparator<LayoutSetBranch> orderByComparator) 805 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 806 return getPersistence() 807 .findByG_P_M_Last(groupId, privateLayout, master, 808 orderByComparator); 809 } 810 811 /** 812 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 813 * 814 * @param groupId the group ID 815 * @param privateLayout the private layout 816 * @param master the master 817 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 818 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 819 */ 820 public static LayoutSetBranch fetchByG_P_M_Last(long groupId, 821 boolean privateLayout, boolean master, 822 OrderByComparator<LayoutSetBranch> orderByComparator) { 823 return getPersistence() 824 .fetchByG_P_M_Last(groupId, privateLayout, master, 825 orderByComparator); 826 } 827 828 /** 829 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 830 * 831 * @param layoutSetBranchId the primary key of the current layout set branch 832 * @param groupId the group ID 833 * @param privateLayout the private layout 834 * @param master the master 835 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 836 * @return the previous, current, and next layout set branch 837 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 838 */ 839 public static LayoutSetBranch[] findByG_P_M_PrevAndNext( 840 long layoutSetBranchId, long groupId, boolean privateLayout, 841 boolean master, OrderByComparator<LayoutSetBranch> orderByComparator) 842 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 843 return getPersistence() 844 .findByG_P_M_PrevAndNext(layoutSetBranchId, groupId, 845 privateLayout, master, orderByComparator); 846 } 847 848 /** 849 * Returns all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 850 * 851 * @param groupId the group ID 852 * @param privateLayout the private layout 853 * @param master the master 854 * @return the matching layout set branchs that the user has permission to view 855 */ 856 public static List<LayoutSetBranch> filterFindByG_P_M(long groupId, 857 boolean privateLayout, boolean master) { 858 return getPersistence().filterFindByG_P_M(groupId, privateLayout, master); 859 } 860 861 /** 862 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 863 * 864 * <p> 865 * 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. 866 * </p> 867 * 868 * @param groupId the group ID 869 * @param privateLayout the private layout 870 * @param master the master 871 * @param start the lower bound of the range of layout set branchs 872 * @param end the upper bound of the range of layout set branchs (not inclusive) 873 * @return the range of matching layout set branchs that the user has permission to view 874 */ 875 public static List<LayoutSetBranch> filterFindByG_P_M(long groupId, 876 boolean privateLayout, boolean master, int start, int end) { 877 return getPersistence() 878 .filterFindByG_P_M(groupId, privateLayout, master, start, end); 879 } 880 881 /** 882 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ? and privateLayout = ? and master = ?. 883 * 884 * <p> 885 * 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. 886 * </p> 887 * 888 * @param groupId the group ID 889 * @param privateLayout the private layout 890 * @param master the master 891 * @param start the lower bound of the range of layout set branchs 892 * @param end the upper bound of the range of layout set branchs (not inclusive) 893 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 894 * @return the ordered range of matching layout set branchs that the user has permission to view 895 */ 896 public static List<LayoutSetBranch> filterFindByG_P_M(long groupId, 897 boolean privateLayout, boolean master, int start, int end, 898 OrderByComparator<LayoutSetBranch> orderByComparator) { 899 return getPersistence() 900 .filterFindByG_P_M(groupId, privateLayout, master, start, 901 end, orderByComparator); 902 } 903 904 /** 905 * 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 = ?. 906 * 907 * @param layoutSetBranchId the primary key of the current layout set branch 908 * @param groupId the group ID 909 * @param privateLayout the private layout 910 * @param master the master 911 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 912 * @return the previous, current, and next layout set branch 913 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 914 */ 915 public static LayoutSetBranch[] filterFindByG_P_M_PrevAndNext( 916 long layoutSetBranchId, long groupId, boolean privateLayout, 917 boolean master, OrderByComparator<LayoutSetBranch> orderByComparator) 918 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 919 return getPersistence() 920 .filterFindByG_P_M_PrevAndNext(layoutSetBranchId, groupId, 921 privateLayout, master, orderByComparator); 922 } 923 924 /** 925 * Removes all the layout set branchs where groupId = ? and privateLayout = ? and master = ? from the database. 926 * 927 * @param groupId the group ID 928 * @param privateLayout the private layout 929 * @param master the master 930 */ 931 public static void removeByG_P_M(long groupId, boolean privateLayout, 932 boolean master) { 933 getPersistence().removeByG_P_M(groupId, privateLayout, master); 934 } 935 936 /** 937 * Returns the number of layout set branchs where groupId = ? and privateLayout = ? and master = ?. 938 * 939 * @param groupId the group ID 940 * @param privateLayout the private layout 941 * @param master the master 942 * @return the number of matching layout set branchs 943 */ 944 public static int countByG_P_M(long groupId, boolean privateLayout, 945 boolean master) { 946 return getPersistence().countByG_P_M(groupId, privateLayout, master); 947 } 948 949 /** 950 * Returns the number of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 951 * 952 * @param groupId the group ID 953 * @param privateLayout the private layout 954 * @param master the master 955 * @return the number of matching layout set branchs that the user has permission to view 956 */ 957 public static int filterCountByG_P_M(long groupId, boolean privateLayout, 958 boolean master) { 959 return getPersistence() 960 .filterCountByG_P_M(groupId, privateLayout, master); 961 } 962 963 /** 964 * Caches the layout set branch in the entity cache if it is enabled. 965 * 966 * @param layoutSetBranch the layout set branch 967 */ 968 public static void cacheResult(LayoutSetBranch layoutSetBranch) { 969 getPersistence().cacheResult(layoutSetBranch); 970 } 971 972 /** 973 * Caches the layout set branchs in the entity cache if it is enabled. 974 * 975 * @param layoutSetBranchs the layout set branchs 976 */ 977 public static void cacheResult(List<LayoutSetBranch> layoutSetBranchs) { 978 getPersistence().cacheResult(layoutSetBranchs); 979 } 980 981 /** 982 * Creates a new layout set branch with the primary key. Does not add the layout set branch to the database. 983 * 984 * @param layoutSetBranchId the primary key for the new layout set branch 985 * @return the new layout set branch 986 */ 987 public static LayoutSetBranch create(long layoutSetBranchId) { 988 return getPersistence().create(layoutSetBranchId); 989 } 990 991 /** 992 * Removes the layout set branch with the primary key from the database. Also notifies the appropriate model listeners. 993 * 994 * @param layoutSetBranchId the primary key of the layout set branch 995 * @return the layout set branch that was removed 996 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 997 */ 998 public static LayoutSetBranch remove(long layoutSetBranchId) 999 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 1000 return getPersistence().remove(layoutSetBranchId); 1001 } 1002 1003 public static LayoutSetBranch updateImpl(LayoutSetBranch layoutSetBranch) { 1004 return getPersistence().updateImpl(layoutSetBranch); 1005 } 1006 1007 /** 1008 * Returns the layout set branch with the primary key or throws a {@link NoSuchLayoutSetBranchException} if it could not be found. 1009 * 1010 * @param layoutSetBranchId the primary key of the layout set branch 1011 * @return the layout set branch 1012 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 1013 */ 1014 public static LayoutSetBranch findByPrimaryKey(long layoutSetBranchId) 1015 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException { 1016 return getPersistence().findByPrimaryKey(layoutSetBranchId); 1017 } 1018 1019 /** 1020 * Returns the layout set branch with the primary key or returns <code>null</code> if it could not be found. 1021 * 1022 * @param layoutSetBranchId the primary key of the layout set branch 1023 * @return the layout set branch, or <code>null</code> if a layout set branch with the primary key could not be found 1024 */ 1025 public static LayoutSetBranch fetchByPrimaryKey(long layoutSetBranchId) { 1026 return getPersistence().fetchByPrimaryKey(layoutSetBranchId); 1027 } 1028 1029 public static java.util.Map<java.io.Serializable, LayoutSetBranch> fetchByPrimaryKeys( 1030 java.util.Set<java.io.Serializable> primaryKeys) { 1031 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1032 } 1033 1034 /** 1035 * Returns all the layout set branchs. 1036 * 1037 * @return the layout set branchs 1038 */ 1039 public static List<LayoutSetBranch> findAll() { 1040 return getPersistence().findAll(); 1041 } 1042 1043 /** 1044 * Returns a range of all the layout set branchs. 1045 * 1046 * <p> 1047 * 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. 1048 * </p> 1049 * 1050 * @param start the lower bound of the range of layout set branchs 1051 * @param end the upper bound of the range of layout set branchs (not inclusive) 1052 * @return the range of layout set branchs 1053 */ 1054 public static List<LayoutSetBranch> findAll(int start, int end) { 1055 return getPersistence().findAll(start, end); 1056 } 1057 1058 /** 1059 * Returns an ordered range of all the layout set branchs. 1060 * 1061 * <p> 1062 * 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. 1063 * </p> 1064 * 1065 * @param start the lower bound of the range of layout set branchs 1066 * @param end the upper bound of the range of layout set branchs (not inclusive) 1067 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1068 * @return the ordered range of layout set branchs 1069 */ 1070 public static List<LayoutSetBranch> findAll(int start, int end, 1071 OrderByComparator<LayoutSetBranch> orderByComparator) { 1072 return getPersistence().findAll(start, end, orderByComparator); 1073 } 1074 1075 /** 1076 * Returns an ordered range of all the layout set branchs. 1077 * 1078 * <p> 1079 * 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. 1080 * </p> 1081 * 1082 * @param start the lower bound of the range of layout set branchs 1083 * @param end the upper bound of the range of layout set branchs (not inclusive) 1084 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1085 * @param retrieveFromCache whether to retrieve from the finder cache 1086 * @return the ordered range of layout set branchs 1087 */ 1088 public static List<LayoutSetBranch> findAll(int start, int end, 1089 OrderByComparator<LayoutSetBranch> orderByComparator, 1090 boolean retrieveFromCache) { 1091 return getPersistence() 1092 .findAll(start, end, orderByComparator, retrieveFromCache); 1093 } 1094 1095 /** 1096 * Removes all the layout set branchs from the database. 1097 */ 1098 public static void removeAll() { 1099 getPersistence().removeAll(); 1100 } 1101 1102 /** 1103 * Returns the number of layout set branchs. 1104 * 1105 * @return the number of layout set branchs 1106 */ 1107 public static int countAll() { 1108 return getPersistence().countAll(); 1109 } 1110 1111 public static java.util.Set<java.lang.String> getBadColumnNames() { 1112 return getPersistence().getBadColumnNames(); 1113 } 1114 1115 public static LayoutSetBranchPersistence getPersistence() { 1116 if (_persistence == null) { 1117 _persistence = (LayoutSetBranchPersistence)PortalBeanLocatorUtil.locate(LayoutSetBranchPersistence.class.getName()); 1118 1119 ReferenceRegistry.registerReference(LayoutSetBranchUtil.class, 1120 "_persistence"); 1121 } 1122 1123 return _persistence; 1124 } 1125 1126 private static LayoutSetBranchPersistence _persistence; 1127 }