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