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.Phone; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the phone service. This utility wraps {@link com.liferay.portal.service.persistence.impl.PhonePersistenceImpl} 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 PhonePersistence 037 * @see com.liferay.portal.service.persistence.impl.PhonePersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class PhoneUtil { 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(Phone phone) { 059 getPersistence().clearCache(phone); 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<Phone> findWithDynamicQuery(DynamicQuery dynamicQuery) { 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<Phone> findWithDynamicQuery(DynamicQuery dynamicQuery, 080 int start, int end) { 081 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 082 } 083 084 /** 085 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 086 */ 087 public static List<Phone> findWithDynamicQuery(DynamicQuery dynamicQuery, 088 int start, int end, OrderByComparator<Phone> orderByComparator) { 089 return getPersistence() 090 .findWithDynamicQuery(dynamicQuery, start, end, 091 orderByComparator); 092 } 093 094 /** 095 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 096 */ 097 public static Phone update(Phone phone) { 098 return getPersistence().update(phone); 099 } 100 101 /** 102 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 103 */ 104 public static Phone update(Phone phone, ServiceContext serviceContext) { 105 return getPersistence().update(phone, serviceContext); 106 } 107 108 /** 109 * Returns all the phones where uuid = ?. 110 * 111 * @param uuid the uuid 112 * @return the matching phones 113 */ 114 public static List<Phone> findByUuid(java.lang.String uuid) { 115 return getPersistence().findByUuid(uuid); 116 } 117 118 /** 119 * Returns a range of all the phones where uuid = ?. 120 * 121 * <p> 122 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 123 * </p> 124 * 125 * @param uuid the uuid 126 * @param start the lower bound of the range of phones 127 * @param end the upper bound of the range of phones (not inclusive) 128 * @return the range of matching phones 129 */ 130 public static List<Phone> findByUuid(java.lang.String uuid, int start, 131 int end) { 132 return getPersistence().findByUuid(uuid, start, end); 133 } 134 135 /** 136 * Returns an ordered range of all the phones where uuid = ?. 137 * 138 * <p> 139 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 140 * </p> 141 * 142 * @param uuid the uuid 143 * @param start the lower bound of the range of phones 144 * @param end the upper bound of the range of phones (not inclusive) 145 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 146 * @return the ordered range of matching phones 147 */ 148 public static List<Phone> findByUuid(java.lang.String uuid, int start, 149 int end, OrderByComparator<Phone> orderByComparator) { 150 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 151 } 152 153 /** 154 * Returns an ordered range of all the phones where uuid = ?. 155 * 156 * <p> 157 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 158 * </p> 159 * 160 * @param uuid the uuid 161 * @param start the lower bound of the range of phones 162 * @param end the upper bound of the range of phones (not inclusive) 163 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 164 * @param retrieveFromCache whether to retrieve from the finder cache 165 * @return the ordered range of matching phones 166 */ 167 public static List<Phone> findByUuid(java.lang.String uuid, int start, 168 int end, OrderByComparator<Phone> orderByComparator, 169 boolean retrieveFromCache) { 170 return getPersistence() 171 .findByUuid(uuid, start, end, orderByComparator, 172 retrieveFromCache); 173 } 174 175 /** 176 * Returns the first phone in the ordered set where uuid = ?. 177 * 178 * @param uuid the uuid 179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 180 * @return the first matching phone 181 * @throws NoSuchPhoneException if a matching phone could not be found 182 */ 183 public static Phone findByUuid_First(java.lang.String uuid, 184 OrderByComparator<Phone> orderByComparator) 185 throws com.liferay.portal.exception.NoSuchPhoneException { 186 return getPersistence().findByUuid_First(uuid, orderByComparator); 187 } 188 189 /** 190 * Returns the first phone in the ordered set where uuid = ?. 191 * 192 * @param uuid the uuid 193 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 194 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 195 */ 196 public static Phone fetchByUuid_First(java.lang.String uuid, 197 OrderByComparator<Phone> orderByComparator) { 198 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 199 } 200 201 /** 202 * Returns the last phone 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 phone 207 * @throws NoSuchPhoneException if a matching phone could not be found 208 */ 209 public static Phone findByUuid_Last(java.lang.String uuid, 210 OrderByComparator<Phone> orderByComparator) 211 throws com.liferay.portal.exception.NoSuchPhoneException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last phone in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 221 */ 222 public static Phone fetchByUuid_Last(java.lang.String uuid, 223 OrderByComparator<Phone> orderByComparator) { 224 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 225 } 226 227 /** 228 * Returns the phones before and after the current phone in the ordered set where uuid = ?. 229 * 230 * @param phoneId the primary key of the current phone 231 * @param uuid the uuid 232 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 233 * @return the previous, current, and next phone 234 * @throws NoSuchPhoneException if a phone with the primary key could not be found 235 */ 236 public static Phone[] findByUuid_PrevAndNext(long phoneId, 237 java.lang.String uuid, OrderByComparator<Phone> orderByComparator) 238 throws com.liferay.portal.exception.NoSuchPhoneException { 239 return getPersistence() 240 .findByUuid_PrevAndNext(phoneId, uuid, orderByComparator); 241 } 242 243 /** 244 * Removes all the phones where uuid = ? from the database. 245 * 246 * @param uuid the uuid 247 */ 248 public static void removeByUuid(java.lang.String uuid) { 249 getPersistence().removeByUuid(uuid); 250 } 251 252 /** 253 * Returns the number of phones where uuid = ?. 254 * 255 * @param uuid the uuid 256 * @return the number of matching phones 257 */ 258 public static int countByUuid(java.lang.String uuid) { 259 return getPersistence().countByUuid(uuid); 260 } 261 262 /** 263 * Returns all the phones where uuid = ? and companyId = ?. 264 * 265 * @param uuid the uuid 266 * @param companyId the company ID 267 * @return the matching phones 268 */ 269 public static List<Phone> findByUuid_C(java.lang.String uuid, long companyId) { 270 return getPersistence().findByUuid_C(uuid, companyId); 271 } 272 273 /** 274 * Returns a range of all the phones where uuid = ? and companyId = ?. 275 * 276 * <p> 277 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 278 * </p> 279 * 280 * @param uuid the uuid 281 * @param companyId the company ID 282 * @param start the lower bound of the range of phones 283 * @param end the upper bound of the range of phones (not inclusive) 284 * @return the range of matching phones 285 */ 286 public static List<Phone> findByUuid_C(java.lang.String uuid, 287 long companyId, int start, int end) { 288 return getPersistence().findByUuid_C(uuid, companyId, start, end); 289 } 290 291 /** 292 * Returns an ordered range of all the phones where uuid = ? and companyId = ?. 293 * 294 * <p> 295 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 296 * </p> 297 * 298 * @param uuid the uuid 299 * @param companyId the company ID 300 * @param start the lower bound of the range of phones 301 * @param end the upper bound of the range of phones (not inclusive) 302 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 303 * @return the ordered range of matching phones 304 */ 305 public static List<Phone> findByUuid_C(java.lang.String uuid, 306 long companyId, int start, int end, 307 OrderByComparator<Phone> orderByComparator) { 308 return getPersistence() 309 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 310 } 311 312 /** 313 * Returns an ordered range of all the phones where uuid = ? and companyId = ?. 314 * 315 * <p> 316 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 317 * </p> 318 * 319 * @param uuid the uuid 320 * @param companyId the company ID 321 * @param start the lower bound of the range of phones 322 * @param end the upper bound of the range of phones (not inclusive) 323 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 324 * @param retrieveFromCache whether to retrieve from the finder cache 325 * @return the ordered range of matching phones 326 */ 327 public static List<Phone> findByUuid_C(java.lang.String uuid, 328 long companyId, int start, int end, 329 OrderByComparator<Phone> orderByComparator, boolean retrieveFromCache) { 330 return getPersistence() 331 .findByUuid_C(uuid, companyId, start, end, 332 orderByComparator, retrieveFromCache); 333 } 334 335 /** 336 * Returns the first phone in the ordered set where uuid = ? and companyId = ?. 337 * 338 * @param uuid the uuid 339 * @param companyId the company ID 340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 341 * @return the first matching phone 342 * @throws NoSuchPhoneException if a matching phone could not be found 343 */ 344 public static Phone findByUuid_C_First(java.lang.String uuid, 345 long companyId, OrderByComparator<Phone> orderByComparator) 346 throws com.liferay.portal.exception.NoSuchPhoneException { 347 return getPersistence() 348 .findByUuid_C_First(uuid, companyId, orderByComparator); 349 } 350 351 /** 352 * Returns the first phone in the ordered set where uuid = ? and companyId = ?. 353 * 354 * @param uuid the uuid 355 * @param companyId the company ID 356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 357 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 358 */ 359 public static Phone fetchByUuid_C_First(java.lang.String uuid, 360 long companyId, OrderByComparator<Phone> orderByComparator) { 361 return getPersistence() 362 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 363 } 364 365 /** 366 * Returns the last phone in the ordered set where uuid = ? and companyId = ?. 367 * 368 * @param uuid the uuid 369 * @param companyId the company ID 370 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 371 * @return the last matching phone 372 * @throws NoSuchPhoneException if a matching phone could not be found 373 */ 374 public static Phone findByUuid_C_Last(java.lang.String uuid, 375 long companyId, OrderByComparator<Phone> orderByComparator) 376 throws com.liferay.portal.exception.NoSuchPhoneException { 377 return getPersistence() 378 .findByUuid_C_Last(uuid, companyId, orderByComparator); 379 } 380 381 /** 382 * Returns the last phone in the ordered set where uuid = ? and companyId = ?. 383 * 384 * @param uuid the uuid 385 * @param companyId the company ID 386 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 387 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 388 */ 389 public static Phone fetchByUuid_C_Last(java.lang.String uuid, 390 long companyId, OrderByComparator<Phone> orderByComparator) { 391 return getPersistence() 392 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 393 } 394 395 /** 396 * Returns the phones before and after the current phone in the ordered set where uuid = ? and companyId = ?. 397 * 398 * @param phoneId the primary key of the current phone 399 * @param uuid the uuid 400 * @param companyId the company ID 401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 402 * @return the previous, current, and next phone 403 * @throws NoSuchPhoneException if a phone with the primary key could not be found 404 */ 405 public static Phone[] findByUuid_C_PrevAndNext(long phoneId, 406 java.lang.String uuid, long companyId, 407 OrderByComparator<Phone> orderByComparator) 408 throws com.liferay.portal.exception.NoSuchPhoneException { 409 return getPersistence() 410 .findByUuid_C_PrevAndNext(phoneId, uuid, companyId, 411 orderByComparator); 412 } 413 414 /** 415 * Removes all the phones where uuid = ? and companyId = ? from the database. 416 * 417 * @param uuid the uuid 418 * @param companyId the company ID 419 */ 420 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 421 getPersistence().removeByUuid_C(uuid, companyId); 422 } 423 424 /** 425 * Returns the number of phones where uuid = ? and companyId = ?. 426 * 427 * @param uuid the uuid 428 * @param companyId the company ID 429 * @return the number of matching phones 430 */ 431 public static int countByUuid_C(java.lang.String uuid, long companyId) { 432 return getPersistence().countByUuid_C(uuid, companyId); 433 } 434 435 /** 436 * Returns all the phones where companyId = ?. 437 * 438 * @param companyId the company ID 439 * @return the matching phones 440 */ 441 public static List<Phone> findByCompanyId(long companyId) { 442 return getPersistence().findByCompanyId(companyId); 443 } 444 445 /** 446 * Returns a range of all the phones where companyId = ?. 447 * 448 * <p> 449 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 450 * </p> 451 * 452 * @param companyId the company ID 453 * @param start the lower bound of the range of phones 454 * @param end the upper bound of the range of phones (not inclusive) 455 * @return the range of matching phones 456 */ 457 public static List<Phone> findByCompanyId(long companyId, int start, int end) { 458 return getPersistence().findByCompanyId(companyId, start, end); 459 } 460 461 /** 462 * Returns an ordered range of all the phones where companyId = ?. 463 * 464 * <p> 465 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 466 * </p> 467 * 468 * @param companyId the company ID 469 * @param start the lower bound of the range of phones 470 * @param end the upper bound of the range of phones (not inclusive) 471 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 472 * @return the ordered range of matching phones 473 */ 474 public static List<Phone> findByCompanyId(long companyId, int start, 475 int end, OrderByComparator<Phone> orderByComparator) { 476 return getPersistence() 477 .findByCompanyId(companyId, start, end, orderByComparator); 478 } 479 480 /** 481 * Returns an ordered range of all the phones where companyId = ?. 482 * 483 * <p> 484 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 485 * </p> 486 * 487 * @param companyId the company ID 488 * @param start the lower bound of the range of phones 489 * @param end the upper bound of the range of phones (not inclusive) 490 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 491 * @param retrieveFromCache whether to retrieve from the finder cache 492 * @return the ordered range of matching phones 493 */ 494 public static List<Phone> findByCompanyId(long companyId, int start, 495 int end, OrderByComparator<Phone> orderByComparator, 496 boolean retrieveFromCache) { 497 return getPersistence() 498 .findByCompanyId(companyId, start, end, orderByComparator, 499 retrieveFromCache); 500 } 501 502 /** 503 * Returns the first phone in the ordered set where companyId = ?. 504 * 505 * @param companyId the company ID 506 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 507 * @return the first matching phone 508 * @throws NoSuchPhoneException if a matching phone could not be found 509 */ 510 public static Phone findByCompanyId_First(long companyId, 511 OrderByComparator<Phone> orderByComparator) 512 throws com.liferay.portal.exception.NoSuchPhoneException { 513 return getPersistence() 514 .findByCompanyId_First(companyId, orderByComparator); 515 } 516 517 /** 518 * Returns the first phone in the ordered set where companyId = ?. 519 * 520 * @param companyId the company ID 521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 522 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 523 */ 524 public static Phone fetchByCompanyId_First(long companyId, 525 OrderByComparator<Phone> orderByComparator) { 526 return getPersistence() 527 .fetchByCompanyId_First(companyId, orderByComparator); 528 } 529 530 /** 531 * Returns the last phone in the ordered set where companyId = ?. 532 * 533 * @param companyId the company ID 534 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 535 * @return the last matching phone 536 * @throws NoSuchPhoneException if a matching phone could not be found 537 */ 538 public static Phone findByCompanyId_Last(long companyId, 539 OrderByComparator<Phone> orderByComparator) 540 throws com.liferay.portal.exception.NoSuchPhoneException { 541 return getPersistence() 542 .findByCompanyId_Last(companyId, orderByComparator); 543 } 544 545 /** 546 * Returns the last phone in the ordered set where companyId = ?. 547 * 548 * @param companyId the company ID 549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 550 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 551 */ 552 public static Phone fetchByCompanyId_Last(long companyId, 553 OrderByComparator<Phone> orderByComparator) { 554 return getPersistence() 555 .fetchByCompanyId_Last(companyId, orderByComparator); 556 } 557 558 /** 559 * Returns the phones before and after the current phone in the ordered set where companyId = ?. 560 * 561 * @param phoneId the primary key of the current phone 562 * @param companyId the company ID 563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 564 * @return the previous, current, and next phone 565 * @throws NoSuchPhoneException if a phone with the primary key could not be found 566 */ 567 public static Phone[] findByCompanyId_PrevAndNext(long phoneId, 568 long companyId, OrderByComparator<Phone> orderByComparator) 569 throws com.liferay.portal.exception.NoSuchPhoneException { 570 return getPersistence() 571 .findByCompanyId_PrevAndNext(phoneId, companyId, 572 orderByComparator); 573 } 574 575 /** 576 * Removes all the phones where companyId = ? from the database. 577 * 578 * @param companyId the company ID 579 */ 580 public static void removeByCompanyId(long companyId) { 581 getPersistence().removeByCompanyId(companyId); 582 } 583 584 /** 585 * Returns the number of phones where companyId = ?. 586 * 587 * @param companyId the company ID 588 * @return the number of matching phones 589 */ 590 public static int countByCompanyId(long companyId) { 591 return getPersistence().countByCompanyId(companyId); 592 } 593 594 /** 595 * Returns all the phones where userId = ?. 596 * 597 * @param userId the user ID 598 * @return the matching phones 599 */ 600 public static List<Phone> findByUserId(long userId) { 601 return getPersistence().findByUserId(userId); 602 } 603 604 /** 605 * Returns a range of all the phones where userId = ?. 606 * 607 * <p> 608 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 609 * </p> 610 * 611 * @param userId the user ID 612 * @param start the lower bound of the range of phones 613 * @param end the upper bound of the range of phones (not inclusive) 614 * @return the range of matching phones 615 */ 616 public static List<Phone> findByUserId(long userId, int start, int end) { 617 return getPersistence().findByUserId(userId, start, end); 618 } 619 620 /** 621 * Returns an ordered range of all the phones where userId = ?. 622 * 623 * <p> 624 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 625 * </p> 626 * 627 * @param userId the user ID 628 * @param start the lower bound of the range of phones 629 * @param end the upper bound of the range of phones (not inclusive) 630 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 631 * @return the ordered range of matching phones 632 */ 633 public static List<Phone> findByUserId(long userId, int start, int end, 634 OrderByComparator<Phone> orderByComparator) { 635 return getPersistence() 636 .findByUserId(userId, start, end, orderByComparator); 637 } 638 639 /** 640 * Returns an ordered range of all the phones where userId = ?. 641 * 642 * <p> 643 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 644 * </p> 645 * 646 * @param userId the user ID 647 * @param start the lower bound of the range of phones 648 * @param end the upper bound of the range of phones (not inclusive) 649 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 650 * @param retrieveFromCache whether to retrieve from the finder cache 651 * @return the ordered range of matching phones 652 */ 653 public static List<Phone> findByUserId(long userId, int start, int end, 654 OrderByComparator<Phone> orderByComparator, boolean retrieveFromCache) { 655 return getPersistence() 656 .findByUserId(userId, start, end, orderByComparator, 657 retrieveFromCache); 658 } 659 660 /** 661 * Returns the first phone in the ordered set where userId = ?. 662 * 663 * @param userId the user ID 664 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 665 * @return the first matching phone 666 * @throws NoSuchPhoneException if a matching phone could not be found 667 */ 668 public static Phone findByUserId_First(long userId, 669 OrderByComparator<Phone> orderByComparator) 670 throws com.liferay.portal.exception.NoSuchPhoneException { 671 return getPersistence().findByUserId_First(userId, orderByComparator); 672 } 673 674 /** 675 * Returns the first phone in the ordered set where userId = ?. 676 * 677 * @param userId the user ID 678 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 679 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 680 */ 681 public static Phone fetchByUserId_First(long userId, 682 OrderByComparator<Phone> orderByComparator) { 683 return getPersistence().fetchByUserId_First(userId, orderByComparator); 684 } 685 686 /** 687 * Returns the last phone in the ordered set where userId = ?. 688 * 689 * @param userId the user ID 690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 691 * @return the last matching phone 692 * @throws NoSuchPhoneException if a matching phone could not be found 693 */ 694 public static Phone findByUserId_Last(long userId, 695 OrderByComparator<Phone> orderByComparator) 696 throws com.liferay.portal.exception.NoSuchPhoneException { 697 return getPersistence().findByUserId_Last(userId, orderByComparator); 698 } 699 700 /** 701 * Returns the last phone in the ordered set where userId = ?. 702 * 703 * @param userId the user ID 704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 705 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 706 */ 707 public static Phone fetchByUserId_Last(long userId, 708 OrderByComparator<Phone> orderByComparator) { 709 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 710 } 711 712 /** 713 * Returns the phones before and after the current phone in the ordered set where userId = ?. 714 * 715 * @param phoneId the primary key of the current phone 716 * @param userId the user ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the previous, current, and next phone 719 * @throws NoSuchPhoneException if a phone with the primary key could not be found 720 */ 721 public static Phone[] findByUserId_PrevAndNext(long phoneId, long userId, 722 OrderByComparator<Phone> orderByComparator) 723 throws com.liferay.portal.exception.NoSuchPhoneException { 724 return getPersistence() 725 .findByUserId_PrevAndNext(phoneId, userId, orderByComparator); 726 } 727 728 /** 729 * Removes all the phones where userId = ? from the database. 730 * 731 * @param userId the user ID 732 */ 733 public static void removeByUserId(long userId) { 734 getPersistence().removeByUserId(userId); 735 } 736 737 /** 738 * Returns the number of phones where userId = ?. 739 * 740 * @param userId the user ID 741 * @return the number of matching phones 742 */ 743 public static int countByUserId(long userId) { 744 return getPersistence().countByUserId(userId); 745 } 746 747 /** 748 * Returns all the phones where companyId = ? and classNameId = ?. 749 * 750 * @param companyId the company ID 751 * @param classNameId the class name ID 752 * @return the matching phones 753 */ 754 public static List<Phone> findByC_C(long companyId, long classNameId) { 755 return getPersistence().findByC_C(companyId, classNameId); 756 } 757 758 /** 759 * Returns a range of all the phones where companyId = ? and classNameId = ?. 760 * 761 * <p> 762 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 763 * </p> 764 * 765 * @param companyId the company ID 766 * @param classNameId the class name ID 767 * @param start the lower bound of the range of phones 768 * @param end the upper bound of the range of phones (not inclusive) 769 * @return the range of matching phones 770 */ 771 public static List<Phone> findByC_C(long companyId, long classNameId, 772 int start, int end) { 773 return getPersistence().findByC_C(companyId, classNameId, start, end); 774 } 775 776 /** 777 * Returns an ordered range of all the phones where companyId = ? and classNameId = ?. 778 * 779 * <p> 780 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 781 * </p> 782 * 783 * @param companyId the company ID 784 * @param classNameId the class name ID 785 * @param start the lower bound of the range of phones 786 * @param end the upper bound of the range of phones (not inclusive) 787 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 788 * @return the ordered range of matching phones 789 */ 790 public static List<Phone> findByC_C(long companyId, long classNameId, 791 int start, int end, OrderByComparator<Phone> orderByComparator) { 792 return getPersistence() 793 .findByC_C(companyId, classNameId, start, end, 794 orderByComparator); 795 } 796 797 /** 798 * Returns an ordered range of all the phones where companyId = ? and classNameId = ?. 799 * 800 * <p> 801 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 802 * </p> 803 * 804 * @param companyId the company ID 805 * @param classNameId the class name ID 806 * @param start the lower bound of the range of phones 807 * @param end the upper bound of the range of phones (not inclusive) 808 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 809 * @param retrieveFromCache whether to retrieve from the finder cache 810 * @return the ordered range of matching phones 811 */ 812 public static List<Phone> findByC_C(long companyId, long classNameId, 813 int start, int end, OrderByComparator<Phone> orderByComparator, 814 boolean retrieveFromCache) { 815 return getPersistence() 816 .findByC_C(companyId, classNameId, start, end, 817 orderByComparator, retrieveFromCache); 818 } 819 820 /** 821 * Returns the first phone in the ordered set where companyId = ? and classNameId = ?. 822 * 823 * @param companyId the company ID 824 * @param classNameId the class name ID 825 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 826 * @return the first matching phone 827 * @throws NoSuchPhoneException if a matching phone could not be found 828 */ 829 public static Phone findByC_C_First(long companyId, long classNameId, 830 OrderByComparator<Phone> orderByComparator) 831 throws com.liferay.portal.exception.NoSuchPhoneException { 832 return getPersistence() 833 .findByC_C_First(companyId, classNameId, orderByComparator); 834 } 835 836 /** 837 * Returns the first phone in the ordered set where companyId = ? and classNameId = ?. 838 * 839 * @param companyId the company ID 840 * @param classNameId the class name ID 841 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 842 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 843 */ 844 public static Phone fetchByC_C_First(long companyId, long classNameId, 845 OrderByComparator<Phone> orderByComparator) { 846 return getPersistence() 847 .fetchByC_C_First(companyId, classNameId, orderByComparator); 848 } 849 850 /** 851 * Returns the last phone in the ordered set where companyId = ? and classNameId = ?. 852 * 853 * @param companyId the company ID 854 * @param classNameId the class name ID 855 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 856 * @return the last matching phone 857 * @throws NoSuchPhoneException if a matching phone could not be found 858 */ 859 public static Phone findByC_C_Last(long companyId, long classNameId, 860 OrderByComparator<Phone> orderByComparator) 861 throws com.liferay.portal.exception.NoSuchPhoneException { 862 return getPersistence() 863 .findByC_C_Last(companyId, classNameId, orderByComparator); 864 } 865 866 /** 867 * Returns the last phone in the ordered set where companyId = ? and classNameId = ?. 868 * 869 * @param companyId the company ID 870 * @param classNameId the class name ID 871 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 872 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 873 */ 874 public static Phone fetchByC_C_Last(long companyId, long classNameId, 875 OrderByComparator<Phone> orderByComparator) { 876 return getPersistence() 877 .fetchByC_C_Last(companyId, classNameId, orderByComparator); 878 } 879 880 /** 881 * Returns the phones before and after the current phone in the ordered set where companyId = ? and classNameId = ?. 882 * 883 * @param phoneId the primary key of the current phone 884 * @param companyId the company ID 885 * @param classNameId the class name ID 886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 887 * @return the previous, current, and next phone 888 * @throws NoSuchPhoneException if a phone with the primary key could not be found 889 */ 890 public static Phone[] findByC_C_PrevAndNext(long phoneId, long companyId, 891 long classNameId, OrderByComparator<Phone> orderByComparator) 892 throws com.liferay.portal.exception.NoSuchPhoneException { 893 return getPersistence() 894 .findByC_C_PrevAndNext(phoneId, companyId, classNameId, 895 orderByComparator); 896 } 897 898 /** 899 * Removes all the phones where companyId = ? and classNameId = ? from the database. 900 * 901 * @param companyId the company ID 902 * @param classNameId the class name ID 903 */ 904 public static void removeByC_C(long companyId, long classNameId) { 905 getPersistence().removeByC_C(companyId, classNameId); 906 } 907 908 /** 909 * Returns the number of phones where companyId = ? and classNameId = ?. 910 * 911 * @param companyId the company ID 912 * @param classNameId the class name ID 913 * @return the number of matching phones 914 */ 915 public static int countByC_C(long companyId, long classNameId) { 916 return getPersistence().countByC_C(companyId, classNameId); 917 } 918 919 /** 920 * Returns all the phones where companyId = ? and classNameId = ? and classPK = ?. 921 * 922 * @param companyId the company ID 923 * @param classNameId the class name ID 924 * @param classPK the class p k 925 * @return the matching phones 926 */ 927 public static List<Phone> findByC_C_C(long companyId, long classNameId, 928 long classPK) { 929 return getPersistence().findByC_C_C(companyId, classNameId, classPK); 930 } 931 932 /** 933 * Returns a range of all the phones where companyId = ? and classNameId = ? and classPK = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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 classNameId the class name ID 941 * @param classPK the class p k 942 * @param start the lower bound of the range of phones 943 * @param end the upper bound of the range of phones (not inclusive) 944 * @return the range of matching phones 945 */ 946 public static List<Phone> findByC_C_C(long companyId, long classNameId, 947 long classPK, int start, int end) { 948 return getPersistence() 949 .findByC_C_C(companyId, classNameId, classPK, start, end); 950 } 951 952 /** 953 * Returns an ordered range of all the phones where companyId = ? and classNameId = ? and classPK = ?. 954 * 955 * <p> 956 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 957 * </p> 958 * 959 * @param companyId the company ID 960 * @param classNameId the class name ID 961 * @param classPK the class p k 962 * @param start the lower bound of the range of phones 963 * @param end the upper bound of the range of phones (not inclusive) 964 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 965 * @return the ordered range of matching phones 966 */ 967 public static List<Phone> findByC_C_C(long companyId, long classNameId, 968 long classPK, int start, int end, 969 OrderByComparator<Phone> orderByComparator) { 970 return getPersistence() 971 .findByC_C_C(companyId, classNameId, classPK, start, end, 972 orderByComparator); 973 } 974 975 /** 976 * Returns an ordered range of all the phones where companyId = ? and classNameId = ? and classPK = ?. 977 * 978 * <p> 979 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 980 * </p> 981 * 982 * @param companyId the company ID 983 * @param classNameId the class name ID 984 * @param classPK the class p k 985 * @param start the lower bound of the range of phones 986 * @param end the upper bound of the range of phones (not inclusive) 987 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 988 * @param retrieveFromCache whether to retrieve from the finder cache 989 * @return the ordered range of matching phones 990 */ 991 public static List<Phone> findByC_C_C(long companyId, long classNameId, 992 long classPK, int start, int end, 993 OrderByComparator<Phone> orderByComparator, boolean retrieveFromCache) { 994 return getPersistence() 995 .findByC_C_C(companyId, classNameId, classPK, start, end, 996 orderByComparator, retrieveFromCache); 997 } 998 999 /** 1000 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1001 * 1002 * @param companyId the company ID 1003 * @param classNameId the class name ID 1004 * @param classPK the class p k 1005 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1006 * @return the first matching phone 1007 * @throws NoSuchPhoneException if a matching phone could not be found 1008 */ 1009 public static Phone findByC_C_C_First(long companyId, long classNameId, 1010 long classPK, OrderByComparator<Phone> orderByComparator) 1011 throws com.liferay.portal.exception.NoSuchPhoneException { 1012 return getPersistence() 1013 .findByC_C_C_First(companyId, classNameId, classPK, 1014 orderByComparator); 1015 } 1016 1017 /** 1018 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1019 * 1020 * @param companyId the company ID 1021 * @param classNameId the class name ID 1022 * @param classPK the class p k 1023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1024 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 1025 */ 1026 public static Phone fetchByC_C_C_First(long companyId, long classNameId, 1027 long classPK, OrderByComparator<Phone> orderByComparator) { 1028 return getPersistence() 1029 .fetchByC_C_C_First(companyId, classNameId, classPK, 1030 orderByComparator); 1031 } 1032 1033 /** 1034 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1035 * 1036 * @param companyId the company ID 1037 * @param classNameId the class name ID 1038 * @param classPK the class p k 1039 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1040 * @return the last matching phone 1041 * @throws NoSuchPhoneException if a matching phone could not be found 1042 */ 1043 public static Phone findByC_C_C_Last(long companyId, long classNameId, 1044 long classPK, OrderByComparator<Phone> orderByComparator) 1045 throws com.liferay.portal.exception.NoSuchPhoneException { 1046 return getPersistence() 1047 .findByC_C_C_Last(companyId, classNameId, classPK, 1048 orderByComparator); 1049 } 1050 1051 /** 1052 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1053 * 1054 * @param companyId the company ID 1055 * @param classNameId the class name ID 1056 * @param classPK the class p k 1057 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1058 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 1059 */ 1060 public static Phone fetchByC_C_C_Last(long companyId, long classNameId, 1061 long classPK, OrderByComparator<Phone> orderByComparator) { 1062 return getPersistence() 1063 .fetchByC_C_C_Last(companyId, classNameId, classPK, 1064 orderByComparator); 1065 } 1066 1067 /** 1068 * Returns the phones before and after the current phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 1069 * 1070 * @param phoneId the primary key of the current phone 1071 * @param companyId the company ID 1072 * @param classNameId the class name ID 1073 * @param classPK the class p k 1074 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1075 * @return the previous, current, and next phone 1076 * @throws NoSuchPhoneException if a phone with the primary key could not be found 1077 */ 1078 public static Phone[] findByC_C_C_PrevAndNext(long phoneId, long companyId, 1079 long classNameId, long classPK, 1080 OrderByComparator<Phone> orderByComparator) 1081 throws com.liferay.portal.exception.NoSuchPhoneException { 1082 return getPersistence() 1083 .findByC_C_C_PrevAndNext(phoneId, companyId, classNameId, 1084 classPK, orderByComparator); 1085 } 1086 1087 /** 1088 * Removes all the phones where companyId = ? and classNameId = ? and classPK = ? from the database. 1089 * 1090 * @param companyId the company ID 1091 * @param classNameId the class name ID 1092 * @param classPK the class p k 1093 */ 1094 public static void removeByC_C_C(long companyId, long classNameId, 1095 long classPK) { 1096 getPersistence().removeByC_C_C(companyId, classNameId, classPK); 1097 } 1098 1099 /** 1100 * Returns the number of phones where companyId = ? and classNameId = ? and classPK = ?. 1101 * 1102 * @param companyId the company ID 1103 * @param classNameId the class name ID 1104 * @param classPK the class p k 1105 * @return the number of matching phones 1106 */ 1107 public static int countByC_C_C(long companyId, long classNameId, 1108 long classPK) { 1109 return getPersistence().countByC_C_C(companyId, classNameId, classPK); 1110 } 1111 1112 /** 1113 * Returns all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1114 * 1115 * @param companyId the company ID 1116 * @param classNameId the class name ID 1117 * @param classPK the class p k 1118 * @param primary the primary 1119 * @return the matching phones 1120 */ 1121 public static List<Phone> findByC_C_C_P(long companyId, long classNameId, 1122 long classPK, boolean primary) { 1123 return getPersistence() 1124 .findByC_C_C_P(companyId, classNameId, classPK, primary); 1125 } 1126 1127 /** 1128 * Returns a range of all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1129 * 1130 * <p> 1131 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 1132 * </p> 1133 * 1134 * @param companyId the company ID 1135 * @param classNameId the class name ID 1136 * @param classPK the class p k 1137 * @param primary the primary 1138 * @param start the lower bound of the range of phones 1139 * @param end the upper bound of the range of phones (not inclusive) 1140 * @return the range of matching phones 1141 */ 1142 public static List<Phone> findByC_C_C_P(long companyId, long classNameId, 1143 long classPK, boolean primary, int start, int end) { 1144 return getPersistence() 1145 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1146 start, end); 1147 } 1148 1149 /** 1150 * Returns an ordered range of all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1151 * 1152 * <p> 1153 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 1154 * </p> 1155 * 1156 * @param companyId the company ID 1157 * @param classNameId the class name ID 1158 * @param classPK the class p k 1159 * @param primary the primary 1160 * @param start the lower bound of the range of phones 1161 * @param end the upper bound of the range of phones (not inclusive) 1162 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1163 * @return the ordered range of matching phones 1164 */ 1165 public static List<Phone> findByC_C_C_P(long companyId, long classNameId, 1166 long classPK, boolean primary, int start, int end, 1167 OrderByComparator<Phone> orderByComparator) { 1168 return getPersistence() 1169 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1170 start, end, orderByComparator); 1171 } 1172 1173 /** 1174 * Returns an ordered range of all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1175 * 1176 * <p> 1177 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1178 * </p> 1179 * 1180 * @param companyId the company ID 1181 * @param classNameId the class name ID 1182 * @param classPK the class p k 1183 * @param primary the primary 1184 * @param start the lower bound of the range of phones 1185 * @param end the upper bound of the range of phones (not inclusive) 1186 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1187 * @param retrieveFromCache whether to retrieve from the finder cache 1188 * @return the ordered range of matching phones 1189 */ 1190 public static List<Phone> findByC_C_C_P(long companyId, long classNameId, 1191 long classPK, boolean primary, int start, int end, 1192 OrderByComparator<Phone> orderByComparator, boolean retrieveFromCache) { 1193 return getPersistence() 1194 .findByC_C_C_P(companyId, classNameId, classPK, primary, 1195 start, end, orderByComparator, retrieveFromCache); 1196 } 1197 1198 /** 1199 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1200 * 1201 * @param companyId the company ID 1202 * @param classNameId the class name ID 1203 * @param classPK the class p k 1204 * @param primary the primary 1205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1206 * @return the first matching phone 1207 * @throws NoSuchPhoneException if a matching phone could not be found 1208 */ 1209 public static Phone findByC_C_C_P_First(long companyId, long classNameId, 1210 long classPK, boolean primary, 1211 OrderByComparator<Phone> orderByComparator) 1212 throws com.liferay.portal.exception.NoSuchPhoneException { 1213 return getPersistence() 1214 .findByC_C_C_P_First(companyId, classNameId, classPK, 1215 primary, orderByComparator); 1216 } 1217 1218 /** 1219 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1220 * 1221 * @param companyId the company ID 1222 * @param classNameId the class name ID 1223 * @param classPK the class p k 1224 * @param primary the primary 1225 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1226 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 1227 */ 1228 public static Phone fetchByC_C_C_P_First(long companyId, long classNameId, 1229 long classPK, boolean primary, 1230 OrderByComparator<Phone> orderByComparator) { 1231 return getPersistence() 1232 .fetchByC_C_C_P_First(companyId, classNameId, classPK, 1233 primary, orderByComparator); 1234 } 1235 1236 /** 1237 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1238 * 1239 * @param companyId the company ID 1240 * @param classNameId the class name ID 1241 * @param classPK the class p k 1242 * @param primary the primary 1243 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1244 * @return the last matching phone 1245 * @throws NoSuchPhoneException if a matching phone could not be found 1246 */ 1247 public static Phone findByC_C_C_P_Last(long companyId, long classNameId, 1248 long classPK, boolean primary, 1249 OrderByComparator<Phone> orderByComparator) 1250 throws com.liferay.portal.exception.NoSuchPhoneException { 1251 return getPersistence() 1252 .findByC_C_C_P_Last(companyId, classNameId, classPK, 1253 primary, orderByComparator); 1254 } 1255 1256 /** 1257 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1258 * 1259 * @param companyId the company ID 1260 * @param classNameId the class name ID 1261 * @param classPK the class p k 1262 * @param primary the primary 1263 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1264 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 1265 */ 1266 public static Phone fetchByC_C_C_P_Last(long companyId, long classNameId, 1267 long classPK, boolean primary, 1268 OrderByComparator<Phone> orderByComparator) { 1269 return getPersistence() 1270 .fetchByC_C_C_P_Last(companyId, classNameId, classPK, 1271 primary, orderByComparator); 1272 } 1273 1274 /** 1275 * Returns the phones before and after the current phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1276 * 1277 * @param phoneId the primary key of the current phone 1278 * @param companyId the company ID 1279 * @param classNameId the class name ID 1280 * @param classPK the class p k 1281 * @param primary the primary 1282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1283 * @return the previous, current, and next phone 1284 * @throws NoSuchPhoneException if a phone with the primary key could not be found 1285 */ 1286 public static Phone[] findByC_C_C_P_PrevAndNext(long phoneId, 1287 long companyId, long classNameId, long classPK, boolean primary, 1288 OrderByComparator<Phone> orderByComparator) 1289 throws com.liferay.portal.exception.NoSuchPhoneException { 1290 return getPersistence() 1291 .findByC_C_C_P_PrevAndNext(phoneId, companyId, classNameId, 1292 classPK, primary, orderByComparator); 1293 } 1294 1295 /** 1296 * Removes all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ? from the database. 1297 * 1298 * @param companyId the company ID 1299 * @param classNameId the class name ID 1300 * @param classPK the class p k 1301 * @param primary the primary 1302 */ 1303 public static void removeByC_C_C_P(long companyId, long classNameId, 1304 long classPK, boolean primary) { 1305 getPersistence() 1306 .removeByC_C_C_P(companyId, classNameId, classPK, primary); 1307 } 1308 1309 /** 1310 * Returns the number of phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 1311 * 1312 * @param companyId the company ID 1313 * @param classNameId the class name ID 1314 * @param classPK the class p k 1315 * @param primary the primary 1316 * @return the number of matching phones 1317 */ 1318 public static int countByC_C_C_P(long companyId, long classNameId, 1319 long classPK, boolean primary) { 1320 return getPersistence() 1321 .countByC_C_C_P(companyId, classNameId, classPK, primary); 1322 } 1323 1324 /** 1325 * Caches the phone in the entity cache if it is enabled. 1326 * 1327 * @param phone the phone 1328 */ 1329 public static void cacheResult(Phone phone) { 1330 getPersistence().cacheResult(phone); 1331 } 1332 1333 /** 1334 * Caches the phones in the entity cache if it is enabled. 1335 * 1336 * @param phones the phones 1337 */ 1338 public static void cacheResult(List<Phone> phones) { 1339 getPersistence().cacheResult(phones); 1340 } 1341 1342 /** 1343 * Creates a new phone with the primary key. Does not add the phone to the database. 1344 * 1345 * @param phoneId the primary key for the new phone 1346 * @return the new phone 1347 */ 1348 public static Phone create(long phoneId) { 1349 return getPersistence().create(phoneId); 1350 } 1351 1352 /** 1353 * Removes the phone with the primary key from the database. Also notifies the appropriate model listeners. 1354 * 1355 * @param phoneId the primary key of the phone 1356 * @return the phone that was removed 1357 * @throws NoSuchPhoneException if a phone with the primary key could not be found 1358 */ 1359 public static Phone remove(long phoneId) 1360 throws com.liferay.portal.exception.NoSuchPhoneException { 1361 return getPersistence().remove(phoneId); 1362 } 1363 1364 public static Phone updateImpl(Phone phone) { 1365 return getPersistence().updateImpl(phone); 1366 } 1367 1368 /** 1369 * Returns the phone with the primary key or throws a {@link NoSuchPhoneException} if it could not be found. 1370 * 1371 * @param phoneId the primary key of the phone 1372 * @return the phone 1373 * @throws NoSuchPhoneException if a phone with the primary key could not be found 1374 */ 1375 public static Phone findByPrimaryKey(long phoneId) 1376 throws com.liferay.portal.exception.NoSuchPhoneException { 1377 return getPersistence().findByPrimaryKey(phoneId); 1378 } 1379 1380 /** 1381 * Returns the phone with the primary key or returns <code>null</code> if it could not be found. 1382 * 1383 * @param phoneId the primary key of the phone 1384 * @return the phone, or <code>null</code> if a phone with the primary key could not be found 1385 */ 1386 public static Phone fetchByPrimaryKey(long phoneId) { 1387 return getPersistence().fetchByPrimaryKey(phoneId); 1388 } 1389 1390 public static java.util.Map<java.io.Serializable, Phone> fetchByPrimaryKeys( 1391 java.util.Set<java.io.Serializable> primaryKeys) { 1392 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1393 } 1394 1395 /** 1396 * Returns all the phones. 1397 * 1398 * @return the phones 1399 */ 1400 public static List<Phone> findAll() { 1401 return getPersistence().findAll(); 1402 } 1403 1404 /** 1405 * Returns a range of all the phones. 1406 * 1407 * <p> 1408 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 1409 * </p> 1410 * 1411 * @param start the lower bound of the range of phones 1412 * @param end the upper bound of the range of phones (not inclusive) 1413 * @return the range of phones 1414 */ 1415 public static List<Phone> findAll(int start, int end) { 1416 return getPersistence().findAll(start, end); 1417 } 1418 1419 /** 1420 * Returns an ordered range of all the phones. 1421 * 1422 * <p> 1423 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 1424 * </p> 1425 * 1426 * @param start the lower bound of the range of phones 1427 * @param end the upper bound of the range of phones (not inclusive) 1428 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1429 * @return the ordered range of phones 1430 */ 1431 public static List<Phone> findAll(int start, int end, 1432 OrderByComparator<Phone> orderByComparator) { 1433 return getPersistence().findAll(start, end, orderByComparator); 1434 } 1435 1436 /** 1437 * Returns an ordered range of all the phones. 1438 * 1439 * <p> 1440 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link PhoneModelImpl}. 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. 1441 * </p> 1442 * 1443 * @param start the lower bound of the range of phones 1444 * @param end the upper bound of the range of phones (not inclusive) 1445 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1446 * @param retrieveFromCache whether to retrieve from the finder cache 1447 * @return the ordered range of phones 1448 */ 1449 public static List<Phone> findAll(int start, int end, 1450 OrderByComparator<Phone> orderByComparator, boolean retrieveFromCache) { 1451 return getPersistence() 1452 .findAll(start, end, orderByComparator, retrieveFromCache); 1453 } 1454 1455 /** 1456 * Removes all the phones from the database. 1457 */ 1458 public static void removeAll() { 1459 getPersistence().removeAll(); 1460 } 1461 1462 /** 1463 * Returns the number of phones. 1464 * 1465 * @return the number of phones 1466 */ 1467 public static int countAll() { 1468 return getPersistence().countAll(); 1469 } 1470 1471 public static java.util.Set<java.lang.String> getBadColumnNames() { 1472 return getPersistence().getBadColumnNames(); 1473 } 1474 1475 public static PhonePersistence getPersistence() { 1476 if (_persistence == null) { 1477 _persistence = (PhonePersistence)PortalBeanLocatorUtil.locate(PhonePersistence.class.getName()); 1478 1479 ReferenceRegistry.registerReference(PhoneUtil.class, "_persistence"); 1480 } 1481 1482 return _persistence; 1483 } 1484 1485 private static PhonePersistence _persistence; 1486 }