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.exception.NoSuchLayoutPrototypeException; 020 import com.liferay.portal.model.LayoutPrototype; 021 022 /** 023 * The persistence interface for the layout 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.LayoutPrototypePersistenceImpl 031 * @see LayoutPrototypeUtil 032 * @generated 033 */ 034 @ProviderType 035 public interface LayoutPrototypePersistence extends BasePersistence<LayoutPrototype> { 036 /* 037 * NOTE FOR DEVELOPERS: 038 * 039 * Never modify or reference this interface directly. Always use {@link LayoutPrototypeUtil} to access the layout prototype persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 040 */ 041 042 /** 043 * Returns all the layout prototypes where uuid = ?. 044 * 045 * @param uuid the uuid 046 * @return the matching layout prototypes 047 */ 048 public java.util.List<LayoutPrototype> findByUuid(java.lang.String uuid); 049 050 /** 051 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 059 * @param end the upper bound of the range of layout prototypes (not inclusive) 060 * @return the range of matching layout prototypes 061 */ 062 public java.util.List<LayoutPrototype> findByUuid(java.lang.String uuid, 063 int start, int end); 064 065 /** 066 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 074 * @param end the upper bound of the range of layout 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 prototypes 077 */ 078 public java.util.List<LayoutPrototype> findByUuid(java.lang.String uuid, 079 int start, int end, 080 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 081 082 /** 083 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 091 * @param end the upper bound of the range of layout 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 prototypes 095 */ 096 public java.util.List<LayoutPrototype> findByUuid(java.lang.String uuid, 097 int start, int end, 098 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator, 099 boolean retrieveFromCache); 100 101 /** 102 * Returns the first layout 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 prototype 107 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 108 */ 109 public LayoutPrototype findByUuid_First(java.lang.String uuid, 110 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 111 throws NoSuchLayoutPrototypeException; 112 113 /** 114 * Returns the first layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 119 */ 120 public LayoutPrototype fetchByUuid_First(java.lang.String uuid, 121 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 122 123 /** 124 * Returns the last layout 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 prototype 129 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 130 */ 131 public LayoutPrototype findByUuid_Last(java.lang.String uuid, 132 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 133 throws NoSuchLayoutPrototypeException; 134 135 /** 136 * Returns the last layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 141 */ 142 public LayoutPrototype fetchByUuid_Last(java.lang.String uuid, 143 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 144 145 /** 146 * Returns the layout prototypes before and after the current layout prototype in the ordered set where uuid = ?. 147 * 148 * @param layoutPrototypeId the primary key of the current layout 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 prototype 152 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 153 */ 154 public LayoutPrototype[] findByUuid_PrevAndNext(long layoutPrototypeId, 155 java.lang.String uuid, 156 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 157 throws NoSuchLayoutPrototypeException; 158 159 /** 160 * Returns all the layout prototypes that the user has permission to view where uuid = ?. 161 * 162 * @param uuid the uuid 163 * @return the matching layout prototypes that the user has permission to view 164 */ 165 public java.util.List<LayoutPrototype> filterFindByUuid( 166 java.lang.String uuid); 167 168 /** 169 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 177 * @param end the upper bound of the range of layout prototypes (not inclusive) 178 * @return the range of matching layout prototypes that the user has permission to view 179 */ 180 public java.util.List<LayoutPrototype> filterFindByUuid( 181 java.lang.String uuid, int start, int end); 182 183 /** 184 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 192 * @param end the upper bound of the range of layout 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 prototypes that the user has permission to view 195 */ 196 public java.util.List<LayoutPrototype> filterFindByUuid( 197 java.lang.String uuid, int start, int end, 198 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 199 200 /** 201 * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where uuid = ?. 202 * 203 * @param layoutPrototypeId the primary key of the current layout 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 prototype 207 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 208 */ 209 public LayoutPrototype[] filterFindByUuid_PrevAndNext( 210 long layoutPrototypeId, java.lang.String uuid, 211 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 212 throws NoSuchLayoutPrototypeException; 213 214 /** 215 * Removes all the layout 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 prototypes where uuid = ?. 223 * 224 * @param uuid the uuid 225 * @return the number of matching layout prototypes 226 */ 227 public int countByUuid(java.lang.String uuid); 228 229 /** 230 * Returns the number of layout prototypes that the user has permission to view where uuid = ?. 231 * 232 * @param uuid the uuid 233 * @return the number of matching layout prototypes that the user has permission to view 234 */ 235 public int filterCountByUuid(java.lang.String uuid); 236 237 /** 238 * Returns all the layout prototypes where uuid = ? and companyId = ?. 239 * 240 * @param uuid the uuid 241 * @param companyId the company ID 242 * @return the matching layout prototypes 243 */ 244 public java.util.List<LayoutPrototype> findByUuid_C(java.lang.String uuid, 245 long companyId); 246 247 /** 248 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 257 * @param end the upper bound of the range of layout prototypes (not inclusive) 258 * @return the range of matching layout prototypes 259 */ 260 public java.util.List<LayoutPrototype> findByUuid_C(java.lang.String uuid, 261 long companyId, int start, int end); 262 263 /** 264 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 273 * @param end the upper bound of the range of layout 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 prototypes 276 */ 277 public java.util.List<LayoutPrototype> findByUuid_C(java.lang.String uuid, 278 long companyId, int start, int end, 279 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 280 281 /** 282 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 291 * @param end the upper bound of the range of layout 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 prototypes 295 */ 296 public java.util.List<LayoutPrototype> findByUuid_C(java.lang.String uuid, 297 long companyId, int start, int end, 298 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator, 299 boolean retrieveFromCache); 300 301 /** 302 * Returns the first layout 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 prototype 308 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 309 */ 310 public LayoutPrototype findByUuid_C_First(java.lang.String uuid, 311 long companyId, 312 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 313 throws NoSuchLayoutPrototypeException; 314 315 /** 316 * Returns the first layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 322 */ 323 public LayoutPrototype fetchByUuid_C_First(java.lang.String uuid, 324 long companyId, 325 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 326 327 /** 328 * Returns the last layout 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 prototype 334 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 335 */ 336 public LayoutPrototype findByUuid_C_Last(java.lang.String uuid, 337 long companyId, 338 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 339 throws NoSuchLayoutPrototypeException; 340 341 /** 342 * Returns the last layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 348 */ 349 public LayoutPrototype fetchByUuid_C_Last(java.lang.String uuid, 350 long companyId, 351 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 352 353 /** 354 * Returns the layout prototypes before and after the current layout prototype in the ordered set where uuid = ? and companyId = ?. 355 * 356 * @param layoutPrototypeId the primary key of the current layout 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 prototype 361 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 362 */ 363 public LayoutPrototype[] findByUuid_C_PrevAndNext(long layoutPrototypeId, 364 java.lang.String uuid, long companyId, 365 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 366 throws NoSuchLayoutPrototypeException; 367 368 /** 369 * Returns all the layout 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 prototypes that the user has permission to view 374 */ 375 public java.util.List<LayoutPrototype> filterFindByUuid_C( 376 java.lang.String uuid, long companyId); 377 378 /** 379 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 388 * @param end the upper bound of the range of layout prototypes (not inclusive) 389 * @return the range of matching layout prototypes that the user has permission to view 390 */ 391 public java.util.List<LayoutPrototype> filterFindByUuid_C( 392 java.lang.String uuid, long companyId, int start, int end); 393 394 /** 395 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 404 * @param end the upper bound of the range of layout 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 prototypes that the user has permission to view 407 */ 408 public java.util.List<LayoutPrototype> filterFindByUuid_C( 409 java.lang.String uuid, long companyId, int start, int end, 410 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 411 412 /** 413 * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where uuid = ? and companyId = ?. 414 * 415 * @param layoutPrototypeId the primary key of the current layout 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 prototype 420 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 421 */ 422 public LayoutPrototype[] filterFindByUuid_C_PrevAndNext( 423 long layoutPrototypeId, java.lang.String uuid, long companyId, 424 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 425 throws NoSuchLayoutPrototypeException; 426 427 /** 428 * Removes all the layout 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 prototypes where uuid = ? and companyId = ?. 437 * 438 * @param uuid the uuid 439 * @param companyId the company ID 440 * @return the number of matching layout prototypes 441 */ 442 public int countByUuid_C(java.lang.String uuid, long companyId); 443 444 /** 445 * Returns the number of layout 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 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 prototypes where companyId = ?. 455 * 456 * @param companyId the company ID 457 * @return the matching layout prototypes 458 */ 459 public java.util.List<LayoutPrototype> findByCompanyId(long companyId); 460 461 /** 462 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 470 * @param end the upper bound of the range of layout prototypes (not inclusive) 471 * @return the range of matching layout prototypes 472 */ 473 public java.util.List<LayoutPrototype> findByCompanyId(long companyId, 474 int start, int end); 475 476 /** 477 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 485 * @param end the upper bound of the range of layout 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 prototypes 488 */ 489 public java.util.List<LayoutPrototype> findByCompanyId(long companyId, 490 int start, int end, 491 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 492 493 /** 494 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 502 * @param end the upper bound of the range of layout 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 prototypes 506 */ 507 public java.util.List<LayoutPrototype> findByCompanyId(long companyId, 508 int start, int end, 509 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator, 510 boolean retrieveFromCache); 511 512 /** 513 * Returns the first layout 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 prototype 518 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 519 */ 520 public LayoutPrototype findByCompanyId_First(long companyId, 521 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 522 throws NoSuchLayoutPrototypeException; 523 524 /** 525 * Returns the first layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 530 */ 531 public LayoutPrototype fetchByCompanyId_First(long companyId, 532 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 533 534 /** 535 * Returns the last layout 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 prototype 540 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 541 */ 542 public LayoutPrototype findByCompanyId_Last(long companyId, 543 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 544 throws NoSuchLayoutPrototypeException; 545 546 /** 547 * Returns the last layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 552 */ 553 public LayoutPrototype fetchByCompanyId_Last(long companyId, 554 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 555 556 /** 557 * Returns the layout prototypes before and after the current layout prototype in the ordered set where companyId = ?. 558 * 559 * @param layoutPrototypeId the primary key of the current layout 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 prototype 563 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 564 */ 565 public LayoutPrototype[] findByCompanyId_PrevAndNext( 566 long layoutPrototypeId, long companyId, 567 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 568 throws NoSuchLayoutPrototypeException; 569 570 /** 571 * Returns all the layout prototypes that the user has permission to view where companyId = ?. 572 * 573 * @param companyId the company ID 574 * @return the matching layout prototypes that the user has permission to view 575 */ 576 public java.util.List<LayoutPrototype> filterFindByCompanyId(long companyId); 577 578 /** 579 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 587 * @param end the upper bound of the range of layout prototypes (not inclusive) 588 * @return the range of matching layout prototypes that the user has permission to view 589 */ 590 public java.util.List<LayoutPrototype> filterFindByCompanyId( 591 long companyId, int start, int end); 592 593 /** 594 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 602 * @param end the upper bound of the range of layout 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 prototypes that the user has permission to view 605 */ 606 public java.util.List<LayoutPrototype> filterFindByCompanyId( 607 long companyId, int start, int end, 608 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 609 610 /** 611 * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where companyId = ?. 612 * 613 * @param layoutPrototypeId the primary key of the current layout 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 prototype 617 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 618 */ 619 public LayoutPrototype[] filterFindByCompanyId_PrevAndNext( 620 long layoutPrototypeId, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 622 throws NoSuchLayoutPrototypeException; 623 624 /** 625 * Removes all the layout 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 prototypes where companyId = ?. 633 * 634 * @param companyId the company ID 635 * @return the number of matching layout prototypes 636 */ 637 public int countByCompanyId(long companyId); 638 639 /** 640 * Returns the number of layout prototypes that the user has permission to view where companyId = ?. 641 * 642 * @param companyId the company ID 643 * @return the number of matching layout prototypes that the user has permission to view 644 */ 645 public int filterCountByCompanyId(long companyId); 646 647 /** 648 * Returns all the layout prototypes where companyId = ? and active = ?. 649 * 650 * @param companyId the company ID 651 * @param active the active 652 * @return the matching layout prototypes 653 */ 654 public java.util.List<LayoutPrototype> findByC_A(long companyId, 655 boolean active); 656 657 /** 658 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 667 * @param end the upper bound of the range of layout prototypes (not inclusive) 668 * @return the range of matching layout prototypes 669 */ 670 public java.util.List<LayoutPrototype> findByC_A(long companyId, 671 boolean active, int start, int end); 672 673 /** 674 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 683 * @param end the upper bound of the range of layout 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 prototypes 686 */ 687 public java.util.List<LayoutPrototype> findByC_A(long companyId, 688 boolean active, int start, int end, 689 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 690 691 /** 692 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 701 * @param end the upper bound of the range of layout 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 prototypes 705 */ 706 public java.util.List<LayoutPrototype> findByC_A(long companyId, 707 boolean active, int start, int end, 708 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator, 709 boolean retrieveFromCache); 710 711 /** 712 * Returns the first layout 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 prototype 718 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 719 */ 720 public LayoutPrototype findByC_A_First(long companyId, boolean active, 721 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 722 throws NoSuchLayoutPrototypeException; 723 724 /** 725 * Returns the first layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 731 */ 732 public LayoutPrototype fetchByC_A_First(long companyId, boolean active, 733 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 734 735 /** 736 * Returns the last layout 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 prototype 742 * @throws NoSuchLayoutPrototypeException if a matching layout prototype could not be found 743 */ 744 public LayoutPrototype findByC_A_Last(long companyId, boolean active, 745 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 746 throws NoSuchLayoutPrototypeException; 747 748 /** 749 * Returns the last layout 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 prototype, or <code>null</code> if a matching layout prototype could not be found 755 */ 756 public LayoutPrototype fetchByC_A_Last(long companyId, boolean active, 757 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 758 759 /** 760 * Returns the layout prototypes before and after the current layout prototype in the ordered set where companyId = ? and active = ?. 761 * 762 * @param layoutPrototypeId the primary key of the current layout 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 prototype 767 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 768 */ 769 public LayoutPrototype[] findByC_A_PrevAndNext(long layoutPrototypeId, 770 long companyId, boolean active, 771 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 772 throws NoSuchLayoutPrototypeException; 773 774 /** 775 * Returns all the layout 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 prototypes that the user has permission to view 780 */ 781 public java.util.List<LayoutPrototype> filterFindByC_A(long companyId, 782 boolean active); 783 784 /** 785 * Returns a range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 794 * @param end the upper bound of the range of layout prototypes (not inclusive) 795 * @return the range of matching layout prototypes that the user has permission to view 796 */ 797 public java.util.List<LayoutPrototype> filterFindByC_A(long companyId, 798 boolean active, int start, int end); 799 800 /** 801 * Returns an ordered range of all the layout 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 LayoutPrototypeModelImpl}. 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 prototypes 810 * @param end the upper bound of the range of layout 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 prototypes that the user has permission to view 813 */ 814 public java.util.List<LayoutPrototype> filterFindByC_A(long companyId, 815 boolean active, int start, int end, 816 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 817 818 /** 819 * Returns the layout prototypes before and after the current layout prototype in the ordered set of layout prototypes that the user has permission to view where companyId = ? and active = ?. 820 * 821 * @param layoutPrototypeId the primary key of the current layout 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 prototype 826 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 827 */ 828 public LayoutPrototype[] filterFindByC_A_PrevAndNext( 829 long layoutPrototypeId, long companyId, boolean active, 830 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator) 831 throws NoSuchLayoutPrototypeException; 832 833 /** 834 * Removes all the layout 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 prototypes where companyId = ? and active = ?. 843 * 844 * @param companyId the company ID 845 * @param active the active 846 * @return the number of matching layout prototypes 847 */ 848 public int countByC_A(long companyId, boolean active); 849 850 /** 851 * Returns the number of layout 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 prototypes that the user has permission to view 856 */ 857 public int filterCountByC_A(long companyId, boolean active); 858 859 /** 860 * Caches the layout prototype in the entity cache if it is enabled. 861 * 862 * @param layoutPrototype the layout prototype 863 */ 864 public void cacheResult(LayoutPrototype layoutPrototype); 865 866 /** 867 * Caches the layout prototypes in the entity cache if it is enabled. 868 * 869 * @param layoutPrototypes the layout prototypes 870 */ 871 public void cacheResult(java.util.List<LayoutPrototype> layoutPrototypes); 872 873 /** 874 * Creates a new layout prototype with the primary key. Does not add the layout prototype to the database. 875 * 876 * @param layoutPrototypeId the primary key for the new layout prototype 877 * @return the new layout prototype 878 */ 879 public LayoutPrototype create(long layoutPrototypeId); 880 881 /** 882 * Removes the layout prototype with the primary key from the database. Also notifies the appropriate model listeners. 883 * 884 * @param layoutPrototypeId the primary key of the layout prototype 885 * @return the layout prototype that was removed 886 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 887 */ 888 public LayoutPrototype remove(long layoutPrototypeId) 889 throws NoSuchLayoutPrototypeException; 890 891 public LayoutPrototype updateImpl(LayoutPrototype layoutPrototype); 892 893 /** 894 * Returns the layout prototype with the primary key or throws a {@link NoSuchLayoutPrototypeException} if it could not be found. 895 * 896 * @param layoutPrototypeId the primary key of the layout prototype 897 * @return the layout prototype 898 * @throws NoSuchLayoutPrototypeException if a layout prototype with the primary key could not be found 899 */ 900 public LayoutPrototype findByPrimaryKey(long layoutPrototypeId) 901 throws NoSuchLayoutPrototypeException; 902 903 /** 904 * Returns the layout prototype with the primary key or returns <code>null</code> if it could not be found. 905 * 906 * @param layoutPrototypeId the primary key of the layout prototype 907 * @return the layout prototype, or <code>null</code> if a layout prototype with the primary key could not be found 908 */ 909 public LayoutPrototype fetchByPrimaryKey(long layoutPrototypeId); 910 911 @Override 912 public java.util.Map<java.io.Serializable, LayoutPrototype> fetchByPrimaryKeys( 913 java.util.Set<java.io.Serializable> primaryKeys); 914 915 /** 916 * Returns all the layout prototypes. 917 * 918 * @return the layout prototypes 919 */ 920 public java.util.List<LayoutPrototype> findAll(); 921 922 /** 923 * Returns a range of all the layout prototypes. 924 * 925 * <p> 926 * 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 LayoutPrototypeModelImpl}. 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. 927 * </p> 928 * 929 * @param start the lower bound of the range of layout prototypes 930 * @param end the upper bound of the range of layout prototypes (not inclusive) 931 * @return the range of layout prototypes 932 */ 933 public java.util.List<LayoutPrototype> findAll(int start, int end); 934 935 /** 936 * Returns an ordered range of all the layout prototypes. 937 * 938 * <p> 939 * 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 LayoutPrototypeModelImpl}. 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. 940 * </p> 941 * 942 * @param start the lower bound of the range of layout prototypes 943 * @param end the upper bound of the range of layout prototypes (not inclusive) 944 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 945 * @return the ordered range of layout prototypes 946 */ 947 public java.util.List<LayoutPrototype> findAll(int start, int end, 948 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator); 949 950 /** 951 * Returns an ordered range of all the layout prototypes. 952 * 953 * <p> 954 * 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 LayoutPrototypeModelImpl}. 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. 955 * </p> 956 * 957 * @param start the lower bound of the range of layout prototypes 958 * @param end the upper bound of the range of layout prototypes (not inclusive) 959 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 960 * @param retrieveFromCache whether to retrieve from the finder cache 961 * @return the ordered range of layout prototypes 962 */ 963 public java.util.List<LayoutPrototype> findAll(int start, int end, 964 com.liferay.portal.kernel.util.OrderByComparator<LayoutPrototype> orderByComparator, 965 boolean retrieveFromCache); 966 967 /** 968 * Removes all the layout prototypes from the database. 969 */ 970 public void removeAll(); 971 972 /** 973 * Returns the number of layout prototypes. 974 * 975 * @return the number of layout prototypes 976 */ 977 public int countAll(); 978 979 @Override 980 public java.util.Set<java.lang.String> getBadColumnNames(); 981 }