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.LayoutSetPrototype; 020 021 /** 022 * The persistence interface for the layout set prototype 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.LayoutSetPrototypePersistenceImpl 030 * @see LayoutSetPrototypeUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface LayoutSetPrototypePersistence extends BasePersistence<LayoutSetPrototype> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link LayoutSetPrototypeUtil} to access the layout set prototype persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the layout set prototypes where uuid = ?. 043 * 044 * @param uuid the uuid 045 * @return the matching layout set prototypes 046 */ 047 public java.util.List<LayoutSetPrototype> findByUuid(java.lang.String uuid); 048 049 /** 050 * Returns a range of all the layout set prototypes where uuid = ?. 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 LayoutSetPrototypeModelImpl}. 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 uuid the uuid 057 * @param start the lower bound of the range of layout set prototypes 058 * @param end the upper bound of the range of layout set prototypes (not inclusive) 059 * @return the range of matching layout set prototypes 060 */ 061 public java.util.List<LayoutSetPrototype> findByUuid( 062 java.lang.String uuid, int start, int end); 063 064 /** 065 * Returns an ordered range of all the layout set prototypes where uuid = ?. 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 LayoutSetPrototypeModelImpl}. 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 uuid the uuid 072 * @param start the lower bound of the range of layout set prototypes 073 * @param end the upper bound of the range of layout set prototypes (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 prototypes 076 */ 077 public java.util.List<LayoutSetPrototype> findByUuid( 078 java.lang.String uuid, int start, int end, 079 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 080 081 /** 082 * Returns an ordered range of all the layout set prototypes where uuid = ?. 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 LayoutSetPrototypeModelImpl}. 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 uuid the uuid 089 * @param start the lower bound of the range of layout set prototypes 090 * @param end the upper bound of the range of layout set prototypes (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 prototypes 094 */ 095 public java.util.List<LayoutSetPrototype> findByUuid( 096 java.lang.String uuid, int start, int end, 097 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator, 098 boolean retrieveFromCache); 099 100 /** 101 * Returns the first layout set prototype in the ordered set where uuid = ?. 102 * 103 * @param uuid the uuid 104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 105 * @return the first matching layout set prototype 106 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 107 */ 108 public LayoutSetPrototype findByUuid_First(java.lang.String uuid, 109 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 110 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 111 112 /** 113 * Returns the first layout set prototype in the ordered set where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 117 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 118 */ 119 public LayoutSetPrototype fetchByUuid_First(java.lang.String uuid, 120 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 121 122 /** 123 * Returns the last layout set prototype in the ordered set where uuid = ?. 124 * 125 * @param uuid the uuid 126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 127 * @return the last matching layout set prototype 128 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 129 */ 130 public LayoutSetPrototype findByUuid_Last(java.lang.String uuid, 131 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 132 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 133 134 /** 135 * Returns the last layout set prototype in the ordered set where uuid = ?. 136 * 137 * @param uuid the uuid 138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 139 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 140 */ 141 public LayoutSetPrototype fetchByUuid_Last(java.lang.String uuid, 142 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 143 144 /** 145 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = ?. 146 * 147 * @param layoutSetPrototypeId the primary key of the current layout set prototype 148 * @param uuid the uuid 149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 150 * @return the previous, current, and next layout set prototype 151 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 152 */ 153 public LayoutSetPrototype[] findByUuid_PrevAndNext( 154 long layoutSetPrototypeId, java.lang.String uuid, 155 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 156 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 157 158 /** 159 * Returns all the layout set prototypes that the user has permission to view where uuid = ?. 160 * 161 * @param uuid the uuid 162 * @return the matching layout set prototypes that the user has permission to view 163 */ 164 public java.util.List<LayoutSetPrototype> filterFindByUuid( 165 java.lang.String uuid); 166 167 /** 168 * Returns a range of all the layout set prototypes that the user has permission to view where uuid = ?. 169 * 170 * <p> 171 * 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 LayoutSetPrototypeModelImpl}. 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. 172 * </p> 173 * 174 * @param uuid the uuid 175 * @param start the lower bound of the range of layout set prototypes 176 * @param end the upper bound of the range of layout set prototypes (not inclusive) 177 * @return the range of matching layout set prototypes that the user has permission to view 178 */ 179 public java.util.List<LayoutSetPrototype> filterFindByUuid( 180 java.lang.String uuid, int start, int end); 181 182 /** 183 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = ?. 184 * 185 * <p> 186 * 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 LayoutSetPrototypeModelImpl}. 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. 187 * </p> 188 * 189 * @param uuid the uuid 190 * @param start the lower bound of the range of layout set prototypes 191 * @param end the upper bound of the range of layout set prototypes (not inclusive) 192 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 193 * @return the ordered range of matching layout set prototypes that the user has permission to view 194 */ 195 public java.util.List<LayoutSetPrototype> filterFindByUuid( 196 java.lang.String uuid, int start, int end, 197 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 198 199 /** 200 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = ?. 201 * 202 * @param layoutSetPrototypeId the primary key of the current layout set prototype 203 * @param uuid the uuid 204 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 205 * @return the previous, current, and next layout set prototype 206 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 207 */ 208 public LayoutSetPrototype[] filterFindByUuid_PrevAndNext( 209 long layoutSetPrototypeId, java.lang.String uuid, 210 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 211 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 212 213 /** 214 * Removes all the layout set prototypes where uuid = ? from the database. 215 * 216 * @param uuid the uuid 217 */ 218 public void removeByUuid(java.lang.String uuid); 219 220 /** 221 * Returns the number of layout set prototypes where uuid = ?. 222 * 223 * @param uuid the uuid 224 * @return the number of matching layout set prototypes 225 */ 226 public int countByUuid(java.lang.String uuid); 227 228 /** 229 * Returns the number of layout set prototypes that the user has permission to view where uuid = ?. 230 * 231 * @param uuid the uuid 232 * @return the number of matching layout set prototypes that the user has permission to view 233 */ 234 public int filterCountByUuid(java.lang.String uuid); 235 236 /** 237 * Returns all the layout set prototypes where uuid = ? and companyId = ?. 238 * 239 * @param uuid the uuid 240 * @param companyId the company ID 241 * @return the matching layout set prototypes 242 */ 243 public java.util.List<LayoutSetPrototype> findByUuid_C( 244 java.lang.String uuid, long companyId); 245 246 /** 247 * Returns a range of all the layout set prototypes where uuid = ? and companyId = ?. 248 * 249 * <p> 250 * 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 LayoutSetPrototypeModelImpl}. 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. 251 * </p> 252 * 253 * @param uuid the uuid 254 * @param companyId the company ID 255 * @param start the lower bound of the range of layout set prototypes 256 * @param end the upper bound of the range of layout set prototypes (not inclusive) 257 * @return the range of matching layout set prototypes 258 */ 259 public java.util.List<LayoutSetPrototype> findByUuid_C( 260 java.lang.String uuid, long companyId, int start, int end); 261 262 /** 263 * Returns an ordered range of all the layout set prototypes where uuid = ? and companyId = ?. 264 * 265 * <p> 266 * 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 LayoutSetPrototypeModelImpl}. 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. 267 * </p> 268 * 269 * @param uuid the uuid 270 * @param companyId the company ID 271 * @param start the lower bound of the range of layout set prototypes 272 * @param end the upper bound of the range of layout set prototypes (not inclusive) 273 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 274 * @return the ordered range of matching layout set prototypes 275 */ 276 public java.util.List<LayoutSetPrototype> findByUuid_C( 277 java.lang.String uuid, long companyId, int start, int end, 278 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 279 280 /** 281 * Returns an ordered range of all the layout set prototypes where uuid = ? and companyId = ?. 282 * 283 * <p> 284 * 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 LayoutSetPrototypeModelImpl}. 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. 285 * </p> 286 * 287 * @param uuid the uuid 288 * @param companyId the company ID 289 * @param start the lower bound of the range of layout set prototypes 290 * @param end the upper bound of the range of layout set prototypes (not inclusive) 291 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 292 * @param retrieveFromCache whether to retrieve from the finder cache 293 * @return the ordered range of matching layout set prototypes 294 */ 295 public java.util.List<LayoutSetPrototype> findByUuid_C( 296 java.lang.String uuid, long companyId, int start, int end, 297 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator, 298 boolean retrieveFromCache); 299 300 /** 301 * Returns the first layout set prototype in the ordered set where uuid = ? and companyId = ?. 302 * 303 * @param uuid the uuid 304 * @param companyId the company ID 305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 306 * @return the first matching layout set prototype 307 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 308 */ 309 public LayoutSetPrototype findByUuid_C_First(java.lang.String uuid, 310 long companyId, 311 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 312 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 313 314 /** 315 * Returns the first layout set prototype in the ordered set where uuid = ? and companyId = ?. 316 * 317 * @param uuid the uuid 318 * @param companyId the company ID 319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 320 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 321 */ 322 public LayoutSetPrototype fetchByUuid_C_First(java.lang.String uuid, 323 long companyId, 324 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 325 326 /** 327 * Returns the last layout set prototype in the ordered set where uuid = ? and companyId = ?. 328 * 329 * @param uuid the uuid 330 * @param companyId the company ID 331 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 332 * @return the last matching layout set prototype 333 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 334 */ 335 public LayoutSetPrototype findByUuid_C_Last(java.lang.String uuid, 336 long companyId, 337 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 338 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 339 340 /** 341 * Returns the last layout set prototype in the ordered set where uuid = ? and companyId = ?. 342 * 343 * @param uuid the uuid 344 * @param companyId the company ID 345 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 346 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 347 */ 348 public LayoutSetPrototype fetchByUuid_C_Last(java.lang.String uuid, 349 long companyId, 350 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 351 352 /** 353 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = ? and companyId = ?. 354 * 355 * @param layoutSetPrototypeId the primary key of the current layout set prototype 356 * @param uuid the uuid 357 * @param companyId the company ID 358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 359 * @return the previous, current, and next layout set prototype 360 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 361 */ 362 public LayoutSetPrototype[] findByUuid_C_PrevAndNext( 363 long layoutSetPrototypeId, java.lang.String uuid, long companyId, 364 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 365 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 366 367 /** 368 * Returns all the layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 369 * 370 * @param uuid the uuid 371 * @param companyId the company ID 372 * @return the matching layout set prototypes that the user has permission to view 373 */ 374 public java.util.List<LayoutSetPrototype> filterFindByUuid_C( 375 java.lang.String uuid, long companyId); 376 377 /** 378 * Returns a range of all the layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 379 * 380 * <p> 381 * 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 LayoutSetPrototypeModelImpl}. 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. 382 * </p> 383 * 384 * @param uuid the uuid 385 * @param companyId the company ID 386 * @param start the lower bound of the range of layout set prototypes 387 * @param end the upper bound of the range of layout set prototypes (not inclusive) 388 * @return the range of matching layout set prototypes that the user has permission to view 389 */ 390 public java.util.List<LayoutSetPrototype> filterFindByUuid_C( 391 java.lang.String uuid, long companyId, int start, int end); 392 393 /** 394 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = ? and companyId = ?. 395 * 396 * <p> 397 * 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 LayoutSetPrototypeModelImpl}. 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. 398 * </p> 399 * 400 * @param uuid the uuid 401 * @param companyId the company ID 402 * @param start the lower bound of the range of layout set prototypes 403 * @param end the upper bound of the range of layout set prototypes (not inclusive) 404 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 405 * @return the ordered range of matching layout set prototypes that the user has permission to view 406 */ 407 public java.util.List<LayoutSetPrototype> filterFindByUuid_C( 408 java.lang.String uuid, long companyId, int start, int end, 409 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 410 411 /** 412 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 413 * 414 * @param layoutSetPrototypeId the primary key of the current layout set prototype 415 * @param uuid the uuid 416 * @param companyId the company ID 417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 418 * @return the previous, current, and next layout set prototype 419 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 420 */ 421 public LayoutSetPrototype[] filterFindByUuid_C_PrevAndNext( 422 long layoutSetPrototypeId, java.lang.String uuid, long companyId, 423 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 424 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 425 426 /** 427 * Removes all the layout set prototypes where uuid = ? and companyId = ? from the database. 428 * 429 * @param uuid the uuid 430 * @param companyId the company ID 431 */ 432 public void removeByUuid_C(java.lang.String uuid, long companyId); 433 434 /** 435 * Returns the number of layout set prototypes where uuid = ? and companyId = ?. 436 * 437 * @param uuid the uuid 438 * @param companyId the company ID 439 * @return the number of matching layout set prototypes 440 */ 441 public int countByUuid_C(java.lang.String uuid, long companyId); 442 443 /** 444 * Returns the number of layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 445 * 446 * @param uuid the uuid 447 * @param companyId the company ID 448 * @return the number of matching layout set prototypes that the user has permission to view 449 */ 450 public int filterCountByUuid_C(java.lang.String uuid, long companyId); 451 452 /** 453 * Returns all the layout set prototypes where companyId = ?. 454 * 455 * @param companyId the company ID 456 * @return the matching layout set prototypes 457 */ 458 public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId); 459 460 /** 461 * Returns a range of all the layout set prototypes where companyId = ?. 462 * 463 * <p> 464 * 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 LayoutSetPrototypeModelImpl}. 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. 465 * </p> 466 * 467 * @param companyId the company ID 468 * @param start the lower bound of the range of layout set prototypes 469 * @param end the upper bound of the range of layout set prototypes (not inclusive) 470 * @return the range of matching layout set prototypes 471 */ 472 public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId, 473 int start, int end); 474 475 /** 476 * Returns an ordered range of all the layout set prototypes where companyId = ?. 477 * 478 * <p> 479 * 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 LayoutSetPrototypeModelImpl}. 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. 480 * </p> 481 * 482 * @param companyId the company ID 483 * @param start the lower bound of the range of layout set prototypes 484 * @param end the upper bound of the range of layout set prototypes (not inclusive) 485 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 486 * @return the ordered range of matching layout set prototypes 487 */ 488 public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId, 489 int start, int end, 490 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 491 492 /** 493 * Returns an ordered range of all the layout set prototypes where companyId = ?. 494 * 495 * <p> 496 * 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 LayoutSetPrototypeModelImpl}. 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. 497 * </p> 498 * 499 * @param companyId the company ID 500 * @param start the lower bound of the range of layout set prototypes 501 * @param end the upper bound of the range of layout set prototypes (not inclusive) 502 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 503 * @param retrieveFromCache whether to retrieve from the finder cache 504 * @return the ordered range of matching layout set prototypes 505 */ 506 public java.util.List<LayoutSetPrototype> findByCompanyId(long companyId, 507 int start, int end, 508 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator, 509 boolean retrieveFromCache); 510 511 /** 512 * Returns the first layout set prototype in the ordered set where companyId = ?. 513 * 514 * @param companyId the company ID 515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 516 * @return the first matching layout set prototype 517 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 518 */ 519 public LayoutSetPrototype findByCompanyId_First(long companyId, 520 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 521 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 522 523 /** 524 * Returns the first layout set prototype in the ordered set where companyId = ?. 525 * 526 * @param companyId the company ID 527 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 528 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 529 */ 530 public LayoutSetPrototype fetchByCompanyId_First(long companyId, 531 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 532 533 /** 534 * Returns the last layout set prototype in the ordered set where companyId = ?. 535 * 536 * @param companyId the company ID 537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 538 * @return the last matching layout set prototype 539 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 540 */ 541 public LayoutSetPrototype findByCompanyId_Last(long companyId, 542 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 543 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 544 545 /** 546 * Returns the last layout set prototype in the ordered set where companyId = ?. 547 * 548 * @param companyId the company ID 549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 550 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 551 */ 552 public LayoutSetPrototype fetchByCompanyId_Last(long companyId, 553 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 554 555 /** 556 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = ?. 557 * 558 * @param layoutSetPrototypeId the primary key of the current layout set prototype 559 * @param companyId the company ID 560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 561 * @return the previous, current, and next layout set prototype 562 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 563 */ 564 public LayoutSetPrototype[] findByCompanyId_PrevAndNext( 565 long layoutSetPrototypeId, long companyId, 566 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 567 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 568 569 /** 570 * Returns all the layout set prototypes that the user has permission to view where companyId = ?. 571 * 572 * @param companyId the company ID 573 * @return the matching layout set prototypes that the user has permission to view 574 */ 575 public java.util.List<LayoutSetPrototype> filterFindByCompanyId( 576 long companyId); 577 578 /** 579 * Returns a range of all the layout set prototypes that the user has permission to view where companyId = ?. 580 * 581 * <p> 582 * 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 LayoutSetPrototypeModelImpl}. 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. 583 * </p> 584 * 585 * @param companyId the company ID 586 * @param start the lower bound of the range of layout set prototypes 587 * @param end the upper bound of the range of layout set prototypes (not inclusive) 588 * @return the range of matching layout set prototypes that the user has permission to view 589 */ 590 public java.util.List<LayoutSetPrototype> filterFindByCompanyId( 591 long companyId, int start, int end); 592 593 /** 594 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = ?. 595 * 596 * <p> 597 * 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 LayoutSetPrototypeModelImpl}. 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. 598 * </p> 599 * 600 * @param companyId the company ID 601 * @param start the lower bound of the range of layout set prototypes 602 * @param end the upper bound of the range of layout set prototypes (not inclusive) 603 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 604 * @return the ordered range of matching layout set prototypes that the user has permission to view 605 */ 606 public java.util.List<LayoutSetPrototype> filterFindByCompanyId( 607 long companyId, int start, int end, 608 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 609 610 /** 611 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = ?. 612 * 613 * @param layoutSetPrototypeId the primary key of the current layout set prototype 614 * @param companyId the company ID 615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 616 * @return the previous, current, and next layout set prototype 617 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 618 */ 619 public LayoutSetPrototype[] filterFindByCompanyId_PrevAndNext( 620 long layoutSetPrototypeId, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 622 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 623 624 /** 625 * Removes all the layout set prototypes where companyId = ? from the database. 626 * 627 * @param companyId the company ID 628 */ 629 public void removeByCompanyId(long companyId); 630 631 /** 632 * Returns the number of layout set prototypes where companyId = ?. 633 * 634 * @param companyId the company ID 635 * @return the number of matching layout set prototypes 636 */ 637 public int countByCompanyId(long companyId); 638 639 /** 640 * Returns the number of layout set prototypes that the user has permission to view where companyId = ?. 641 * 642 * @param companyId the company ID 643 * @return the number of matching layout set prototypes that the user has permission to view 644 */ 645 public int filterCountByCompanyId(long companyId); 646 647 /** 648 * Returns all the layout set prototypes where companyId = ? and active = ?. 649 * 650 * @param companyId the company ID 651 * @param active the active 652 * @return the matching layout set prototypes 653 */ 654 public java.util.List<LayoutSetPrototype> findByC_A(long companyId, 655 boolean active); 656 657 /** 658 * Returns a range of all the layout set prototypes where companyId = ? and active = ?. 659 * 660 * <p> 661 * 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 LayoutSetPrototypeModelImpl}. 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. 662 * </p> 663 * 664 * @param companyId the company ID 665 * @param active the active 666 * @param start the lower bound of the range of layout set prototypes 667 * @param end the upper bound of the range of layout set prototypes (not inclusive) 668 * @return the range of matching layout set prototypes 669 */ 670 public java.util.List<LayoutSetPrototype> findByC_A(long companyId, 671 boolean active, int start, int end); 672 673 /** 674 * Returns an ordered range of all the layout set prototypes where companyId = ? and active = ?. 675 * 676 * <p> 677 * 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 LayoutSetPrototypeModelImpl}. 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. 678 * </p> 679 * 680 * @param companyId the company ID 681 * @param active the active 682 * @param start the lower bound of the range of layout set prototypes 683 * @param end the upper bound of the range of layout set prototypes (not inclusive) 684 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 685 * @return the ordered range of matching layout set prototypes 686 */ 687 public java.util.List<LayoutSetPrototype> findByC_A(long companyId, 688 boolean active, int start, int end, 689 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 690 691 /** 692 * Returns an ordered range of all the layout set prototypes where companyId = ? and active = ?. 693 * 694 * <p> 695 * 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 LayoutSetPrototypeModelImpl}. 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. 696 * </p> 697 * 698 * @param companyId the company ID 699 * @param active the active 700 * @param start the lower bound of the range of layout set prototypes 701 * @param end the upper bound of the range of layout set prototypes (not inclusive) 702 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 703 * @param retrieveFromCache whether to retrieve from the finder cache 704 * @return the ordered range of matching layout set prototypes 705 */ 706 public java.util.List<LayoutSetPrototype> findByC_A(long companyId, 707 boolean active, int start, int end, 708 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator, 709 boolean retrieveFromCache); 710 711 /** 712 * Returns the first layout set prototype in the ordered set where companyId = ? and active = ?. 713 * 714 * @param companyId the company ID 715 * @param active the active 716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 717 * @return the first matching layout set prototype 718 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 719 */ 720 public LayoutSetPrototype findByC_A_First(long companyId, boolean active, 721 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 722 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 723 724 /** 725 * Returns the first layout set prototype in the ordered set where companyId = ? and active = ?. 726 * 727 * @param companyId the company ID 728 * @param active the active 729 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 730 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 731 */ 732 public LayoutSetPrototype fetchByC_A_First(long companyId, boolean active, 733 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 734 735 /** 736 * Returns the last layout set prototype in the ordered set where companyId = ? and active = ?. 737 * 738 * @param companyId the company ID 739 * @param active the active 740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 741 * @return the last matching layout set prototype 742 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 743 */ 744 public LayoutSetPrototype findByC_A_Last(long companyId, boolean active, 745 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 746 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 747 748 /** 749 * Returns the last layout set prototype in the ordered set where companyId = ? and active = ?. 750 * 751 * @param companyId the company ID 752 * @param active the active 753 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 754 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 755 */ 756 public LayoutSetPrototype fetchByC_A_Last(long companyId, boolean active, 757 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 758 759 /** 760 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = ? and active = ?. 761 * 762 * @param layoutSetPrototypeId the primary key of the current layout set prototype 763 * @param companyId the company ID 764 * @param active the active 765 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 766 * @return the previous, current, and next layout set prototype 767 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 768 */ 769 public LayoutSetPrototype[] findByC_A_PrevAndNext( 770 long layoutSetPrototypeId, long companyId, boolean active, 771 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 772 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 773 774 /** 775 * Returns all the layout set prototypes that the user has permission to view where companyId = ? and active = ?. 776 * 777 * @param companyId the company ID 778 * @param active the active 779 * @return the matching layout set prototypes that the user has permission to view 780 */ 781 public java.util.List<LayoutSetPrototype> filterFindByC_A(long companyId, 782 boolean active); 783 784 /** 785 * Returns a range of all the layout set prototypes that the user has permission to view where companyId = ? and active = ?. 786 * 787 * <p> 788 * 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 LayoutSetPrototypeModelImpl}. 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. 789 * </p> 790 * 791 * @param companyId the company ID 792 * @param active the active 793 * @param start the lower bound of the range of layout set prototypes 794 * @param end the upper bound of the range of layout set prototypes (not inclusive) 795 * @return the range of matching layout set prototypes that the user has permission to view 796 */ 797 public java.util.List<LayoutSetPrototype> filterFindByC_A(long companyId, 798 boolean active, int start, int end); 799 800 /** 801 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = ? and active = ?. 802 * 803 * <p> 804 * 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 LayoutSetPrototypeModelImpl}. 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. 805 * </p> 806 * 807 * @param companyId the company ID 808 * @param active the active 809 * @param start the lower bound of the range of layout set prototypes 810 * @param end the upper bound of the range of layout set prototypes (not inclusive) 811 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 812 * @return the ordered range of matching layout set prototypes that the user has permission to view 813 */ 814 public java.util.List<LayoutSetPrototype> filterFindByC_A(long companyId, 815 boolean active, int start, int end, 816 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 817 818 /** 819 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = ? and active = ?. 820 * 821 * @param layoutSetPrototypeId the primary key of the current layout set prototype 822 * @param companyId the company ID 823 * @param active the active 824 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 825 * @return the previous, current, and next layout set prototype 826 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 827 */ 828 public LayoutSetPrototype[] filterFindByC_A_PrevAndNext( 829 long layoutSetPrototypeId, long companyId, boolean active, 830 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator) 831 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 832 833 /** 834 * Removes all the layout set prototypes where companyId = ? and active = ? from the database. 835 * 836 * @param companyId the company ID 837 * @param active the active 838 */ 839 public void removeByC_A(long companyId, boolean active); 840 841 /** 842 * Returns the number of layout set prototypes where companyId = ? and active = ?. 843 * 844 * @param companyId the company ID 845 * @param active the active 846 * @return the number of matching layout set prototypes 847 */ 848 public int countByC_A(long companyId, boolean active); 849 850 /** 851 * Returns the number of layout set prototypes that the user has permission to view where companyId = ? and active = ?. 852 * 853 * @param companyId the company ID 854 * @param active the active 855 * @return the number of matching layout set prototypes that the user has permission to view 856 */ 857 public int filterCountByC_A(long companyId, boolean active); 858 859 /** 860 * Caches the layout set prototype in the entity cache if it is enabled. 861 * 862 * @param layoutSetPrototype the layout set prototype 863 */ 864 public void cacheResult(LayoutSetPrototype layoutSetPrototype); 865 866 /** 867 * Caches the layout set prototypes in the entity cache if it is enabled. 868 * 869 * @param layoutSetPrototypes the layout set prototypes 870 */ 871 public void cacheResult( 872 java.util.List<LayoutSetPrototype> layoutSetPrototypes); 873 874 /** 875 * Creates a new layout set prototype with the primary key. Does not add the layout set prototype to the database. 876 * 877 * @param layoutSetPrototypeId the primary key for the new layout set prototype 878 * @return the new layout set prototype 879 */ 880 public LayoutSetPrototype create(long layoutSetPrototypeId); 881 882 /** 883 * Removes the layout set prototype with the primary key from the database. Also notifies the appropriate model listeners. 884 * 885 * @param layoutSetPrototypeId the primary key of the layout set prototype 886 * @return the layout set prototype that was removed 887 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 888 */ 889 public LayoutSetPrototype remove(long layoutSetPrototypeId) 890 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 891 892 public LayoutSetPrototype updateImpl(LayoutSetPrototype layoutSetPrototype); 893 894 /** 895 * Returns the layout set prototype with the primary key or throws a {@link NoSuchLayoutSetPrototypeException} if it could not be found. 896 * 897 * @param layoutSetPrototypeId the primary key of the layout set prototype 898 * @return the layout set prototype 899 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 900 */ 901 public LayoutSetPrototype findByPrimaryKey(long layoutSetPrototypeId) 902 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException; 903 904 /** 905 * Returns the layout set prototype with the primary key or returns <code>null</code> if it could not be found. 906 * 907 * @param layoutSetPrototypeId the primary key of the layout set prototype 908 * @return the layout set prototype, or <code>null</code> if a layout set prototype with the primary key could not be found 909 */ 910 public LayoutSetPrototype fetchByPrimaryKey(long layoutSetPrototypeId); 911 912 @Override 913 public java.util.Map<java.io.Serializable, LayoutSetPrototype> fetchByPrimaryKeys( 914 java.util.Set<java.io.Serializable> primaryKeys); 915 916 /** 917 * Returns all the layout set prototypes. 918 * 919 * @return the layout set prototypes 920 */ 921 public java.util.List<LayoutSetPrototype> findAll(); 922 923 /** 924 * Returns a range of all the layout set prototypes. 925 * 926 * <p> 927 * 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 LayoutSetPrototypeModelImpl}. 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. 928 * </p> 929 * 930 * @param start the lower bound of the range of layout set prototypes 931 * @param end the upper bound of the range of layout set prototypes (not inclusive) 932 * @return the range of layout set prototypes 933 */ 934 public java.util.List<LayoutSetPrototype> findAll(int start, int end); 935 936 /** 937 * Returns an ordered range of all the layout set prototypes. 938 * 939 * <p> 940 * 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 LayoutSetPrototypeModelImpl}. 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. 941 * </p> 942 * 943 * @param start the lower bound of the range of layout set prototypes 944 * @param end the upper bound of the range of layout set prototypes (not inclusive) 945 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 946 * @return the ordered range of layout set prototypes 947 */ 948 public java.util.List<LayoutSetPrototype> findAll(int start, int end, 949 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator); 950 951 /** 952 * Returns an ordered range of all the layout set prototypes. 953 * 954 * <p> 955 * 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 LayoutSetPrototypeModelImpl}. 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. 956 * </p> 957 * 958 * @param start the lower bound of the range of layout set prototypes 959 * @param end the upper bound of the range of layout set prototypes (not inclusive) 960 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 961 * @param retrieveFromCache whether to retrieve from the finder cache 962 * @return the ordered range of layout set prototypes 963 */ 964 public java.util.List<LayoutSetPrototype> findAll(int start, int end, 965 com.liferay.portal.kernel.util.OrderByComparator<LayoutSetPrototype> orderByComparator, 966 boolean retrieveFromCache); 967 968 /** 969 * Removes all the layout set prototypes from the database. 970 */ 971 public void removeAll(); 972 973 /** 974 * Returns the number of layout set prototypes. 975 * 976 * @return the number of layout set prototypes 977 */ 978 public int countAll(); 979 980 @Override 981 public java.util.Set<java.lang.String> getBadColumnNames(); 982 }