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.model.LayoutSetBranch; 020 021 /** 022 * The persistence interface for the layout set branch service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.LayoutSetBranchPersistenceImpl 030 * @see LayoutSetBranchUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface LayoutSetBranchPersistence extends BasePersistence<LayoutSetBranch> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link LayoutSetBranchUtil} to access the layout set branch persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the layout set branchs where groupId = ?. 043 * 044 * @param groupId the group ID 045 * @return the matching layout set branchs 046 */ 047 public java.util.List<LayoutSetBranch> findByGroupId(long groupId); 048 049 /** 050 * Returns a range of all the layout set branchs where groupId = ?. 051 * 052 * <p> 053 * 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. 054 * </p> 055 * 056 * @param groupId the group ID 057 * @param start the lower bound of the range of layout set branchs 058 * @param end the upper bound of the range of layout set branchs (not inclusive) 059 * @return the range of matching layout set branchs 060 */ 061 public java.util.List<LayoutSetBranch> findByGroupId(long groupId, 062 int start, int end); 063 064 /** 065 * Returns an ordered range of all the layout set branchs where groupId = ?. 066 * 067 * <p> 068 * 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. 069 * </p> 070 * 071 * @param groupId the group ID 072 * @param start the lower bound of the range of layout set branchs 073 * @param end the upper bound of the range of layout set branchs (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching layout set branchs 076 */ 077 public java.util.List<LayoutSetBranch> findByGroupId(long groupId, 078 int start, int end, 079 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 080 081 /** 082 * Returns an ordered range of all the layout set branchs where groupId = ?. 083 * 084 * <p> 085 * 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. 086 * </p> 087 * 088 * @param groupId the group ID 089 * @param start the lower bound of the range of layout set branchs 090 * @param end the upper bound of the range of layout set branchs (not inclusive) 091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 092 * @param retrieveFromCache whether to retrieve from the finder cache 093 * @return the ordered range of matching layout set branchs 094 */ 095 public java.util.List<LayoutSetBranch> findByGroupId(long groupId, 096 int start, int end, 097 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator, 098 boolean retrieveFromCache); 099 100 /** 101 * Returns the first layout set branch in the ordered set where groupId = ?. 102 * 103 * @param groupId the group ID 104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 105 * @return the first matching layout set branch 106 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 107 */ 108 public LayoutSetBranch findByGroupId_First(long groupId, 109 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 110 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 111 112 /** 113 * Returns the first layout set branch in the ordered set where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 117 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 118 */ 119 public LayoutSetBranch fetchByGroupId_First(long groupId, 120 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 121 122 /** 123 * Returns the last layout set branch in the ordered set where groupId = ?. 124 * 125 * @param groupId the group ID 126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 127 * @return the last matching layout set branch 128 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 129 */ 130 public LayoutSetBranch findByGroupId_Last(long groupId, 131 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 132 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 133 134 /** 135 * Returns the last layout set branch in the ordered set where groupId = ?. 136 * 137 * @param groupId the group ID 138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 139 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 140 */ 141 public LayoutSetBranch fetchByGroupId_Last(long groupId, 142 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 143 144 /** 145 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ?. 146 * 147 * @param layoutSetBranchId the primary key of the current layout set branch 148 * @param groupId the group ID 149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 150 * @return the previous, current, and next layout set branch 151 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 152 */ 153 public LayoutSetBranch[] findByGroupId_PrevAndNext(long layoutSetBranchId, 154 long groupId, 155 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 156 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 157 158 /** 159 * Returns all the layout set branchs that the user has permission to view where groupId = ?. 160 * 161 * @param groupId the group ID 162 * @return the matching layout set branchs that the user has permission to view 163 */ 164 public java.util.List<LayoutSetBranch> filterFindByGroupId(long groupId); 165 166 /** 167 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ?. 168 * 169 * <p> 170 * 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. 171 * </p> 172 * 173 * @param groupId the group ID 174 * @param start the lower bound of the range of layout set branchs 175 * @param end the upper bound of the range of layout set branchs (not inclusive) 176 * @return the range of matching layout set branchs that the user has permission to view 177 */ 178 public java.util.List<LayoutSetBranch> filterFindByGroupId(long groupId, 179 int start, int end); 180 181 /** 182 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ?. 183 * 184 * <p> 185 * 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. 186 * </p> 187 * 188 * @param groupId the group ID 189 * @param start the lower bound of the range of layout set branchs 190 * @param end the upper bound of the range of layout set branchs (not inclusive) 191 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 192 * @return the ordered range of matching layout set branchs that the user has permission to view 193 */ 194 public java.util.List<LayoutSetBranch> filterFindByGroupId(long groupId, 195 int start, int end, 196 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 197 198 /** 199 * 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 = ?. 200 * 201 * @param layoutSetBranchId the primary key of the current layout set branch 202 * @param groupId the group ID 203 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 204 * @return the previous, current, and next layout set branch 205 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 206 */ 207 public LayoutSetBranch[] filterFindByGroupId_PrevAndNext( 208 long layoutSetBranchId, long groupId, 209 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 210 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 211 212 /** 213 * Removes all the layout set branchs where groupId = ? from the database. 214 * 215 * @param groupId the group ID 216 */ 217 public void removeByGroupId(long groupId); 218 219 /** 220 * Returns the number of layout set branchs where groupId = ?. 221 * 222 * @param groupId the group ID 223 * @return the number of matching layout set branchs 224 */ 225 public int countByGroupId(long groupId); 226 227 /** 228 * Returns the number of layout set branchs that the user has permission to view where groupId = ?. 229 * 230 * @param groupId the group ID 231 * @return the number of matching layout set branchs that the user has permission to view 232 */ 233 public int filterCountByGroupId(long groupId); 234 235 /** 236 * Returns all the layout set branchs where groupId = ? and privateLayout = ?. 237 * 238 * @param groupId the group ID 239 * @param privateLayout the private layout 240 * @return the matching layout set branchs 241 */ 242 public java.util.List<LayoutSetBranch> findByG_P(long groupId, 243 boolean privateLayout); 244 245 /** 246 * Returns a range of all the layout set branchs where groupId = ? and privateLayout = ?. 247 * 248 * <p> 249 * 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. 250 * </p> 251 * 252 * @param groupId the group ID 253 * @param privateLayout the private layout 254 * @param start the lower bound of the range of layout set branchs 255 * @param end the upper bound of the range of layout set branchs (not inclusive) 256 * @return the range of matching layout set branchs 257 */ 258 public java.util.List<LayoutSetBranch> findByG_P(long groupId, 259 boolean privateLayout, int start, int end); 260 261 /** 262 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ?. 263 * 264 * <p> 265 * 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. 266 * </p> 267 * 268 * @param groupId the group ID 269 * @param privateLayout the private layout 270 * @param start the lower bound of the range of layout set branchs 271 * @param end the upper bound of the range of layout set branchs (not inclusive) 272 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 273 * @return the ordered range of matching layout set branchs 274 */ 275 public java.util.List<LayoutSetBranch> findByG_P(long groupId, 276 boolean privateLayout, int start, int end, 277 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 278 279 /** 280 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ?. 281 * 282 * <p> 283 * 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. 284 * </p> 285 * 286 * @param groupId the group ID 287 * @param privateLayout the private layout 288 * @param start the lower bound of the range of layout set branchs 289 * @param end the upper bound of the range of layout set branchs (not inclusive) 290 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 291 * @param retrieveFromCache whether to retrieve from the finder cache 292 * @return the ordered range of matching layout set branchs 293 */ 294 public java.util.List<LayoutSetBranch> findByG_P(long groupId, 295 boolean privateLayout, int start, int end, 296 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator, 297 boolean retrieveFromCache); 298 299 /** 300 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ?. 301 * 302 * @param groupId the group ID 303 * @param privateLayout the private layout 304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 305 * @return the first matching layout set branch 306 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 307 */ 308 public LayoutSetBranch findByG_P_First(long groupId, boolean privateLayout, 309 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 310 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 311 312 /** 313 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ?. 314 * 315 * @param groupId the group ID 316 * @param privateLayout the private layout 317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 318 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 319 */ 320 public LayoutSetBranch fetchByG_P_First(long groupId, 321 boolean privateLayout, 322 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 323 324 /** 325 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ?. 326 * 327 * @param groupId the group ID 328 * @param privateLayout the private layout 329 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 330 * @return the last matching layout set branch 331 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 332 */ 333 public LayoutSetBranch findByG_P_Last(long groupId, boolean privateLayout, 334 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 335 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 336 337 /** 338 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ?. 339 * 340 * @param groupId the group ID 341 * @param privateLayout the private layout 342 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 343 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 344 */ 345 public LayoutSetBranch fetchByG_P_Last(long groupId, boolean privateLayout, 346 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 347 348 /** 349 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ? and privateLayout = ?. 350 * 351 * @param layoutSetBranchId the primary key of the current layout set branch 352 * @param groupId the group ID 353 * @param privateLayout the private layout 354 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 355 * @return the previous, current, and next layout set branch 356 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 357 */ 358 public LayoutSetBranch[] findByG_P_PrevAndNext(long layoutSetBranchId, 359 long groupId, boolean privateLayout, 360 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 361 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 362 363 /** 364 * Returns all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 365 * 366 * @param groupId the group ID 367 * @param privateLayout the private layout 368 * @return the matching layout set branchs that the user has permission to view 369 */ 370 public java.util.List<LayoutSetBranch> filterFindByG_P(long groupId, 371 boolean privateLayout); 372 373 /** 374 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 375 * 376 * <p> 377 * 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. 378 * </p> 379 * 380 * @param groupId the group ID 381 * @param privateLayout the private layout 382 * @param start the lower bound of the range of layout set branchs 383 * @param end the upper bound of the range of layout set branchs (not inclusive) 384 * @return the range of matching layout set branchs that the user has permission to view 385 */ 386 public java.util.List<LayoutSetBranch> filterFindByG_P(long groupId, 387 boolean privateLayout, int start, int end); 388 389 /** 390 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ? and privateLayout = ?. 391 * 392 * <p> 393 * 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. 394 * </p> 395 * 396 * @param groupId the group ID 397 * @param privateLayout the private layout 398 * @param start the lower bound of the range of layout set branchs 399 * @param end the upper bound of the range of layout set branchs (not inclusive) 400 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 401 * @return the ordered range of matching layout set branchs that the user has permission to view 402 */ 403 public java.util.List<LayoutSetBranch> filterFindByG_P(long groupId, 404 boolean privateLayout, int start, int end, 405 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 406 407 /** 408 * 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 = ?. 409 * 410 * @param layoutSetBranchId the primary key of the current layout set branch 411 * @param groupId the group ID 412 * @param privateLayout the private layout 413 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 414 * @return the previous, current, and next layout set branch 415 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 416 */ 417 public LayoutSetBranch[] filterFindByG_P_PrevAndNext( 418 long layoutSetBranchId, long groupId, boolean privateLayout, 419 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 420 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 421 422 /** 423 * Removes all the layout set branchs where groupId = ? and privateLayout = ? from the database. 424 * 425 * @param groupId the group ID 426 * @param privateLayout the private layout 427 */ 428 public void removeByG_P(long groupId, boolean privateLayout); 429 430 /** 431 * Returns the number of layout set branchs where groupId = ? and privateLayout = ?. 432 * 433 * @param groupId the group ID 434 * @param privateLayout the private layout 435 * @return the number of matching layout set branchs 436 */ 437 public int countByG_P(long groupId, boolean privateLayout); 438 439 /** 440 * Returns the number of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ?. 441 * 442 * @param groupId the group ID 443 * @param privateLayout the private layout 444 * @return the number of matching layout set branchs that the user has permission to view 445 */ 446 public int filterCountByG_P(long groupId, boolean privateLayout); 447 448 /** 449 * Returns the layout set branch where groupId = ? and privateLayout = ? and name = ? or throws a {@link NoSuchLayoutSetBranchException} if it could not be found. 450 * 451 * @param groupId the group ID 452 * @param privateLayout the private layout 453 * @param name the name 454 * @return the matching layout set branch 455 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 456 */ 457 public LayoutSetBranch findByG_P_N(long groupId, boolean privateLayout, 458 java.lang.String name) 459 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 460 461 /** 462 * 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. 463 * 464 * @param groupId the group ID 465 * @param privateLayout the private layout 466 * @param name the name 467 * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 468 */ 469 public LayoutSetBranch fetchByG_P_N(long groupId, boolean privateLayout, 470 java.lang.String name); 471 472 /** 473 * 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. 474 * 475 * @param groupId the group ID 476 * @param privateLayout the private layout 477 * @param name the name 478 * @param retrieveFromCache whether to retrieve from the finder cache 479 * @return the matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 480 */ 481 public LayoutSetBranch fetchByG_P_N(long groupId, boolean privateLayout, 482 java.lang.String name, boolean retrieveFromCache); 483 484 /** 485 * Removes the layout set branch where groupId = ? and privateLayout = ? and name = ? from the database. 486 * 487 * @param groupId the group ID 488 * @param privateLayout the private layout 489 * @param name the name 490 * @return the layout set branch that was removed 491 */ 492 public LayoutSetBranch removeByG_P_N(long groupId, boolean privateLayout, 493 java.lang.String name) 494 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 495 496 /** 497 * Returns the number of layout set branchs where groupId = ? and privateLayout = ? and name = ?. 498 * 499 * @param groupId the group ID 500 * @param privateLayout the private layout 501 * @param name the name 502 * @return the number of matching layout set branchs 503 */ 504 public int countByG_P_N(long groupId, boolean privateLayout, 505 java.lang.String name); 506 507 /** 508 * Returns all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 509 * 510 * @param groupId the group ID 511 * @param privateLayout the private layout 512 * @param master the master 513 * @return the matching layout set branchs 514 */ 515 public java.util.List<LayoutSetBranch> findByG_P_M(long groupId, 516 boolean privateLayout, boolean master); 517 518 /** 519 * Returns a range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 520 * 521 * <p> 522 * 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. 523 * </p> 524 * 525 * @param groupId the group ID 526 * @param privateLayout the private layout 527 * @param master the master 528 * @param start the lower bound of the range of layout set branchs 529 * @param end the upper bound of the range of layout set branchs (not inclusive) 530 * @return the range of matching layout set branchs 531 */ 532 public java.util.List<LayoutSetBranch> findByG_P_M(long groupId, 533 boolean privateLayout, boolean master, int start, int end); 534 535 /** 536 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 537 * 538 * <p> 539 * 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. 540 * </p> 541 * 542 * @param groupId the group ID 543 * @param privateLayout the private layout 544 * @param master the master 545 * @param start the lower bound of the range of layout set branchs 546 * @param end the upper bound of the range of layout set branchs (not inclusive) 547 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 548 * @return the ordered range of matching layout set branchs 549 */ 550 public java.util.List<LayoutSetBranch> findByG_P_M(long groupId, 551 boolean privateLayout, boolean master, int start, int end, 552 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 553 554 /** 555 * Returns an ordered range of all the layout set branchs where groupId = ? and privateLayout = ? and master = ?. 556 * 557 * <p> 558 * 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. 559 * </p> 560 * 561 * @param groupId the group ID 562 * @param privateLayout the private layout 563 * @param master the master 564 * @param start the lower bound of the range of layout set branchs 565 * @param end the upper bound of the range of layout set branchs (not inclusive) 566 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 567 * @param retrieveFromCache whether to retrieve from the finder cache 568 * @return the ordered range of matching layout set branchs 569 */ 570 public java.util.List<LayoutSetBranch> findByG_P_M(long groupId, 571 boolean privateLayout, boolean master, int start, int end, 572 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator, 573 boolean retrieveFromCache); 574 575 /** 576 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 577 * 578 * @param groupId the group ID 579 * @param privateLayout the private layout 580 * @param master the master 581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 582 * @return the first matching layout set branch 583 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 584 */ 585 public LayoutSetBranch findByG_P_M_First(long groupId, 586 boolean privateLayout, boolean master, 587 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 588 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 589 590 /** 591 * Returns the first layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 592 * 593 * @param groupId the group ID 594 * @param privateLayout the private layout 595 * @param master the master 596 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 597 * @return the first matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 598 */ 599 public LayoutSetBranch fetchByG_P_M_First(long groupId, 600 boolean privateLayout, boolean master, 601 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 602 603 /** 604 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 605 * 606 * @param groupId the group ID 607 * @param privateLayout the private layout 608 * @param master the master 609 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 610 * @return the last matching layout set branch 611 * @throws NoSuchLayoutSetBranchException if a matching layout set branch could not be found 612 */ 613 public LayoutSetBranch findByG_P_M_Last(long groupId, 614 boolean privateLayout, boolean master, 615 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 616 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 617 618 /** 619 * Returns the last layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 620 * 621 * @param groupId the group ID 622 * @param privateLayout the private layout 623 * @param master the master 624 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 625 * @return the last matching layout set branch, or <code>null</code> if a matching layout set branch could not be found 626 */ 627 public LayoutSetBranch fetchByG_P_M_Last(long groupId, 628 boolean privateLayout, boolean master, 629 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 630 631 /** 632 * Returns the layout set branchs before and after the current layout set branch in the ordered set where groupId = ? and privateLayout = ? and master = ?. 633 * 634 * @param layoutSetBranchId the primary key of the current layout set branch 635 * @param groupId the group ID 636 * @param privateLayout the private layout 637 * @param master the master 638 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 639 * @return the previous, current, and next layout set branch 640 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 641 */ 642 public LayoutSetBranch[] findByG_P_M_PrevAndNext(long layoutSetBranchId, 643 long groupId, boolean privateLayout, boolean master, 644 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 645 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 646 647 /** 648 * Returns all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 649 * 650 * @param groupId the group ID 651 * @param privateLayout the private layout 652 * @param master the master 653 * @return the matching layout set branchs that the user has permission to view 654 */ 655 public java.util.List<LayoutSetBranch> filterFindByG_P_M(long groupId, 656 boolean privateLayout, boolean master); 657 658 /** 659 * Returns a range of all the layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 660 * 661 * <p> 662 * 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. 663 * </p> 664 * 665 * @param groupId the group ID 666 * @param privateLayout the private layout 667 * @param master the master 668 * @param start the lower bound of the range of layout set branchs 669 * @param end the upper bound of the range of layout set branchs (not inclusive) 670 * @return the range of matching layout set branchs that the user has permission to view 671 */ 672 public java.util.List<LayoutSetBranch> filterFindByG_P_M(long groupId, 673 boolean privateLayout, boolean master, int start, int end); 674 675 /** 676 * Returns an ordered range of all the layout set branchs that the user has permissions to view where groupId = ? and privateLayout = ? and master = ?. 677 * 678 * <p> 679 * 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. 680 * </p> 681 * 682 * @param groupId the group ID 683 * @param privateLayout the private layout 684 * @param master the master 685 * @param start the lower bound of the range of layout set branchs 686 * @param end the upper bound of the range of layout set branchs (not inclusive) 687 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 688 * @return the ordered range of matching layout set branchs that the user has permission to view 689 */ 690 public java.util.List<LayoutSetBranch> filterFindByG_P_M(long groupId, 691 boolean privateLayout, boolean master, int start, int end, 692 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 693 694 /** 695 * 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 = ?. 696 * 697 * @param layoutSetBranchId the primary key of the current layout set branch 698 * @param groupId the group ID 699 * @param privateLayout the private layout 700 * @param master the master 701 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 702 * @return the previous, current, and next layout set branch 703 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 704 */ 705 public LayoutSetBranch[] filterFindByG_P_M_PrevAndNext( 706 long layoutSetBranchId, long groupId, boolean privateLayout, 707 boolean master, 708 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator) 709 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 710 711 /** 712 * Removes all the layout set branchs where groupId = ? and privateLayout = ? and master = ? from the database. 713 * 714 * @param groupId the group ID 715 * @param privateLayout the private layout 716 * @param master the master 717 */ 718 public void removeByG_P_M(long groupId, boolean privateLayout, 719 boolean master); 720 721 /** 722 * Returns the number of layout set branchs 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 * @return the number of matching layout set branchs 728 */ 729 public int countByG_P_M(long groupId, boolean privateLayout, boolean master); 730 731 /** 732 * Returns the number of layout set branchs that the user has permission to view where groupId = ? and privateLayout = ? and master = ?. 733 * 734 * @param groupId the group ID 735 * @param privateLayout the private layout 736 * @param master the master 737 * @return the number of matching layout set branchs that the user has permission to view 738 */ 739 public int filterCountByG_P_M(long groupId, boolean privateLayout, 740 boolean master); 741 742 /** 743 * Caches the layout set branch in the entity cache if it is enabled. 744 * 745 * @param layoutSetBranch the layout set branch 746 */ 747 public void cacheResult(LayoutSetBranch layoutSetBranch); 748 749 /** 750 * Caches the layout set branchs in the entity cache if it is enabled. 751 * 752 * @param layoutSetBranchs the layout set branchs 753 */ 754 public void cacheResult(java.util.List<LayoutSetBranch> layoutSetBranchs); 755 756 /** 757 * Creates a new layout set branch with the primary key. Does not add the layout set branch to the database. 758 * 759 * @param layoutSetBranchId the primary key for the new layout set branch 760 * @return the new layout set branch 761 */ 762 public LayoutSetBranch create(long layoutSetBranchId); 763 764 /** 765 * Removes the layout set branch with the primary key from the database. Also notifies the appropriate model listeners. 766 * 767 * @param layoutSetBranchId the primary key of the layout set branch 768 * @return the layout set branch that was removed 769 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 770 */ 771 public LayoutSetBranch remove(long layoutSetBranchId) 772 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 773 774 public LayoutSetBranch updateImpl(LayoutSetBranch layoutSetBranch); 775 776 /** 777 * Returns the layout set branch with the primary key or throws a {@link NoSuchLayoutSetBranchException} if it could not be found. 778 * 779 * @param layoutSetBranchId the primary key of the layout set branch 780 * @return the layout set branch 781 * @throws NoSuchLayoutSetBranchException if a layout set branch with the primary key could not be found 782 */ 783 public LayoutSetBranch findByPrimaryKey(long layoutSetBranchId) 784 throws com.liferay.portal.exception.NoSuchLayoutSetBranchException; 785 786 /** 787 * Returns the layout set branch with the primary key or returns <code>null</code> if it could not be found. 788 * 789 * @param layoutSetBranchId the primary key of the layout set branch 790 * @return the layout set branch, or <code>null</code> if a layout set branch with the primary key could not be found 791 */ 792 public LayoutSetBranch fetchByPrimaryKey(long layoutSetBranchId); 793 794 @Override 795 public java.util.Map<java.io.Serializable, LayoutSetBranch> fetchByPrimaryKeys( 796 java.util.Set<java.io.Serializable> primaryKeys); 797 798 /** 799 * Returns all the layout set branchs. 800 * 801 * @return the layout set branchs 802 */ 803 public java.util.List<LayoutSetBranch> findAll(); 804 805 /** 806 * Returns a range of all the layout set branchs. 807 * 808 * <p> 809 * 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. 810 * </p> 811 * 812 * @param start the lower bound of the range of layout set branchs 813 * @param end the upper bound of the range of layout set branchs (not inclusive) 814 * @return the range of layout set branchs 815 */ 816 public java.util.List<LayoutSetBranch> findAll(int start, int end); 817 818 /** 819 * Returns an ordered range of all the layout set branchs. 820 * 821 * <p> 822 * 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. 823 * </p> 824 * 825 * @param start the lower bound of the range of layout set branchs 826 * @param end the upper bound of the range of layout set branchs (not inclusive) 827 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 828 * @return the ordered range of layout set branchs 829 */ 830 public java.util.List<LayoutSetBranch> findAll(int start, int end, 831 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator); 832 833 /** 834 * Returns an ordered range of all the layout set branchs. 835 * 836 * <p> 837 * 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. 838 * </p> 839 * 840 * @param start the lower bound of the range of layout set branchs 841 * @param end the upper bound of the range of layout set branchs (not inclusive) 842 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 843 * @param retrieveFromCache whether to retrieve from the finder cache 844 * @return the ordered range of layout set branchs 845 */ 846 public java.util.List<LayoutSetBranch> findAll(int start, int end, 847 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetBranch> orderByComparator, 848 boolean retrieveFromCache); 849 850 /** 851 * Removes all the layout set branchs from the database. 852 */ 853 public void removeAll(); 854 855 /** 856 * Returns the number of layout set branchs. 857 * 858 * @return the number of layout set branchs 859 */ 860 public int countAll(); 861 862 @Override 863 public java.util.Set<java.lang.String> getBadColumnNames(); 864 }