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