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