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 the first layout set prototype in the ordered set where uuid = ?. 160 * 161 * @param uuid the uuid 162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 163 * @return the first matching layout set prototype 164 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 165 */ 166 public static LayoutSetPrototype findByUuid_First(java.lang.String uuid, 167 OrderByComparator<LayoutSetPrototype> orderByComparator) 168 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 169 return getPersistence().findByUuid_First(uuid, orderByComparator); 170 } 171 172 /** 173 * Returns the first layout set prototype in the ordered set where uuid = ?. 174 * 175 * @param uuid the uuid 176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 177 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 178 */ 179 public static LayoutSetPrototype fetchByUuid_First(java.lang.String uuid, 180 OrderByComparator<LayoutSetPrototype> orderByComparator) { 181 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 182 } 183 184 /** 185 * Returns the last layout set prototype in the ordered set where uuid = ?. 186 * 187 * @param uuid the uuid 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the last matching layout set prototype 190 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 191 */ 192 public static LayoutSetPrototype findByUuid_Last(java.lang.String uuid, 193 OrderByComparator<LayoutSetPrototype> orderByComparator) 194 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 195 return getPersistence().findByUuid_Last(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last layout set prototype in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 204 */ 205 public static LayoutSetPrototype fetchByUuid_Last(java.lang.String uuid, 206 OrderByComparator<LayoutSetPrototype> orderByComparator) { 207 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 208 } 209 210 /** 211 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = ?. 212 * 213 * @param layoutSetPrototypeId the primary key of the current layout set prototype 214 * @param uuid the uuid 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the previous, current, and next layout set prototype 217 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 218 */ 219 public static LayoutSetPrototype[] findByUuid_PrevAndNext( 220 long layoutSetPrototypeId, java.lang.String uuid, 221 OrderByComparator<LayoutSetPrototype> orderByComparator) 222 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 223 return getPersistence() 224 .findByUuid_PrevAndNext(layoutSetPrototypeId, uuid, 225 orderByComparator); 226 } 227 228 /** 229 * Returns all the layout set prototypes that the user has permission to view where uuid = ?. 230 * 231 * @param uuid the uuid 232 * @return the matching layout set prototypes that the user has permission to view 233 */ 234 public static List<LayoutSetPrototype> filterFindByUuid( 235 java.lang.String uuid) { 236 return getPersistence().filterFindByUuid(uuid); 237 } 238 239 /** 240 * Returns a range of all the layout set prototypes that the user has permission to view where uuid = ?. 241 * 242 * <p> 243 * 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. 244 * </p> 245 * 246 * @param uuid the uuid 247 * @param start the lower bound of the range of layout set prototypes 248 * @param end the upper bound of the range of layout set prototypes (not inclusive) 249 * @return the range of matching layout set prototypes that the user has permission to view 250 */ 251 public static List<LayoutSetPrototype> filterFindByUuid( 252 java.lang.String uuid, int start, int end) { 253 return getPersistence().filterFindByUuid(uuid, start, end); 254 } 255 256 /** 257 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = ?. 258 * 259 * <p> 260 * 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. 261 * </p> 262 * 263 * @param uuid the uuid 264 * @param start the lower bound of the range of layout set prototypes 265 * @param end the upper bound of the range of layout set prototypes (not inclusive) 266 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 267 * @return the ordered range of matching layout set prototypes that the user has permission to view 268 */ 269 public static List<LayoutSetPrototype> filterFindByUuid( 270 java.lang.String uuid, int start, int end, 271 OrderByComparator<LayoutSetPrototype> orderByComparator) { 272 return getPersistence() 273 .filterFindByUuid(uuid, start, end, orderByComparator); 274 } 275 276 /** 277 * 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 = ?. 278 * 279 * @param layoutSetPrototypeId the primary key of the current layout set prototype 280 * @param uuid the uuid 281 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 282 * @return the previous, current, and next layout set prototype 283 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 284 */ 285 public static LayoutSetPrototype[] filterFindByUuid_PrevAndNext( 286 long layoutSetPrototypeId, java.lang.String uuid, 287 OrderByComparator<LayoutSetPrototype> orderByComparator) 288 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 289 return getPersistence() 290 .filterFindByUuid_PrevAndNext(layoutSetPrototypeId, uuid, 291 orderByComparator); 292 } 293 294 /** 295 * Removes all the layout set prototypes where uuid = ? from the database. 296 * 297 * @param uuid the uuid 298 */ 299 public static void removeByUuid(java.lang.String uuid) { 300 getPersistence().removeByUuid(uuid); 301 } 302 303 /** 304 * Returns the number of layout set prototypes where uuid = ?. 305 * 306 * @param uuid the uuid 307 * @return the number of matching layout set prototypes 308 */ 309 public static int countByUuid(java.lang.String uuid) { 310 return getPersistence().countByUuid(uuid); 311 } 312 313 /** 314 * Returns the number of layout set prototypes that the user has permission to view where uuid = ?. 315 * 316 * @param uuid the uuid 317 * @return the number of matching layout set prototypes that the user has permission to view 318 */ 319 public static int filterCountByUuid(java.lang.String uuid) { 320 return getPersistence().filterCountByUuid(uuid); 321 } 322 323 /** 324 * Returns all the layout set prototypes where uuid = ? and companyId = ?. 325 * 326 * @param uuid the uuid 327 * @param companyId the company ID 328 * @return the matching layout set prototypes 329 */ 330 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 331 long companyId) { 332 return getPersistence().findByUuid_C(uuid, companyId); 333 } 334 335 /** 336 * Returns a range of all the layout set prototypes where uuid = ? and companyId = ?. 337 * 338 * <p> 339 * 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. 340 * </p> 341 * 342 * @param uuid the uuid 343 * @param companyId the company ID 344 * @param start the lower bound of the range of layout set prototypes 345 * @param end the upper bound of the range of layout set prototypes (not inclusive) 346 * @return the range of matching layout set prototypes 347 */ 348 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 349 long companyId, int start, int end) { 350 return getPersistence().findByUuid_C(uuid, companyId, start, end); 351 } 352 353 /** 354 * Returns an ordered range of all the layout set prototypes where uuid = ? and companyId = ?. 355 * 356 * <p> 357 * 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. 358 * </p> 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 * @param start the lower bound of the range of layout set prototypes 363 * @param end the upper bound of the range of layout set prototypes (not inclusive) 364 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 365 * @return the ordered range of matching layout set prototypes 366 */ 367 public static List<LayoutSetPrototype> findByUuid_C(java.lang.String uuid, 368 long companyId, int start, int end, 369 OrderByComparator<LayoutSetPrototype> orderByComparator) { 370 return getPersistence() 371 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 372 } 373 374 /** 375 * Returns the first layout set prototype in the ordered set where uuid = ? and companyId = ?. 376 * 377 * @param uuid the uuid 378 * @param companyId the company ID 379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 380 * @return the first matching layout set prototype 381 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 382 */ 383 public static LayoutSetPrototype findByUuid_C_First(java.lang.String uuid, 384 long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) 385 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 386 return getPersistence() 387 .findByUuid_C_First(uuid, companyId, orderByComparator); 388 } 389 390 /** 391 * Returns the first layout set prototype in the ordered set where uuid = ? and companyId = ?. 392 * 393 * @param uuid the uuid 394 * @param companyId the company ID 395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 396 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 397 */ 398 public static LayoutSetPrototype fetchByUuid_C_First( 399 java.lang.String uuid, long companyId, 400 OrderByComparator<LayoutSetPrototype> orderByComparator) { 401 return getPersistence() 402 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 403 } 404 405 /** 406 * Returns the last layout set prototype in the ordered set where uuid = ? and companyId = ?. 407 * 408 * @param uuid the uuid 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the last matching layout set prototype 412 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 413 */ 414 public static LayoutSetPrototype findByUuid_C_Last(java.lang.String uuid, 415 long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) 416 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 417 return getPersistence() 418 .findByUuid_C_Last(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the last 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 last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 428 */ 429 public static LayoutSetPrototype fetchByUuid_C_Last(java.lang.String uuid, 430 long companyId, OrderByComparator<LayoutSetPrototype> orderByComparator) { 431 return getPersistence() 432 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 433 } 434 435 /** 436 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where uuid = ? and companyId = ?. 437 * 438 * @param layoutSetPrototypeId the primary key of the current layout set prototype 439 * @param uuid the uuid 440 * @param companyId the company ID 441 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 442 * @return the previous, current, and next layout set prototype 443 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 444 */ 445 public static LayoutSetPrototype[] findByUuid_C_PrevAndNext( 446 long layoutSetPrototypeId, java.lang.String uuid, long companyId, 447 OrderByComparator<LayoutSetPrototype> orderByComparator) 448 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 449 return getPersistence() 450 .findByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid, 451 companyId, orderByComparator); 452 } 453 454 /** 455 * Returns all the layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 456 * 457 * @param uuid the uuid 458 * @param companyId the company ID 459 * @return the matching layout set prototypes that the user has permission to view 460 */ 461 public static List<LayoutSetPrototype> filterFindByUuid_C( 462 java.lang.String uuid, long companyId) { 463 return getPersistence().filterFindByUuid_C(uuid, companyId); 464 } 465 466 /** 467 * Returns a range of all the layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 468 * 469 * <p> 470 * 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. 471 * </p> 472 * 473 * @param uuid the uuid 474 * @param companyId the company ID 475 * @param start the lower bound of the range of layout set prototypes 476 * @param end the upper bound of the range of layout set prototypes (not inclusive) 477 * @return the range of matching layout set prototypes that the user has permission to view 478 */ 479 public static List<LayoutSetPrototype> filterFindByUuid_C( 480 java.lang.String uuid, long companyId, int start, int end) { 481 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 482 } 483 484 /** 485 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where uuid = ? and companyId = ?. 486 * 487 * <p> 488 * 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. 489 * </p> 490 * 491 * @param uuid the uuid 492 * @param companyId the company ID 493 * @param start the lower bound of the range of layout set prototypes 494 * @param end the upper bound of the range of layout set prototypes (not inclusive) 495 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 496 * @return the ordered range of matching layout set prototypes that the user has permission to view 497 */ 498 public static List<LayoutSetPrototype> filterFindByUuid_C( 499 java.lang.String uuid, long companyId, int start, int end, 500 OrderByComparator<LayoutSetPrototype> orderByComparator) { 501 return getPersistence() 502 .filterFindByUuid_C(uuid, companyId, start, end, 503 orderByComparator); 504 } 505 506 /** 507 * 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 = ?. 508 * 509 * @param layoutSetPrototypeId the primary key of the current layout set prototype 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 513 * @return the previous, current, and next layout set prototype 514 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 515 */ 516 public static LayoutSetPrototype[] filterFindByUuid_C_PrevAndNext( 517 long layoutSetPrototypeId, java.lang.String uuid, long companyId, 518 OrderByComparator<LayoutSetPrototype> orderByComparator) 519 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 520 return getPersistence() 521 .filterFindByUuid_C_PrevAndNext(layoutSetPrototypeId, uuid, 522 companyId, orderByComparator); 523 } 524 525 /** 526 * Removes all the layout set prototypes where uuid = ? and companyId = ? from the database. 527 * 528 * @param uuid the uuid 529 * @param companyId the company ID 530 */ 531 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 532 getPersistence().removeByUuid_C(uuid, companyId); 533 } 534 535 /** 536 * Returns the number of layout set prototypes where uuid = ? and companyId = ?. 537 * 538 * @param uuid the uuid 539 * @param companyId the company ID 540 * @return the number of matching layout set prototypes 541 */ 542 public static int countByUuid_C(java.lang.String uuid, long companyId) { 543 return getPersistence().countByUuid_C(uuid, companyId); 544 } 545 546 /** 547 * Returns the number of layout set prototypes that the user has permission to view where uuid = ? and companyId = ?. 548 * 549 * @param uuid the uuid 550 * @param companyId the company ID 551 * @return the number of matching layout set prototypes that the user has permission to view 552 */ 553 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) { 554 return getPersistence().filterCountByUuid_C(uuid, companyId); 555 } 556 557 /** 558 * Returns all the layout set prototypes where companyId = ?. 559 * 560 * @param companyId the company ID 561 * @return the matching layout set prototypes 562 */ 563 public static List<LayoutSetPrototype> findByCompanyId(long companyId) { 564 return getPersistence().findByCompanyId(companyId); 565 } 566 567 /** 568 * Returns a range of all the layout set prototypes where companyId = ?. 569 * 570 * <p> 571 * 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. 572 * </p> 573 * 574 * @param companyId the company ID 575 * @param start the lower bound of the range of layout set prototypes 576 * @param end the upper bound of the range of layout set prototypes (not inclusive) 577 * @return the range of matching layout set prototypes 578 */ 579 public static List<LayoutSetPrototype> findByCompanyId(long companyId, 580 int start, int end) { 581 return getPersistence().findByCompanyId(companyId, start, end); 582 } 583 584 /** 585 * Returns an ordered range of all the layout set prototypes where companyId = ?. 586 * 587 * <p> 588 * 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. 589 * </p> 590 * 591 * @param companyId the company ID 592 * @param start the lower bound of the range of layout set prototypes 593 * @param end the upper bound of the range of layout set prototypes (not inclusive) 594 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 595 * @return the ordered range of matching layout set prototypes 596 */ 597 public static List<LayoutSetPrototype> findByCompanyId(long companyId, 598 int start, int end, 599 OrderByComparator<LayoutSetPrototype> orderByComparator) { 600 return getPersistence() 601 .findByCompanyId(companyId, start, end, orderByComparator); 602 } 603 604 /** 605 * Returns the first layout set prototype in the ordered set where companyId = ?. 606 * 607 * @param companyId the company ID 608 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 609 * @return the first matching layout set prototype 610 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 611 */ 612 public static LayoutSetPrototype findByCompanyId_First(long companyId, 613 OrderByComparator<LayoutSetPrototype> orderByComparator) 614 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 615 return getPersistence() 616 .findByCompanyId_First(companyId, orderByComparator); 617 } 618 619 /** 620 * Returns the first layout set prototype in the ordered set where companyId = ?. 621 * 622 * @param companyId the company ID 623 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 624 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 625 */ 626 public static LayoutSetPrototype fetchByCompanyId_First(long companyId, 627 OrderByComparator<LayoutSetPrototype> orderByComparator) { 628 return getPersistence() 629 .fetchByCompanyId_First(companyId, orderByComparator); 630 } 631 632 /** 633 * Returns the last layout set prototype in the ordered set where companyId = ?. 634 * 635 * @param companyId the company ID 636 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 637 * @return the last matching layout set prototype 638 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 639 */ 640 public static LayoutSetPrototype findByCompanyId_Last(long companyId, 641 OrderByComparator<LayoutSetPrototype> orderByComparator) 642 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 643 return getPersistence() 644 .findByCompanyId_Last(companyId, orderByComparator); 645 } 646 647 /** 648 * Returns the last layout set prototype in the ordered set where companyId = ?. 649 * 650 * @param companyId the company ID 651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 652 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 653 */ 654 public static LayoutSetPrototype fetchByCompanyId_Last(long companyId, 655 OrderByComparator<LayoutSetPrototype> orderByComparator) { 656 return getPersistence() 657 .fetchByCompanyId_Last(companyId, orderByComparator); 658 } 659 660 /** 661 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = ?. 662 * 663 * @param layoutSetPrototypeId the primary key of the current layout set prototype 664 * @param companyId the company ID 665 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 666 * @return the previous, current, and next layout set prototype 667 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 668 */ 669 public static LayoutSetPrototype[] findByCompanyId_PrevAndNext( 670 long layoutSetPrototypeId, long companyId, 671 OrderByComparator<LayoutSetPrototype> orderByComparator) 672 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 673 return getPersistence() 674 .findByCompanyId_PrevAndNext(layoutSetPrototypeId, 675 companyId, orderByComparator); 676 } 677 678 /** 679 * Returns all the layout set prototypes that the user has permission to view where companyId = ?. 680 * 681 * @param companyId the company ID 682 * @return the matching layout set prototypes that the user has permission to view 683 */ 684 public static List<LayoutSetPrototype> filterFindByCompanyId(long companyId) { 685 return getPersistence().filterFindByCompanyId(companyId); 686 } 687 688 /** 689 * Returns a range of all the layout set prototypes that the user has permission to view where companyId = ?. 690 * 691 * <p> 692 * 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. 693 * </p> 694 * 695 * @param companyId the company ID 696 * @param start the lower bound of the range of layout set prototypes 697 * @param end the upper bound of the range of layout set prototypes (not inclusive) 698 * @return the range of matching layout set prototypes that the user has permission to view 699 */ 700 public static List<LayoutSetPrototype> filterFindByCompanyId( 701 long companyId, int start, int end) { 702 return getPersistence().filterFindByCompanyId(companyId, start, end); 703 } 704 705 /** 706 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = ?. 707 * 708 * <p> 709 * 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. 710 * </p> 711 * 712 * @param companyId the company ID 713 * @param start the lower bound of the range of layout set prototypes 714 * @param end the upper bound of the range of layout set prototypes (not inclusive) 715 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 716 * @return the ordered range of matching layout set prototypes that the user has permission to view 717 */ 718 public static List<LayoutSetPrototype> filterFindByCompanyId( 719 long companyId, int start, int end, 720 OrderByComparator<LayoutSetPrototype> orderByComparator) { 721 return getPersistence() 722 .filterFindByCompanyId(companyId, start, end, 723 orderByComparator); 724 } 725 726 /** 727 * 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 = ?. 728 * 729 * @param layoutSetPrototypeId the primary key of the current layout set prototype 730 * @param companyId the company ID 731 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 732 * @return the previous, current, and next layout set prototype 733 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 734 */ 735 public static LayoutSetPrototype[] filterFindByCompanyId_PrevAndNext( 736 long layoutSetPrototypeId, long companyId, 737 OrderByComparator<LayoutSetPrototype> orderByComparator) 738 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 739 return getPersistence() 740 .filterFindByCompanyId_PrevAndNext(layoutSetPrototypeId, 741 companyId, orderByComparator); 742 } 743 744 /** 745 * Removes all the layout set prototypes where companyId = ? from the database. 746 * 747 * @param companyId the company ID 748 */ 749 public static void removeByCompanyId(long companyId) { 750 getPersistence().removeByCompanyId(companyId); 751 } 752 753 /** 754 * Returns the number of layout set prototypes where companyId = ?. 755 * 756 * @param companyId the company ID 757 * @return the number of matching layout set prototypes 758 */ 759 public static int countByCompanyId(long companyId) { 760 return getPersistence().countByCompanyId(companyId); 761 } 762 763 /** 764 * Returns the number of layout set prototypes that the user has permission to view where companyId = ?. 765 * 766 * @param companyId the company ID 767 * @return the number of matching layout set prototypes that the user has permission to view 768 */ 769 public static int filterCountByCompanyId(long companyId) { 770 return getPersistence().filterCountByCompanyId(companyId); 771 } 772 773 /** 774 * Returns all the layout set prototypes where companyId = ? and active = ?. 775 * 776 * @param companyId the company ID 777 * @param active the active 778 * @return the matching layout set prototypes 779 */ 780 public static List<LayoutSetPrototype> findByC_A(long companyId, 781 boolean active) { 782 return getPersistence().findByC_A(companyId, active); 783 } 784 785 /** 786 * Returns a range of all the layout set prototypes where companyId = ? and active = ?. 787 * 788 * <p> 789 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link LayoutSetPrototypeModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 790 * </p> 791 * 792 * @param companyId the company ID 793 * @param active the active 794 * @param start the lower bound of the range of layout set prototypes 795 * @param end the upper bound of the range of layout set prototypes (not inclusive) 796 * @return the range of matching layout set prototypes 797 */ 798 public static List<LayoutSetPrototype> findByC_A(long companyId, 799 boolean active, int start, int end) { 800 return getPersistence().findByC_A(companyId, active, start, end); 801 } 802 803 /** 804 * Returns an ordered range of all the layout set prototypes where companyId = ? and active = ?. 805 * 806 * <p> 807 * 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. 808 * </p> 809 * 810 * @param companyId the company ID 811 * @param active the active 812 * @param start the lower bound of the range of layout set prototypes 813 * @param end the upper bound of the range of layout set prototypes (not inclusive) 814 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 815 * @return the ordered range of matching layout set prototypes 816 */ 817 public static List<LayoutSetPrototype> findByC_A(long companyId, 818 boolean active, int start, int end, 819 OrderByComparator<LayoutSetPrototype> orderByComparator) { 820 return getPersistence() 821 .findByC_A(companyId, active, start, end, orderByComparator); 822 } 823 824 /** 825 * Returns the first layout set prototype in the ordered set where companyId = ? and active = ?. 826 * 827 * @param companyId the company ID 828 * @param active the active 829 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 830 * @return the first matching layout set prototype 831 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 832 */ 833 public static LayoutSetPrototype findByC_A_First(long companyId, 834 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) 835 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 836 return getPersistence() 837 .findByC_A_First(companyId, active, orderByComparator); 838 } 839 840 /** 841 * Returns the first layout set prototype in the ordered set where companyId = ? and active = ?. 842 * 843 * @param companyId the company ID 844 * @param active the active 845 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 846 * @return the first matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 847 */ 848 public static LayoutSetPrototype fetchByC_A_First(long companyId, 849 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) { 850 return getPersistence() 851 .fetchByC_A_First(companyId, active, orderByComparator); 852 } 853 854 /** 855 * Returns the last layout set prototype in the ordered set where companyId = ? and active = ?. 856 * 857 * @param companyId the company ID 858 * @param active the active 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the last matching layout set prototype 861 * @throws NoSuchLayoutSetPrototypeException if a matching layout set prototype could not be found 862 */ 863 public static LayoutSetPrototype findByC_A_Last(long companyId, 864 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) 865 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 866 return getPersistence() 867 .findByC_A_Last(companyId, active, orderByComparator); 868 } 869 870 /** 871 * Returns the last layout set prototype in the ordered set where companyId = ? and active = ?. 872 * 873 * @param companyId the company ID 874 * @param active the active 875 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 876 * @return the last matching layout set prototype, or <code>null</code> if a matching layout set prototype could not be found 877 */ 878 public static LayoutSetPrototype fetchByC_A_Last(long companyId, 879 boolean active, OrderByComparator<LayoutSetPrototype> orderByComparator) { 880 return getPersistence() 881 .fetchByC_A_Last(companyId, active, orderByComparator); 882 } 883 884 /** 885 * Returns the layout set prototypes before and after the current layout set prototype in the ordered set where companyId = ? and active = ?. 886 * 887 * @param layoutSetPrototypeId the primary key of the current layout set prototype 888 * @param companyId the company ID 889 * @param active the active 890 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 891 * @return the previous, current, and next layout set prototype 892 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 893 */ 894 public static LayoutSetPrototype[] findByC_A_PrevAndNext( 895 long layoutSetPrototypeId, long companyId, boolean active, 896 OrderByComparator<LayoutSetPrototype> orderByComparator) 897 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 898 return getPersistence() 899 .findByC_A_PrevAndNext(layoutSetPrototypeId, companyId, 900 active, orderByComparator); 901 } 902 903 /** 904 * Returns all the layout set prototypes that the user has permission to view where companyId = ? and active = ?. 905 * 906 * @param companyId the company ID 907 * @param active the active 908 * @return the matching layout set prototypes that the user has permission to view 909 */ 910 public static List<LayoutSetPrototype> filterFindByC_A(long companyId, 911 boolean active) { 912 return getPersistence().filterFindByC_A(companyId, active); 913 } 914 915 /** 916 * Returns a range of all the layout set prototypes that the user has permission to view where companyId = ? and active = ?. 917 * 918 * <p> 919 * 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. 920 * </p> 921 * 922 * @param companyId the company ID 923 * @param active the active 924 * @param start the lower bound of the range of layout set prototypes 925 * @param end the upper bound of the range of layout set prototypes (not inclusive) 926 * @return the range of matching layout set prototypes that the user has permission to view 927 */ 928 public static List<LayoutSetPrototype> filterFindByC_A(long companyId, 929 boolean active, int start, int end) { 930 return getPersistence().filterFindByC_A(companyId, active, start, end); 931 } 932 933 /** 934 * Returns an ordered range of all the layout set prototypes that the user has permissions to view where companyId = ? and active = ?. 935 * 936 * <p> 937 * 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. 938 * </p> 939 * 940 * @param companyId the company ID 941 * @param active the active 942 * @param start the lower bound of the range of layout set prototypes 943 * @param end the upper bound of the range of layout set prototypes (not inclusive) 944 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 945 * @return the ordered range of matching layout set prototypes that the user has permission to view 946 */ 947 public static List<LayoutSetPrototype> filterFindByC_A(long companyId, 948 boolean active, int start, int end, 949 OrderByComparator<LayoutSetPrototype> orderByComparator) { 950 return getPersistence() 951 .filterFindByC_A(companyId, active, start, end, 952 orderByComparator); 953 } 954 955 /** 956 * 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 = ?. 957 * 958 * @param layoutSetPrototypeId the primary key of the current layout set prototype 959 * @param companyId the company ID 960 * @param active the active 961 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 962 * @return the previous, current, and next layout set prototype 963 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 964 */ 965 public static LayoutSetPrototype[] filterFindByC_A_PrevAndNext( 966 long layoutSetPrototypeId, long companyId, boolean active, 967 OrderByComparator<LayoutSetPrototype> orderByComparator) 968 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 969 return getPersistence() 970 .filterFindByC_A_PrevAndNext(layoutSetPrototypeId, 971 companyId, active, orderByComparator); 972 } 973 974 /** 975 * Removes all the layout set prototypes where companyId = ? and active = ? from the database. 976 * 977 * @param companyId the company ID 978 * @param active the active 979 */ 980 public static void removeByC_A(long companyId, boolean active) { 981 getPersistence().removeByC_A(companyId, active); 982 } 983 984 /** 985 * Returns the number of layout set prototypes where companyId = ? and active = ?. 986 * 987 * @param companyId the company ID 988 * @param active the active 989 * @return the number of matching layout set prototypes 990 */ 991 public static int countByC_A(long companyId, boolean active) { 992 return getPersistence().countByC_A(companyId, active); 993 } 994 995 /** 996 * Returns the number of layout set prototypes that the user has permission to view where companyId = ? and active = ?. 997 * 998 * @param companyId the company ID 999 * @param active the active 1000 * @return the number of matching layout set prototypes that the user has permission to view 1001 */ 1002 public static int filterCountByC_A(long companyId, boolean active) { 1003 return getPersistence().filterCountByC_A(companyId, active); 1004 } 1005 1006 /** 1007 * Caches the layout set prototype in the entity cache if it is enabled. 1008 * 1009 * @param layoutSetPrototype the layout set prototype 1010 */ 1011 public static void cacheResult(LayoutSetPrototype layoutSetPrototype) { 1012 getPersistence().cacheResult(layoutSetPrototype); 1013 } 1014 1015 /** 1016 * Caches the layout set prototypes in the entity cache if it is enabled. 1017 * 1018 * @param layoutSetPrototypes the layout set prototypes 1019 */ 1020 public static void cacheResult(List<LayoutSetPrototype> layoutSetPrototypes) { 1021 getPersistence().cacheResult(layoutSetPrototypes); 1022 } 1023 1024 /** 1025 * Creates a new layout set prototype with the primary key. Does not add the layout set prototype to the database. 1026 * 1027 * @param layoutSetPrototypeId the primary key for the new layout set prototype 1028 * @return the new layout set prototype 1029 */ 1030 public static LayoutSetPrototype create(long layoutSetPrototypeId) { 1031 return getPersistence().create(layoutSetPrototypeId); 1032 } 1033 1034 /** 1035 * Removes the layout set prototype with the primary key from the database. Also notifies the appropriate model listeners. 1036 * 1037 * @param layoutSetPrototypeId the primary key of the layout set prototype 1038 * @return the layout set prototype that was removed 1039 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 1040 */ 1041 public static LayoutSetPrototype remove(long layoutSetPrototypeId) 1042 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 1043 return getPersistence().remove(layoutSetPrototypeId); 1044 } 1045 1046 public static LayoutSetPrototype updateImpl( 1047 LayoutSetPrototype layoutSetPrototype) { 1048 return getPersistence().updateImpl(layoutSetPrototype); 1049 } 1050 1051 /** 1052 * Returns the layout set prototype with the primary key or throws a {@link NoSuchLayoutSetPrototypeException} if it could not be found. 1053 * 1054 * @param layoutSetPrototypeId the primary key of the layout set prototype 1055 * @return the layout set prototype 1056 * @throws NoSuchLayoutSetPrototypeException if a layout set prototype with the primary key could not be found 1057 */ 1058 public static LayoutSetPrototype findByPrimaryKey(long layoutSetPrototypeId) 1059 throws com.liferay.portal.NoSuchLayoutSetPrototypeException { 1060 return getPersistence().findByPrimaryKey(layoutSetPrototypeId); 1061 } 1062 1063 /** 1064 * Returns the layout set prototype with the primary key or returns <code>null</code> if it could not be found. 1065 * 1066 * @param layoutSetPrototypeId the primary key of the layout set prototype 1067 * @return the layout set prototype, or <code>null</code> if a layout set prototype with the primary key could not be found 1068 */ 1069 public static LayoutSetPrototype fetchByPrimaryKey( 1070 long layoutSetPrototypeId) { 1071 return getPersistence().fetchByPrimaryKey(layoutSetPrototypeId); 1072 } 1073 1074 public static java.util.Map<java.io.Serializable, LayoutSetPrototype> fetchByPrimaryKeys( 1075 java.util.Set<java.io.Serializable> primaryKeys) { 1076 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1077 } 1078 1079 /** 1080 * Returns all the layout set prototypes. 1081 * 1082 * @return the layout set prototypes 1083 */ 1084 public static List<LayoutSetPrototype> findAll() { 1085 return getPersistence().findAll(); 1086 } 1087 1088 /** 1089 * Returns a range of all the layout set prototypes. 1090 * 1091 * <p> 1092 * 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. 1093 * </p> 1094 * 1095 * @param start the lower bound of the range of layout set prototypes 1096 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1097 * @return the range of layout set prototypes 1098 */ 1099 public static List<LayoutSetPrototype> findAll(int start, int end) { 1100 return getPersistence().findAll(start, end); 1101 } 1102 1103 /** 1104 * Returns an ordered range of all the layout set prototypes. 1105 * 1106 * <p> 1107 * 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. 1108 * </p> 1109 * 1110 * @param start the lower bound of the range of layout set prototypes 1111 * @param end the upper bound of the range of layout set prototypes (not inclusive) 1112 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1113 * @return the ordered range of layout set prototypes 1114 */ 1115 public static List<LayoutSetPrototype> findAll(int start, int end, 1116 OrderByComparator<LayoutSetPrototype> orderByComparator) { 1117 return getPersistence().findAll(start, end, orderByComparator); 1118 } 1119 1120 /** 1121 * Removes all the layout set prototypes from the database. 1122 */ 1123 public static void removeAll() { 1124 getPersistence().removeAll(); 1125 } 1126 1127 /** 1128 * Returns the number of layout set prototypes. 1129 * 1130 * @return the number of layout set prototypes 1131 */ 1132 public static int countAll() { 1133 return getPersistence().countAll(); 1134 } 1135 1136 public static LayoutSetPrototypePersistence getPersistence() { 1137 if (_persistence == null) { 1138 _persistence = (LayoutSetPrototypePersistence)PortalBeanLocatorUtil.locate(LayoutSetPrototypePersistence.class.getName()); 1139 1140 ReferenceRegistry.registerReference(LayoutSetPrototypeUtil.class, 1141 "_persistence"); 1142 } 1143 1144 return _persistence; 1145 } 1146 1147 /** 1148 * @deprecated As of 6.2.0 1149 */ 1150 @Deprecated 1151 public void setPersistence(LayoutSetPrototypePersistence persistence) { 1152 } 1153 1154 private static LayoutSetPrototypePersistence _persistence; 1155 }