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