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