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