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