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.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.LayoutSetPrototype; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the layout set prototype service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutSetPrototypePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see LayoutSetPrototypePersistence 037 * @see com.liferay.portal.service.persistence.impl.LayoutSetPrototypePersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class LayoutSetPrototypeUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(LayoutSetPrototype layoutSetPrototype) { 059 getPersistence().clearCache(layoutSetPrototype); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<LayoutSetPrototype> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<LayoutSetPrototype> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<LayoutSetPrototype> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<LayoutSetPrototype> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static LayoutSetPrototype update( 100 LayoutSetPrototype layoutSetPrototype) { 101 return getPersistence().update(layoutSetPrototype); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static LayoutSetPrototype update( 108 LayoutSetPrototype layoutSetPrototype, ServiceContext serviceContext) { 109 return getPersistence().update(layoutSetPrototype, serviceContext); 110 } 111 112 /** 113 * Returns all the layout set prototypes where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching layout set prototypes 117 */ 118 public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the layout set prototypes where uuid = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of layout set prototypes 131 * @param end the upper bound of the range of layout set prototypes (not inclusive) 132 * @return the range of matching layout set prototypes 133 */ 134 public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the layout set prototypes where uuid = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of layout set prototypes 148 * @param end the upper bound of the range of layout set prototypes (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching layout set prototypes 151 */ 152 public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid, 153 int start, int end, 154 OrderByComparator<LayoutSetPrototype> orderByComparator) { 155 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns an ordered range of all the layout set prototypes where uuid = ?. 160 * 161 * <p> 162 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 163 * </p> 164 * 165 * @param uuid the uuid 166 * @param start the lower bound of the range of layout set prototypes 167 * @param end the upper bound of the range of layout set prototypes (not inclusive) 168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 169 * @param retrieveFromCache whether to retrieve from the finder cache 170 * @return the ordered range of matching layout set prototypes 171 */ 172 public static List<LayoutSetPrototype> findByUuid(java.lang.String uuid, 173 int start, int end, 174 OrderByComparator<LayoutSetPrototype> orderByComparator, 175 boolean retrieveFromCache) { 176 return getPersistence() 177 .findByUuid(uuid, start, end, orderByComparator, 178 retrieveFromCache); 179 } 180 181 /** 182 * Returns the first layout set prototype in the ordered set where uuid = ?. 183 * 184 * @param uuid the uuid 185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 186 * @return the first matching layout set prototype 187 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 188 */ 189 public static LayoutSetPrototype findByUuid_First(java.lang.String uuid, 190 OrderByComparator<LayoutSetPrototype> orderByComparator) 191 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 192 return getPersistence().findByUuid_First(uuid, orderByComparator); 193 } 194 195 /** 196 * Returns the first layout set prototype in the ordered set where uuid = ?. 197 * 198 * @param uuid the uuid 199 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 200 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 201 */ 202 public static LayoutSetPrototype fetchByUuid_First(java.lang.String uuid, 203 OrderByComparator<LayoutSetPrototype> orderByComparator) { 204 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 205 } 206 207 /** 208 * Returns the last layout set prototype in the ordered set where uuid = ?. 209 * 210 * @param uuid the uuid 211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 212 * @return the last matching layout set prototype 213 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 214 */ 215 public static LayoutSetPrototype findByUuid_Last(java.lang.String uuid, 216 OrderByComparator<LayoutSetPrototype> orderByComparator) 217 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 218 return getPersistence().findByUuid_Last(uuid, orderByComparator); 219 } 220 221 /** 222 * Returns the last layout set prototype in the ordered set where uuid = ?. 223 * 224 * @param uuid the uuid 225 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 226 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 227 */ 228 public static LayoutSetPrototype fetchByUuid_Last(java.lang.String uuid, 229 OrderByComparator<LayoutSetPrototype> orderByComparator) { 230 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 231 } 232 233 /** 234 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = ?. 235 * 236 * @param layoutSetPrototypeId the primary key of the current layout set prototype 237 * @param uuid the uuid 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the previous, current, and next layout set prototype 240 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 241 */ 242 public static LayoutSetPrototype[] findByUuid_PrevAndNext( 243 long layoutSetPrototypeId, java.lang.String uuid, 244 OrderByComparator<LayoutSetPrototype> orderByComparator) 245 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 246 return getPersistence() 247 .findByUuid_PrevAndNext(layoutSetPrototypeId, uuid, 248 orderByComparator); 249 } 250 251 /** 252 * Returns all the layout set prototypes that the user has permission to view where uuid = ?. 253 * 254 * @param uuid the uuid 255 * @return the matching layout set prototypes that the user has permission to view 256 */ 257 public static List<LayoutSetPrototype> filterFindByUuid( 258 java.lang.String uuid) { 259 return getPersistence().filterFindByUuid(uuid); 260 } 261 262 /** 263 * Returns a range of all the layout set prototypes that the user has permission to view where uuid = ?. 264 * 265 * <p> 266 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 267 * </p> 268 * 269 * @param uuid the uuid 270 * @param start the lower bound of the range of layout set prototypes 271 * @param end the upper bound of the range of layout set prototypes (not inclusive) 272 * @return the range of matching layout set prototypes that the user has permission to view 273 */ 274 public static List<LayoutSetPrototype> filterFindByUuid( 275 java.lang.String uuid, int start, int end) { 276 return getPersistence().filterFindByUuid(uuid, start, end); 277 } 278 279 /** 280 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = ?. 281 * 282 * <p> 283 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 284 * </p> 285 * 286 * @param uuid the uuid 287 * @param start the lower bound of the range of layout set prototypes 288 * @param end the upper bound of the range of layout set prototypes (not inclusive) 289 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 290 * @return the ordered range of matching layout set prototypes that the user has permission to view 291 */ 292 public static List<LayoutSetPrototype> filterFindByUuid( 293 java.lang.String uuid, int start, int end, 294 OrderByComparator<LayoutSetPrototype> orderByComparator) { 295 return getPersistence() 296 .filterFindByUuid(uuid, start, end, orderByComparator); 297 } 298 299 /** 300 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = ?. 301 * 302 * @param layoutSetPrototypeId the primary key of the current layout set prototype 303 * @param uuid the uuid 304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 305 * @return the previous, current, and next layout set prototype 306 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 307 */ 308 public static LayoutSetPrototype[] filterFindByUuid_PrevAndNext( 309 long layoutSetPrototypeId, java.lang.String uuid, 310 OrderByComparator<LayoutSetPrototype> orderByComparator) 311 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 312 return getPersistence() 313 .filterFindByUuid_PrevAndNext(layoutSetPrototypeId, uuid, 314 orderByComparator); 315 } 316 317 /** 318 * Removes all the layout set prototypes where uuid = ? from the database. 319 * 320 * @param uuid the uuid 321 */ 322 public static void removeByUuid(java.lang.String uuid) { 323 getPersistence().removeByUuid(uuid); 324 } 325 326 /** 327 * Returns the number of layout set prototypes where uuid = ?. 328 * 329 * @param uuid the uuid 330 * @return the number of matching layout set prototypes 331 */ 332 public static int countByUuid(java.lang.String uuid) { 333 return getPersistence().countByUuid(uuid); 334 } 335 336 /** 337 * Returns the number of layout set prototypes that the user has permission to view where uuid = ?. 338 * 339 * @param uuid the uuid 340 * @return the number of matching layout set prototypes that the user has permission to view 341 */ 342 public static int filterCountByUuid(java.lang.String uuid) { 343 return getPersistence().filterCountByUuid(uuid); 344 } 345 346 /** 347 * Returns all the layout set prototypes where uuid = ? and companyId = ?. 348 * 349 * @param uuid the uuid 350 * @param companyId the company ID 351 * @return the matching layout set prototypes 352 */ 353 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 354 long companyId) { 355 return getPersistence().findByUuid_C(uuid, companyId); 356 } 357 358 /** 359 * Returns a range of all the layout set prototypes where uuid = ? and companyId = ?. 360 * 361 * <p> 362 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 363 * </p> 364 * 365 * @param uuid the uuid 366 * @param companyId the company ID 367 * @param start the lower bound of the range of layout set prototypes 368 * @param end the upper bound of the range of layout set prototypes (not inclusive) 369 * @return the range of matching layout set prototypes 370 */ 371 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 372 long companyId, int start, int end) { 373 return getPersistence().findByUuid_C(uuid, companyId, start, end); 374 } 375 376 /** 377 * Returns an ordered range of all the layout set prototypes where uuid = ? and companyId = ?. 378 * 379 * <p> 380 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 381 * </p> 382 * 383 * @param uuid the uuid 384 * @param companyId the company ID 385 * @param start the lower bound of the range of layout set prototypes 386 * @param end the upper bound of the range of layout set prototypes (not inclusive) 387 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 388 * @return the ordered range of matching layout set prototypes 389 */ 390 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 391 long companyId, int start, int end, 392 OrderByComparator<LayoutSetPrototype> orderByComparator) { 393 return getPersistence() 394 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 395 } 396 397 /** 398 * Returns an ordered range of all the layout set prototypes where uuid = ? and companyId = ?. 399 * 400 * <p> 401 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 402 * </p> 403 * 404 * @param uuid the uuid 405 * @param companyId the company ID 406 * @param start the lower bound of the range of layout set prototypes 407 * @param end the upper bound of the range of layout set prototypes (not inclusive) 408 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 409 * @param retrieveFromCache whether to retrieve from the finder cache 410 * @return the ordered range of matching layout set prototypes 411 */ 412 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 413 long companyId, int start, int end, 414 OrderByComparator<LayoutSetPrototype> orderByComparator, 415 boolean retrieveFromCache) { 416 return getPersistence() 417 .findByUuid_C(uuid, companyId, start, end, 418 orderByComparator, retrieveFromCache); 419 } 420 421 /** 422 * Returns the first layout set prototype in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching layout set prototype 428 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 429 */ 430 public static LayoutSetPrototype findByUuid_C_First(java.lang.String uuid, 431 long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) 432 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 433 return getPersistence() 434 .findByUuid_C_First(uuid, companyId, orderByComparator); 435 } 436 437 /** 438 * Returns the first layout set prototype in the ordered set where uuid = ? and companyId = ?. 439 * 440 * @param uuid the uuid 441 * @param companyId the company ID 442 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 443 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 444 */ 445 public static LayoutSetPrototype fetchByUuid_C_First( 446 java.lang.String uuid, long companyId, 447 OrderByComparator<LayoutSetPrototype> orderByComparator) { 448 return getPersistence() 449 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 450 } 451 452 /** 453 * Returns the last layout set prototype in the ordered set where uuid = ? and companyId = ?. 454 * 455 * @param uuid the uuid 456 * @param companyId the company ID 457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 458 * @return the last matching layout set prototype 459 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 460 */ 461 public static LayoutSetPrototype findByUuid_C_Last(java.lang.String uuid, 462 long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) 463 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 464 return getPersistence() 465 .findByUuid_C_Last(uuid, companyId, orderByComparator); 466 } 467 468 /** 469 * Returns the last layout set prototype in the ordered set where uuid = ? and companyId = ?. 470 * 471 * @param uuid the uuid 472 * @param companyId the company ID 473 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 474 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 475 */ 476 public static LayoutSetPrototype fetchByUuid_C_Last(java.lang.String uuid, 477 long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) { 478 return getPersistence() 479 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 480 } 481 482 /** 483 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = ? and companyId = ?. 484 * 485 * @param layoutSetPrototypeId the primary key of the current layout set prototype 486 * @param uuid the uuid 487 * @param companyId the company ID 488 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 489 * @return the previous, current, and next layout set prototype 490 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 491 */ 492 public static LayoutSetPrototype[] findByUuid_C_PrevAndNext( 493 long layoutSetPrototypeId, java.lang.String uuid, long companyId, 494 OrderByComparator<LayoutSetPrototype> orderByComparator) 495 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 496 return getPersistence() 497 .findByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid, 498 companyId, orderByComparator); 499 } 500 501 /** 502 * Returns all the layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 503 * 504 * @param uuid the uuid 505 * @param companyId the company ID 506 * @return the matching layout set prototypes that the user has permission to view 507 */ 508 public static List<LayoutSetPrototype> filterFindByUuid_C( 509 java.lang.String uuid, long companyId) { 510 return getPersistence().filterFindByUuid_C(uuid, companyId); 511 } 512 513 /** 514 * Returns a range of all the layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 515 * 516 * <p> 517 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 518 * </p> 519 * 520 * @param uuid the uuid 521 * @param companyId the company ID 522 * @param start the lower bound of the range of layout set prototypes 523 * @param end the upper bound of the range of layout set prototypes (not inclusive) 524 * @return the range of matching layout set prototypes that the user has permission to view 525 */ 526 public static List<LayoutSetPrototype> filterFindByUuid_C( 527 java.lang.String uuid, long companyId, int start, int end) { 528 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 529 } 530 531 /** 532 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = ? and companyId = ?. 533 * 534 * <p> 535 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 536 * </p> 537 * 538 * @param uuid the uuid 539 * @param companyId the company ID 540 * @param start the lower bound of the range of layout set prototypes 541 * @param end the upper bound of the range of layout set prototypes (not inclusive) 542 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 543 * @return the ordered range of matching layout set prototypes that the user has permission to view 544 */ 545 public static List<LayoutSetPrototype> filterFindByUuid_C( 546 java.lang.String uuid, long companyId, int start, int end, 547 OrderByComparator<LayoutSetPrototype> orderByComparator) { 548 return getPersistence() 549 .filterFindByUuid_C(uuid, companyId, start, end, 550 orderByComparator); 551 } 552 553 /** 554 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 555 * 556 * @param layoutSetPrototypeId the primary key of the current layout set prototype 557 * @param uuid the uuid 558 * @param companyId the company ID 559 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 560 * @return the previous, current, and next layout set prototype 561 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 562 */ 563 public static LayoutSetPrototype[] filterFindByUuid_C_PrevAndNext( 564 long layoutSetPrototypeId, java.lang.String uuid, long companyId, 565 OrderByComparator<LayoutSetPrototype> orderByComparator) 566 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 567 return getPersistence() 568 .filterFindByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid, 569 companyId, orderByComparator); 570 } 571 572 /** 573 * Removes all the layout set prototypes where uuid = ? and companyId = ? from the database. 574 * 575 * @param uuid the uuid 576 * @param companyId the company ID 577 */ 578 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 579 getPersistence().removeByUuid_C(uuid, companyId); 580 } 581 582 /** 583 * Returns the number of layout set prototypes where uuid = ? and companyId = ?. 584 * 585 * @param uuid the uuid 586 * @param companyId the company ID 587 * @return the number of matching layout set prototypes 588 */ 589 public static int countByUuid_C(java.lang.String uuid, long companyId) { 590 return getPersistence().countByUuid_C(uuid, companyId); 591 } 592 593 /** 594 * Returns the number of layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 595 * 596 * @param uuid the uuid 597 * @param companyId the company ID 598 * @return the number of matching layout set prototypes that the user has permission to view 599 */ 600 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) { 601 return getPersistence().filterCountByUuid_C(uuid, companyId); 602 } 603 604 /** 605 * Returns all the layout set prototypes where companyId = ?. 606 * 607 * @param companyId the company ID 608 * @return the matching layout set prototypes 609 */ 610 public static List<LayoutSetPrototype> findByCompanyId(long companyId) { 611 return getPersistence().findByCompanyId(companyId); 612 } 613 614 /** 615 * Returns a range of all the layout set prototypes where companyId = ?. 616 * 617 * <p> 618 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 619 * </p> 620 * 621 * @param companyId the company ID 622 * @param start the lower bound of the range of layout set prototypes 623 * @param end the upper bound of the range of layout set prototypes (not inclusive) 624 * @return the range of matching layout set prototypes 625 */ 626 public static List<LayoutSetPrototype> findByCompanyId(long companyId, 627 int start, int end) { 628 return getPersistence().findByCompanyId(companyId, start, end); 629 } 630 631 /** 632 * Returns an ordered range of all the layout set prototypes where companyId = ?. 633 * 634 * <p> 635 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 636 * </p> 637 * 638 * @param companyId the company ID 639 * @param start the lower bound of the range of layout set prototypes 640 * @param end the upper bound of the range of layout set prototypes (not inclusive) 641 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 642 * @return the ordered range of matching layout set prototypes 643 */ 644 public static List<LayoutSetPrototype> findByCompanyId(long companyId, 645 int start, int end, 646 OrderByComparator<LayoutSetPrototype> orderByComparator) { 647 return getPersistence() 648 .findByCompanyId(companyId, start, end, orderByComparator); 649 } 650 651 /** 652 * Returns an ordered range of all the layout set prototypes where companyId = ?. 653 * 654 * <p> 655 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 656 * </p> 657 * 658 * @param companyId the company ID 659 * @param start the lower bound of the range of layout set prototypes 660 * @param end the upper bound of the range of layout set prototypes (not inclusive) 661 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 662 * @param retrieveFromCache whether to retrieve from the finder cache 663 * @return the ordered range of matching layout set prototypes 664 */ 665 public static List<LayoutSetPrototype> findByCompanyId(long companyId, 666 int start, int end, 667 OrderByComparator<LayoutSetPrototype> orderByComparator, 668 boolean retrieveFromCache) { 669 return getPersistence() 670 .findByCompanyId(companyId, start, end, orderByComparator, 671 retrieveFromCache); 672 } 673 674 /** 675 * Returns the first layout set prototype in the ordered set where companyId = ?. 676 * 677 * @param companyId the company ID 678 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 679 * @return the first matching layout set prototype 680 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 681 */ 682 public static LayoutSetPrototype findByCompanyId_First(long companyId, 683 OrderByComparator<LayoutSetPrototype> orderByComparator) 684 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 685 return getPersistence() 686 .findByCompanyId_First(companyId, orderByComparator); 687 } 688 689 /** 690 * Returns the first layout set prototype in the ordered set where companyId = ?. 691 * 692 * @param companyId the company ID 693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 694 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 695 */ 696 public static LayoutSetPrototype fetchByCompanyId_First(long companyId, 697 OrderByComparator<LayoutSetPrototype> orderByComparator) { 698 return getPersistence() 699 .fetchByCompanyId_First(companyId, orderByComparator); 700 } 701 702 /** 703 * Returns the last layout set prototype in the ordered set where companyId = ?. 704 * 705 * @param companyId the company ID 706 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 707 * @return the last matching layout set prototype 708 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 709 */ 710 public static LayoutSetPrototype findByCompanyId_Last(long companyId, 711 OrderByComparator<LayoutSetPrototype> orderByComparator) 712 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 713 return getPersistence() 714 .findByCompanyId_Last(companyId, orderByComparator); 715 } 716 717 /** 718 * Returns the last layout set prototype in the ordered set where companyId = ?. 719 * 720 * @param companyId the company ID 721 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 722 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 723 */ 724 public static LayoutSetPrototype fetchByCompanyId_Last(long companyId, 725 OrderByComparator<LayoutSetPrototype> orderByComparator) { 726 return getPersistence() 727 .fetchByCompanyId_Last(companyId, orderByComparator); 728 } 729 730 /** 731 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = ?. 732 * 733 * @param layoutSetPrototypeId the primary key of the current layout set prototype 734 * @param companyId the company ID 735 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 736 * @return the previous, current, and next layout set prototype 737 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 738 */ 739 public static LayoutSetPrototype[] findByCompanyId_PrevAndNext( 740 long layoutSetPrototypeId, long companyId, 741 OrderByComparator<LayoutSetPrototype> orderByComparator) 742 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 743 return getPersistence() 744 .findByCompanyId_PrevAndNext(layoutSetPrototypeId, 745 companyId, orderByComparator); 746 } 747 748 /** 749 * Returns all the layout set prototypes that the user has permission to view where companyId = ?. 750 * 751 * @param companyId the company ID 752 * @return the matching layout set prototypes that the user has permission to view 753 */ 754 public static List<LayoutSetPrototype> filterFindByCompanyId(long companyId) { 755 return getPersistence().filterFindByCompanyId(companyId); 756 } 757 758 /** 759 * Returns a range of all the layout set prototypes that the user has permission to view where companyId = ?. 760 * 761 * <p> 762 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 763 * </p> 764 * 765 * @param companyId the company ID 766 * @param start the lower bound of the range of layout set prototypes 767 * @param end the upper bound of the range of layout set prototypes (not inclusive) 768 * @return the range of matching layout set prototypes that the user has permission to view 769 */ 770 public static List<LayoutSetPrototype> filterFindByCompanyId( 771 long companyId, int start, int end) { 772 return getPersistence().filterFindByCompanyId(companyId, start, end); 773 } 774 775 /** 776 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = ?. 777 * 778 * <p> 779 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 780 * </p> 781 * 782 * @param companyId the company ID 783 * @param start the lower bound of the range of layout set prototypes 784 * @param end the upper bound of the range of layout set prototypes (not inclusive) 785 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 786 * @return the ordered range of matching layout set prototypes that the user has permission to view 787 */ 788 public static List<LayoutSetPrototype> filterFindByCompanyId( 789 long companyId, int start, int end, 790 OrderByComparator<LayoutSetPrototype> orderByComparator) { 791 return getPersistence() 792 .filterFindByCompanyId(companyId, start, end, 793 orderByComparator); 794 } 795 796 /** 797 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = ?. 798 * 799 * @param layoutSetPrototypeId the primary key of the current layout set prototype 800 * @param companyId the company ID 801 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 802 * @return the previous, current, and next layout set prototype 803 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 804 */ 805 public static LayoutSetPrototype[] filterFindByCompanyId_PrevAndNext( 806 long layoutSetPrototypeId, long companyId, 807 OrderByComparator<LayoutSetPrototype> orderByComparator) 808 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 809 return getPersistence() 810 .filterFindByCompanyId_PrevAndNext(layoutSetPrototypeId, 811 companyId, orderByComparator); 812 } 813 814 /** 815 * Removes all the layout set prototypes where companyId = ? from the database. 816 * 817 * @param companyId the company ID 818 */ 819 public static void removeByCompanyId(long companyId) { 820 getPersistence().removeByCompanyId(companyId); 821 } 822 823 /** 824 * Returns the number of layout set prototypes where companyId = ?. 825 * 826 * @param companyId the company ID 827 * @return the number of matching layout set prototypes 828 */ 829 public static int countByCompanyId(long companyId) { 830 return getPersistence().countByCompanyId(companyId); 831 } 832 833 /** 834 * Returns the number of layout set prototypes that the user has permission to view where companyId = ?. 835 * 836 * @param companyId the company ID 837 * @return the number of matching layout set prototypes that the user has permission to view 838 */ 839 public static int filterCountByCompanyId(long companyId) { 840 return getPersistence().filterCountByCompanyId(companyId); 841 } 842 843 /** 844 * Returns all the layout set prototypes where companyId = ? and active = ?. 845 * 846 * @param companyId the company ID 847 * @param active the active 848 * @return the matching layout set prototypes 849 */ 850 public static List<LayoutSetPrototype> findByC_A(long companyId, 851 boolean active) { 852 return getPersistence().findByC_A(companyId, active); 853 } 854 855 /** 856 * Returns a range of all the layout set prototypes where companyId = ? and active = ?. 857 * 858 * <p> 859 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 860 * </p> 861 * 862 * @param companyId the company ID 863 * @param active the active 864 * @param start the lower bound of the range of layout set prototypes 865 * @param end the upper bound of the range of layout set prototypes (not inclusive) 866 * @return the range of matching layout set prototypes 867 */ 868 public static List<LayoutSetPrototype> findByC_A(long companyId, 869 boolean active, int start, int end) { 870 return getPersistence().findByC_A(companyId, active, start, end); 871 } 872 873 /** 874 * Returns an ordered range of all the layout set prototypes where companyId = ? and active = ?. 875 * 876 * <p> 877 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 878 * </p> 879 * 880 * @param companyId the company ID 881 * @param active the active 882 * @param start the lower bound of the range of layout set prototypes 883 * @param end the upper bound of the range of layout set prototypes (not inclusive) 884 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 885 * @return the ordered range of matching layout set prototypes 886 */ 887 public static List<LayoutSetPrototype> findByC_A(long companyId, 888 boolean active, int start, int end, 889 OrderByComparator<LayoutSetPrototype> orderByComparator) { 890 return getPersistence() 891 .findByC_A(companyId, active, start, end, orderByComparator); 892 } 893 894 /** 895 * Returns an ordered range of all the layout set prototypes where companyId = ? and active = ?. 896 * 897 * <p> 898 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 899 * </p> 900 * 901 * @param companyId the company ID 902 * @param active the active 903 * @param start the lower bound of the range of layout set prototypes 904 * @param end the upper bound of the range of layout set prototypes (not inclusive) 905 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 906 * @param retrieveFromCache whether to retrieve from the finder cache 907 * @return the ordered range of matching layout set prototypes 908 */ 909 public static List<LayoutSetPrototype> findByC_A(long companyId, 910 boolean active, int start, int end, 911 OrderByComparator<LayoutSetPrototype> orderByComparator, 912 boolean retrieveFromCache) { 913 return getPersistence() 914 .findByC_A(companyId, active, start, end, orderByComparator, 915 retrieveFromCache); 916 } 917 918 /** 919 * Returns the first layout set prototype in the ordered set where companyId = ? and active = ?. 920 * 921 * @param companyId the company ID 922 * @param active the active 923 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 924 * @return the first matching layout set prototype 925 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 926 */ 927 public static LayoutSetPrototype findByC_A_First(long companyId, 928 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) 929 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 930 return getPersistence() 931 .findByC_A_First(companyId, active, orderByComparator); 932 } 933 934 /** 935 * Returns the first layout set prototype in the ordered set where companyId = ? and active = ?. 936 * 937 * @param companyId the company ID 938 * @param active the active 939 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 940 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 941 */ 942 public static LayoutSetPrototype fetchByC_A_First(long companyId, 943 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) { 944 return getPersistence() 945 .fetchByC_A_First(companyId, active, orderByComparator); 946 } 947 948 /** 949 * Returns the last layout set prototype in the ordered set where companyId = ? and active = ?. 950 * 951 * @param companyId the company ID 952 * @param active the active 953 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 954 * @return the last matching layout set prototype 955 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 956 */ 957 public static LayoutSetPrototype findByC_A_Last(long companyId, 958 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) 959 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 960 return getPersistence() 961 .findByC_A_Last(companyId, active, orderByComparator); 962 } 963 964 /** 965 * Returns the last layout set prototype in the ordered set where companyId = ? and active = ?. 966 * 967 * @param companyId the company ID 968 * @param active the active 969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 970 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 971 */ 972 public static LayoutSetPrototype fetchByC_A_Last(long companyId, 973 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) { 974 return getPersistence() 975 .fetchByC_A_Last(companyId, active, orderByComparator); 976 } 977 978 /** 979 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = ? and active = ?. 980 * 981 * @param layoutSetPrototypeId the primary key of the current layout set prototype 982 * @param companyId the company ID 983 * @param active the active 984 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 985 * @return the previous, current, and next layout set prototype 986 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 987 */ 988 public static LayoutSetPrototype[] findByC_A_PrevAndNext( 989 long layoutSetPrototypeId, long companyId, boolean active, 990 OrderByComparator<LayoutSetPrototype> orderByComparator) 991 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 992 return getPersistence() 993 .findByC_A_PrevAndNext(layoutSetPrototypeId, companyId, 994 active, orderByComparator); 995 } 996 997 /** 998 * Returns all the layout set prototypes that the user has permission to view where companyId = ? and active = ?. 999 * 1000 * @param companyId the company ID 1001 * @param active the active 1002 * @return the matching layout set prototypes that the user has permission to view 1003 */ 1004 public static List<LayoutSetPrototype> filterFindByC_A(long companyId, 1005 boolean active) { 1006 return getPersistence().filterFindByC_A(companyId, active); 1007 } 1008 1009 /** 1010 * Returns a range of all the layout set prototypes that the user has permission to view where companyId = ? and active = ?. 1011 * 1012 * <p> 1013 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1014 * </p> 1015 * 1016 * @param companyId the company ID 1017 * @param active the active 1018 * @param start the lower bound of the range of layout set prototypes 1019 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1020 * @return the range of matching layout set prototypes that the user has permission to view 1021 */ 1022 public static List<LayoutSetPrototype> filterFindByC_A(long companyId, 1023 boolean active, int start, int end) { 1024 return getPersistence().filterFindByC_A(companyId, active, start, end); 1025 } 1026 1027 /** 1028 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = ? and active = ?. 1029 * 1030 * <p> 1031 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1032 * </p> 1033 * 1034 * @param companyId the company ID 1035 * @param active the active 1036 * @param start the lower bound of the range of layout set prototypes 1037 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1038 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1039 * @return the ordered range of matching layout set prototypes that the user has permission to view 1040 */ 1041 public static List<LayoutSetPrototype> filterFindByC_A(long companyId, 1042 boolean active, int start, int end, 1043 OrderByComparator<LayoutSetPrototype> orderByComparator) { 1044 return getPersistence() 1045 .filterFindByC_A(companyId, active, start, end, 1046 orderByComparator); 1047 } 1048 1049 /** 1050 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set of layout set prototypes that the user has permission to view where companyId = ? and active = ?. 1051 * 1052 * @param layoutSetPrototypeId the primary key of the current layout set prototype 1053 * @param companyId the company ID 1054 * @param active the active 1055 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1056 * @return the previous, current, and next layout set prototype 1057 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 1058 */ 1059 public static LayoutSetPrototype[] filterFindByC_A_PrevAndNext( 1060 long layoutSetPrototypeId, long companyId, boolean active, 1061 OrderByComparator<LayoutSetPrototype> orderByComparator) 1062 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 1063 return getPersistence() 1064 .filterFindByC_A_PrevAndNext(layoutSetPrototypeId, 1065 companyId, active, orderByComparator); 1066 } 1067 1068 /** 1069 * Removes all the layout set prototypes where companyId = ? and active = ? from the database. 1070 * 1071 * @param companyId the company ID 1072 * @param active the active 1073 */ 1074 public static void removeByC_A(long companyId, boolean active) { 1075 getPersistence().removeByC_A(companyId, active); 1076 } 1077 1078 /** 1079 * Returns the number of layout set prototypes where companyId = ? and active = ?. 1080 * 1081 * @param companyId the company ID 1082 * @param active the active 1083 * @return the number of matching layout set prototypes 1084 */ 1085 public static int countByC_A(long companyId, boolean active) { 1086 return getPersistence().countByC_A(companyId, active); 1087 } 1088 1089 /** 1090 * Returns the number of layout set prototypes that the user has permission to view where companyId = ? and active = ?. 1091 * 1092 * @param companyId the company ID 1093 * @param active the active 1094 * @return the number of matching layout set prototypes that the user has permission to view 1095 */ 1096 public static int filterCountByC_A(long companyId, boolean active) { 1097 return getPersistence().filterCountByC_A(companyId, active); 1098 } 1099 1100 /** 1101 * Caches the layout set prototype in the entity cache if it is enabled. 1102 * 1103 * @param layoutSetPrototype the layout set prototype 1104 */ 1105 public static void cacheResult(LayoutSetPrototype layoutSetPrototype) { 1106 getPersistence().cacheResult(layoutSetPrototype); 1107 } 1108 1109 /** 1110 * Caches the layout set prototypes in the entity cache if it is enabled. 1111 * 1112 * @param layoutSetPrototypes the layout set prototypes 1113 */ 1114 public static void cacheResult(List<LayoutSetPrototype> layoutSetPrototypes) { 1115 getPersistence().cacheResult(layoutSetPrototypes); 1116 } 1117 1118 /** 1119 * Creates a new layout set prototype with the primary key. Does not add the layout set prototype to the database. 1120 * 1121 * @param layoutSetPrototypeId the primary key for the new layout set prototype 1122 * @return the new layout set prototype 1123 */ 1124 public static LayoutSetPrototype create(long layoutSetPrototypeId) { 1125 return getPersistence().create(layoutSetPrototypeId); 1126 } 1127 1128 /** 1129 * Removes the layout set prototype with the primary key from the database. Also notifies the appropriate model listeners. 1130 * 1131 * @param layoutSetPrototypeId the primary key of the layout set prototype 1132 * @return the layout set prototype that was removed 1133 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 1134 */ 1135 public static LayoutSetPrototype remove(long layoutSetPrototypeId) 1136 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 1137 return getPersistence().remove(layoutSetPrototypeId); 1138 } 1139 1140 public static LayoutSetPrototype updateImpl( 1141 LayoutSetPrototype layoutSetPrototype) { 1142 return getPersistence().updateImpl(layoutSetPrototype); 1143 } 1144 1145 /** 1146 * Returns the layout set prototype with the primary key or throws a {@link NoSuchLayoutSetPrototypeException} if it could not be found. 1147 * 1148 * @param layoutSetPrototypeId the primary key of the layout set prototype 1149 * @return the layout set prototype 1150 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 1151 */ 1152 public static LayoutSetPrototype findByPrimaryKey(long layoutSetPrototypeId) 1153 throws com.liferay.portal.exception.NoSuchLayoutSetPrototypeException { 1154 return getPersistence().findByPrimaryKey(layoutSetPrototypeId); 1155 } 1156 1157 /** 1158 * Returns the layout set prototype with the primary key or returns <code>null</code> if it could not be found. 1159 * 1160 * @param layoutSetPrototypeId the primary key of the layout set prototype 1161 * @return the layout set prototype, or <code>null</code> if a layout set prototype with the primary key could not be found 1162 */ 1163 public static LayoutSetPrototype fetchByPrimaryKey( 1164 long layoutSetPrototypeId) { 1165 return getPersistence().fetchByPrimaryKey(layoutSetPrototypeId); 1166 } 1167 1168 public static java.util.Map<java.io.Serializable, LayoutSetPrototype> fetchByPrimaryKeys( 1169 java.util.Set<java.io.Serializable> primaryKeys) { 1170 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1171 } 1172 1173 /** 1174 * Returns all the layout set prototypes. 1175 * 1176 * @return the layout set prototypes 1177 */ 1178 public static List<LayoutSetPrototype> findAll() { 1179 return getPersistence().findAll(); 1180 } 1181 1182 /** 1183 * Returns a range of all the layout set prototypes. 1184 * 1185 * <p> 1186 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1187 * </p> 1188 * 1189 * @param start the lower bound of the range of layout set prototypes 1190 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1191 * @return the range of layout set prototypes 1192 */ 1193 public static List<LayoutSetPrototype> findAll(int start, int end) { 1194 return getPersistence().findAll(start, end); 1195 } 1196 1197 /** 1198 * Returns an ordered range of all the layout set prototypes. 1199 * 1200 * <p> 1201 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1202 * </p> 1203 * 1204 * @param start the lower bound of the range of layout set prototypes 1205 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1206 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1207 * @return the ordered range of layout set prototypes 1208 */ 1209 public static List<LayoutSetPrototype> findAll(int start, int end, 1210 OrderByComparator<LayoutSetPrototype> orderByComparator) { 1211 return getPersistence().findAll(start, end, orderByComparator); 1212 } 1213 1214 /** 1215 * Returns an ordered range of all the layout set prototypes. 1216 * 1217 * <p> 1218 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1219 * </p> 1220 * 1221 * @param start the lower bound of the range of layout set prototypes 1222 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1223 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1224 * @param retrieveFromCache whether to retrieve from the finder cache 1225 * @return the ordered range of layout set prototypes 1226 */ 1227 public static List<LayoutSetPrototype> findAll(int start, int end, 1228 OrderByComparator<LayoutSetPrototype> orderByComparator, 1229 boolean retrieveFromCache) { 1230 return getPersistence() 1231 .findAll(start, end, orderByComparator, retrieveFromCache); 1232 } 1233 1234 /** 1235 * Removes all the layout set prototypes from the database. 1236 */ 1237 public static void removeAll() { 1238 getPersistence().removeAll(); 1239 } 1240 1241 /** 1242 * Returns the number of layout set prototypes. 1243 * 1244 * @return the number of layout set prototypes 1245 */ 1246 public static int countAll() { 1247 return getPersistence().countAll(); 1248 } 1249 1250 public static java.util.Set<java.lang.String> getBadColumnNames() { 1251 return getPersistence().getBadColumnNames(); 1252 } 1253 1254 public static LayoutSetPrototypePersistence getPersistence() { 1255 if (_persistence == null) { 1256 _persistence = (LayoutSetPrototypePersistence)PortalBeanLocatorUtil.locate(LayoutSetPrototypePersistence.class.getName()); 1257 1258 ReferenceRegistry.registerReference(LayoutSetPrototypeUtil.class, 1259 "_persistence"); 1260 } 1261 1262 return _persistence; 1263 } 1264 1265 private static LayoutSetPrototypePersistence _persistence; 1266 }