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.model.Phone; 020 021 /** 022 * The persistence interface for the phone service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.PhonePersistenceImpl 030 * @see PhoneUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface PhonePersistence extends BasePersistence<Phone> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link PhoneUtil} to access the phone persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the phones where uuid = ?. 043 * 044 * @param uuid the uuid 045 * @return the matching phones 046 */ 047 public java.util.List<Phone> findByUuid(java.lang.String uuid); 048 049 /** 050 * Returns a range of all the phones where uuid = ?. 051 * 052 * <p> 053 * 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. 054 * </p> 055 * 056 * @param uuid the uuid 057 * @param start the lower bound of the range of phones 058 * @param end the upper bound of the range of phones (not inclusive) 059 * @return the range of matching phones 060 */ 061 public java.util.List<Phone> findByUuid(java.lang.String uuid, int start, 062 int end); 063 064 /** 065 * Returns an ordered range of all the phones where uuid = ?. 066 * 067 * <p> 068 * 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. 069 * </p> 070 * 071 * @param uuid the uuid 072 * @param start the lower bound of the range of phones 073 * @param end the upper bound of the range of phones (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching phones 076 */ 077 public java.util.List<Phone> findByUuid(java.lang.String uuid, int start, 078 int end, 079 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 080 081 /** 082 * Returns the first phone in the ordered set where uuid = ?. 083 * 084 * @param uuid the uuid 085 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 086 * @return the first matching phone 087 * @throws NoSuchPhoneException if a matching phone could not be found 088 */ 089 public Phone findByUuid_First(java.lang.String uuid, 090 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 091 throws com.liferay.portal.NoSuchPhoneException; 092 093 /** 094 * Returns the first phone in the ordered set where uuid = ?. 095 * 096 * @param uuid the uuid 097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 098 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 099 */ 100 public Phone fetchByUuid_First(java.lang.String uuid, 101 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 102 103 /** 104 * Returns the last phone in the ordered set where uuid = ?. 105 * 106 * @param uuid the uuid 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the last matching phone 109 * @throws NoSuchPhoneException if a matching phone could not be found 110 */ 111 public Phone findByUuid_Last(java.lang.String uuid, 112 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 113 throws com.liferay.portal.NoSuchPhoneException; 114 115 /** 116 * Returns the last phone in the ordered set where uuid = ?. 117 * 118 * @param uuid the uuid 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 121 */ 122 public Phone fetchByUuid_Last(java.lang.String uuid, 123 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 124 125 /** 126 * Returns the phones before and after the current phone in the ordered set where uuid = ?. 127 * 128 * @param phoneId the primary key of the current phone 129 * @param uuid the uuid 130 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 131 * @return the previous, current, and next phone 132 * @throws NoSuchPhoneException if a phone with the primary key could not be found 133 */ 134 public Phone[] findByUuid_PrevAndNext(long phoneId, java.lang.String uuid, 135 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 136 throws com.liferay.portal.NoSuchPhoneException; 137 138 /** 139 * Removes all the phones where uuid = ? from the database. 140 * 141 * @param uuid the uuid 142 */ 143 public void removeByUuid(java.lang.String uuid); 144 145 /** 146 * Returns the number of phones where uuid = ?. 147 * 148 * @param uuid the uuid 149 * @return the number of matching phones 150 */ 151 public int countByUuid(java.lang.String uuid); 152 153 /** 154 * Returns all the phones where uuid = ? and companyId = ?. 155 * 156 * @param uuid the uuid 157 * @param companyId the company ID 158 * @return the matching phones 159 */ 160 public java.util.List<Phone> findByUuid_C(java.lang.String uuid, 161 long companyId); 162 163 /** 164 * Returns a range of all the phones where uuid = ? and companyId = ?. 165 * 166 * <p> 167 * 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. 168 * </p> 169 * 170 * @param uuid the uuid 171 * @param companyId the company ID 172 * @param start the lower bound of the range of phones 173 * @param end the upper bound of the range of phones (not inclusive) 174 * @return the range of matching phones 175 */ 176 public java.util.List<Phone> findByUuid_C(java.lang.String uuid, 177 long companyId, int start, int end); 178 179 /** 180 * Returns an ordered range of all the phones where uuid = ? and companyId = ?. 181 * 182 * <p> 183 * 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. 184 * </p> 185 * 186 * @param uuid the uuid 187 * @param companyId the company ID 188 * @param start the lower bound of the range of phones 189 * @param end the upper bound of the range of phones (not inclusive) 190 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 191 * @return the ordered range of matching phones 192 */ 193 public java.util.List<Phone> findByUuid_C(java.lang.String uuid, 194 long companyId, int start, int end, 195 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 196 197 /** 198 * Returns the first phone in the ordered set where uuid = ? and companyId = ?. 199 * 200 * @param uuid the uuid 201 * @param companyId the company ID 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the first matching phone 204 * @throws NoSuchPhoneException if a matching phone could not be found 205 */ 206 public Phone findByUuid_C_First(java.lang.String uuid, long companyId, 207 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 208 throws com.liferay.portal.NoSuchPhoneException; 209 210 /** 211 * Returns the first phone in the ordered set where uuid = ? and companyId = ?. 212 * 213 * @param uuid the uuid 214 * @param companyId the company ID 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 217 */ 218 public Phone fetchByUuid_C_First(java.lang.String uuid, long companyId, 219 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 220 221 /** 222 * Returns the last phone in the ordered set where uuid = ? and companyId = ?. 223 * 224 * @param uuid the uuid 225 * @param companyId the company ID 226 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 227 * @return the last matching phone 228 * @throws NoSuchPhoneException if a matching phone could not be found 229 */ 230 public Phone findByUuid_C_Last(java.lang.String uuid, long companyId, 231 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 232 throws com.liferay.portal.NoSuchPhoneException; 233 234 /** 235 * Returns the last phone in the ordered set where uuid = ? and companyId = ?. 236 * 237 * @param uuid the uuid 238 * @param companyId the company ID 239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 240 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 241 */ 242 public Phone fetchByUuid_C_Last(java.lang.String uuid, long companyId, 243 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 244 245 /** 246 * Returns the phones before and after the current phone in the ordered set where uuid = ? and companyId = ?. 247 * 248 * @param phoneId the primary key of the current phone 249 * @param uuid the uuid 250 * @param companyId the company ID 251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 252 * @return the previous, current, and next phone 253 * @throws NoSuchPhoneException if a phone with the primary key could not be found 254 */ 255 public Phone[] findByUuid_C_PrevAndNext(long phoneId, 256 java.lang.String uuid, long companyId, 257 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 258 throws com.liferay.portal.NoSuchPhoneException; 259 260 /** 261 * Removes all the phones where uuid = ? and companyId = ? from the database. 262 * 263 * @param uuid the uuid 264 * @param companyId the company ID 265 */ 266 public void removeByUuid_C(java.lang.String uuid, long companyId); 267 268 /** 269 * Returns the number of phones where uuid = ? and companyId = ?. 270 * 271 * @param uuid the uuid 272 * @param companyId the company ID 273 * @return the number of matching phones 274 */ 275 public int countByUuid_C(java.lang.String uuid, long companyId); 276 277 /** 278 * Returns all the phones where companyId = ?. 279 * 280 * @param companyId the company ID 281 * @return the matching phones 282 */ 283 public java.util.List<Phone> findByCompanyId(long companyId); 284 285 /** 286 * Returns a range of all the phones where companyId = ?. 287 * 288 * <p> 289 * 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. 290 * </p> 291 * 292 * @param companyId the company ID 293 * @param start the lower bound of the range of phones 294 * @param end the upper bound of the range of phones (not inclusive) 295 * @return the range of matching phones 296 */ 297 public java.util.List<Phone> findByCompanyId(long companyId, int start, 298 int end); 299 300 /** 301 * Returns an ordered range of all the phones where companyId = ?. 302 * 303 * <p> 304 * 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. 305 * </p> 306 * 307 * @param companyId the company ID 308 * @param start the lower bound of the range of phones 309 * @param end the upper bound of the range of phones (not inclusive) 310 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 311 * @return the ordered range of matching phones 312 */ 313 public java.util.List<Phone> findByCompanyId(long companyId, int start, 314 int end, 315 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 316 317 /** 318 * Returns the first phone in the ordered set where companyId = ?. 319 * 320 * @param companyId the company ID 321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 322 * @return the first matching phone 323 * @throws NoSuchPhoneException if a matching phone could not be found 324 */ 325 public Phone findByCompanyId_First(long companyId, 326 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 327 throws com.liferay.portal.NoSuchPhoneException; 328 329 /** 330 * Returns the first phone in the ordered set where companyId = ?. 331 * 332 * @param companyId the company ID 333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 334 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 335 */ 336 public Phone fetchByCompanyId_First(long companyId, 337 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 338 339 /** 340 * Returns the last phone in the ordered set where companyId = ?. 341 * 342 * @param companyId the company ID 343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 344 * @return the last matching phone 345 * @throws NoSuchPhoneException if a matching phone could not be found 346 */ 347 public Phone findByCompanyId_Last(long companyId, 348 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 349 throws com.liferay.portal.NoSuchPhoneException; 350 351 /** 352 * Returns the last phone in the ordered set where companyId = ?. 353 * 354 * @param companyId the company ID 355 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 356 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 357 */ 358 public Phone fetchByCompanyId_Last(long companyId, 359 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 360 361 /** 362 * Returns the phones before and after the current phone in the ordered set where companyId = ?. 363 * 364 * @param phoneId the primary key of the current phone 365 * @param companyId the company ID 366 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 367 * @return the previous, current, and next phone 368 * @throws NoSuchPhoneException if a phone with the primary key could not be found 369 */ 370 public Phone[] findByCompanyId_PrevAndNext(long phoneId, long companyId, 371 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 372 throws com.liferay.portal.NoSuchPhoneException; 373 374 /** 375 * Removes all the phones where companyId = ? from the database. 376 * 377 * @param companyId the company ID 378 */ 379 public void removeByCompanyId(long companyId); 380 381 /** 382 * Returns the number of phones where companyId = ?. 383 * 384 * @param companyId the company ID 385 * @return the number of matching phones 386 */ 387 public int countByCompanyId(long companyId); 388 389 /** 390 * Returns all the phones where userId = ?. 391 * 392 * @param userId the user ID 393 * @return the matching phones 394 */ 395 public java.util.List<Phone> findByUserId(long userId); 396 397 /** 398 * Returns a range of all the phones where userId = ?. 399 * 400 * <p> 401 * 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. 402 * </p> 403 * 404 * @param userId the user ID 405 * @param start the lower bound of the range of phones 406 * @param end the upper bound of the range of phones (not inclusive) 407 * @return the range of matching phones 408 */ 409 public java.util.List<Phone> findByUserId(long userId, int start, int end); 410 411 /** 412 * Returns an ordered range of all the phones where userId = ?. 413 * 414 * <p> 415 * 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. 416 * </p> 417 * 418 * @param userId the user ID 419 * @param start the lower bound of the range of phones 420 * @param end the upper bound of the range of phones (not inclusive) 421 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 422 * @return the ordered range of matching phones 423 */ 424 public java.util.List<Phone> findByUserId(long userId, int start, int end, 425 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 426 427 /** 428 * Returns the first phone in the ordered set where userId = ?. 429 * 430 * @param userId the user ID 431 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 432 * @return the first matching phone 433 * @throws NoSuchPhoneException if a matching phone could not be found 434 */ 435 public Phone findByUserId_First(long userId, 436 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 437 throws com.liferay.portal.NoSuchPhoneException; 438 439 /** 440 * Returns the first phone in the ordered set where userId = ?. 441 * 442 * @param userId the user ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 445 */ 446 public Phone fetchByUserId_First(long userId, 447 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 448 449 /** 450 * Returns the last phone in the ordered set where userId = ?. 451 * 452 * @param userId the user ID 453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 454 * @return the last matching phone 455 * @throws NoSuchPhoneException if a matching phone could not be found 456 */ 457 public Phone findByUserId_Last(long userId, 458 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 459 throws com.liferay.portal.NoSuchPhoneException; 460 461 /** 462 * Returns the last phone in the ordered set where userId = ?. 463 * 464 * @param userId the user ID 465 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 466 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 467 */ 468 public Phone fetchByUserId_Last(long userId, 469 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 470 471 /** 472 * Returns the phones before and after the current phone in the ordered set where userId = ?. 473 * 474 * @param phoneId the primary key of the current phone 475 * @param userId the user ID 476 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 477 * @return the previous, current, and next phone 478 * @throws NoSuchPhoneException if a phone with the primary key could not be found 479 */ 480 public Phone[] findByUserId_PrevAndNext(long phoneId, long userId, 481 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 482 throws com.liferay.portal.NoSuchPhoneException; 483 484 /** 485 * Removes all the phones where userId = ? from the database. 486 * 487 * @param userId the user ID 488 */ 489 public void removeByUserId(long userId); 490 491 /** 492 * Returns the number of phones where userId = ?. 493 * 494 * @param userId the user ID 495 * @return the number of matching phones 496 */ 497 public int countByUserId(long userId); 498 499 /** 500 * Returns all the phones where companyId = ? and classNameId = ?. 501 * 502 * @param companyId the company ID 503 * @param classNameId the class name ID 504 * @return the matching phones 505 */ 506 public java.util.List<Phone> findByC_C(long companyId, long classNameId); 507 508 /** 509 * Returns a range of all the phones where companyId = ? and classNameId = ?. 510 * 511 * <p> 512 * 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. 513 * </p> 514 * 515 * @param companyId the company ID 516 * @param classNameId the class name ID 517 * @param start the lower bound of the range of phones 518 * @param end the upper bound of the range of phones (not inclusive) 519 * @return the range of matching phones 520 */ 521 public java.util.List<Phone> findByC_C(long companyId, long classNameId, 522 int start, int end); 523 524 /** 525 * Returns an ordered range of all the phones where companyId = ? and classNameId = ?. 526 * 527 * <p> 528 * 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. 529 * </p> 530 * 531 * @param companyId the company ID 532 * @param classNameId the class name ID 533 * @param start the lower bound of the range of phones 534 * @param end the upper bound of the range of phones (not inclusive) 535 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 536 * @return the ordered range of matching phones 537 */ 538 public java.util.List<Phone> findByC_C(long companyId, long classNameId, 539 int start, int end, 540 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 541 542 /** 543 * Returns the first phone in the ordered set where companyId = ? and classNameId = ?. 544 * 545 * @param companyId the company ID 546 * @param classNameId the class name ID 547 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 548 * @return the first matching phone 549 * @throws NoSuchPhoneException if a matching phone could not be found 550 */ 551 public Phone findByC_C_First(long companyId, long classNameId, 552 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 553 throws com.liferay.portal.NoSuchPhoneException; 554 555 /** 556 * Returns the first phone in the ordered set where companyId = ? and classNameId = ?. 557 * 558 * @param companyId the company ID 559 * @param classNameId the class name ID 560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 561 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 562 */ 563 public Phone fetchByC_C_First(long companyId, long classNameId, 564 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 565 566 /** 567 * Returns the last phone in the ordered set where companyId = ? and classNameId = ?. 568 * 569 * @param companyId the company ID 570 * @param classNameId the class name ID 571 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 572 * @return the last matching phone 573 * @throws NoSuchPhoneException if a matching phone could not be found 574 */ 575 public Phone findByC_C_Last(long companyId, long classNameId, 576 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 577 throws com.liferay.portal.NoSuchPhoneException; 578 579 /** 580 * Returns the last phone in the ordered set where companyId = ? and classNameId = ?. 581 * 582 * @param companyId the company ID 583 * @param classNameId the class name ID 584 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 585 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 586 */ 587 public Phone fetchByC_C_Last(long companyId, long classNameId, 588 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 589 590 /** 591 * Returns the phones before and after the current phone in the ordered set where companyId = ? and classNameId = ?. 592 * 593 * @param phoneId the primary key of the current phone 594 * @param companyId the company ID 595 * @param classNameId the class name ID 596 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 597 * @return the previous, current, and next phone 598 * @throws NoSuchPhoneException if a phone with the primary key could not be found 599 */ 600 public Phone[] findByC_C_PrevAndNext(long phoneId, long companyId, 601 long classNameId, 602 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 603 throws com.liferay.portal.NoSuchPhoneException; 604 605 /** 606 * Removes all the phones where companyId = ? and classNameId = ? from the database. 607 * 608 * @param companyId the company ID 609 * @param classNameId the class name ID 610 */ 611 public void removeByC_C(long companyId, long classNameId); 612 613 /** 614 * Returns the number of phones where companyId = ? and classNameId = ?. 615 * 616 * @param companyId the company ID 617 * @param classNameId the class name ID 618 * @return the number of matching phones 619 */ 620 public int countByC_C(long companyId, long classNameId); 621 622 /** 623 * Returns all the phones where companyId = ? and classNameId = ? and classPK = ?. 624 * 625 * @param companyId the company ID 626 * @param classNameId the class name ID 627 * @param classPK the class p k 628 * @return the matching phones 629 */ 630 public java.util.List<Phone> findByC_C_C(long companyId, long classNameId, 631 long classPK); 632 633 /** 634 * Returns a range of all the phones where companyId = ? and classNameId = ? and classPK = ?. 635 * 636 * <p> 637 * 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. 638 * </p> 639 * 640 * @param companyId the company ID 641 * @param classNameId the class name ID 642 * @param classPK the class p k 643 * @param start the lower bound of the range of phones 644 * @param end the upper bound of the range of phones (not inclusive) 645 * @return the range of matching phones 646 */ 647 public java.util.List<Phone> findByC_C_C(long companyId, long classNameId, 648 long classPK, int start, int end); 649 650 /** 651 * Returns an ordered range of all the phones where companyId = ? and classNameId = ? and classPK = ?. 652 * 653 * <p> 654 * 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. 655 * </p> 656 * 657 * @param companyId the company ID 658 * @param classNameId the class name ID 659 * @param classPK the class p k 660 * @param start the lower bound of the range of phones 661 * @param end the upper bound of the range of phones (not inclusive) 662 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 663 * @return the ordered range of matching phones 664 */ 665 public java.util.List<Phone> findByC_C_C(long companyId, long classNameId, 666 long classPK, int start, int end, 667 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 668 669 /** 670 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 671 * 672 * @param companyId the company ID 673 * @param classNameId the class name ID 674 * @param classPK the class p k 675 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 676 * @return the first matching phone 677 * @throws NoSuchPhoneException if a matching phone could not be found 678 */ 679 public Phone findByC_C_C_First(long companyId, long classNameId, 680 long classPK, 681 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 682 throws com.liferay.portal.NoSuchPhoneException; 683 684 /** 685 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 686 * 687 * @param companyId the company ID 688 * @param classNameId the class name ID 689 * @param classPK the class p k 690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 691 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 692 */ 693 public Phone fetchByC_C_C_First(long companyId, long classNameId, 694 long classPK, 695 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 696 697 /** 698 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 699 * 700 * @param companyId the company ID 701 * @param classNameId the class name ID 702 * @param classPK the class p k 703 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 704 * @return the last matching phone 705 * @throws NoSuchPhoneException if a matching phone could not be found 706 */ 707 public Phone findByC_C_C_Last(long companyId, long classNameId, 708 long classPK, 709 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 710 throws com.liferay.portal.NoSuchPhoneException; 711 712 /** 713 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 714 * 715 * @param companyId the company ID 716 * @param classNameId the class name ID 717 * @param classPK the class p k 718 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 719 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 720 */ 721 public Phone fetchByC_C_C_Last(long companyId, long classNameId, 722 long classPK, 723 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 724 725 /** 726 * Returns the phones before and after the current phone in the ordered set where companyId = ? and classNameId = ? and classPK = ?. 727 * 728 * @param phoneId the primary key of the current phone 729 * @param companyId the company ID 730 * @param classNameId the class name ID 731 * @param classPK the class p k 732 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 733 * @return the previous, current, and next phone 734 * @throws NoSuchPhoneException if a phone with the primary key could not be found 735 */ 736 public Phone[] findByC_C_C_PrevAndNext(long phoneId, long companyId, 737 long classNameId, long classPK, 738 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 739 throws com.liferay.portal.NoSuchPhoneException; 740 741 /** 742 * Removes all the phones where companyId = ? and classNameId = ? and classPK = ? from the database. 743 * 744 * @param companyId the company ID 745 * @param classNameId the class name ID 746 * @param classPK the class p k 747 */ 748 public void removeByC_C_C(long companyId, long classNameId, long classPK); 749 750 /** 751 * Returns the number of phones where companyId = ? and classNameId = ? and classPK = ?. 752 * 753 * @param companyId the company ID 754 * @param classNameId the class name ID 755 * @param classPK the class p k 756 * @return the number of matching phones 757 */ 758 public int countByC_C_C(long companyId, long classNameId, long classPK); 759 760 /** 761 * Returns all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 762 * 763 * @param companyId the company ID 764 * @param classNameId the class name ID 765 * @param classPK the class p k 766 * @param primary the primary 767 * @return the matching phones 768 */ 769 public java.util.List<Phone> findByC_C_C_P(long companyId, 770 long classNameId, long classPK, boolean primary); 771 772 /** 773 * Returns a range of all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 774 * 775 * <p> 776 * 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. 777 * </p> 778 * 779 * @param companyId the company ID 780 * @param classNameId the class name ID 781 * @param classPK the class p k 782 * @param primary the primary 783 * @param start the lower bound of the range of phones 784 * @param end the upper bound of the range of phones (not inclusive) 785 * @return the range of matching phones 786 */ 787 public java.util.List<Phone> findByC_C_C_P(long companyId, 788 long classNameId, long classPK, boolean primary, int start, int end); 789 790 /** 791 * Returns an ordered range of all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 792 * 793 * <p> 794 * 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. 795 * </p> 796 * 797 * @param companyId the company ID 798 * @param classNameId the class name ID 799 * @param classPK the class p k 800 * @param primary the primary 801 * @param start the lower bound of the range of phones 802 * @param end the upper bound of the range of phones (not inclusive) 803 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 804 * @return the ordered range of matching phones 805 */ 806 public java.util.List<Phone> findByC_C_C_P(long companyId, 807 long classNameId, long classPK, boolean primary, int start, int end, 808 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 809 810 /** 811 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 812 * 813 * @param companyId the company ID 814 * @param classNameId the class name ID 815 * @param classPK the class p k 816 * @param primary the primary 817 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 818 * @return the first matching phone 819 * @throws NoSuchPhoneException if a matching phone could not be found 820 */ 821 public Phone findByC_C_C_P_First(long companyId, long classNameId, 822 long classPK, boolean primary, 823 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 824 throws com.liferay.portal.NoSuchPhoneException; 825 826 /** 827 * Returns the first phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 828 * 829 * @param companyId the company ID 830 * @param classNameId the class name ID 831 * @param classPK the class p k 832 * @param primary the primary 833 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 834 * @return the first matching phone, or <code>null</code> if a matching phone could not be found 835 */ 836 public Phone fetchByC_C_C_P_First(long companyId, long classNameId, 837 long classPK, boolean primary, 838 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 839 840 /** 841 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 842 * 843 * @param companyId the company ID 844 * @param classNameId the class name ID 845 * @param classPK the class p k 846 * @param primary the primary 847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 848 * @return the last matching phone 849 * @throws NoSuchPhoneException if a matching phone could not be found 850 */ 851 public Phone findByC_C_C_P_Last(long companyId, long classNameId, 852 long classPK, boolean primary, 853 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 854 throws com.liferay.portal.NoSuchPhoneException; 855 856 /** 857 * Returns the last phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 858 * 859 * @param companyId the company ID 860 * @param classNameId the class name ID 861 * @param classPK the class p k 862 * @param primary the primary 863 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 864 * @return the last matching phone, or <code>null</code> if a matching phone could not be found 865 */ 866 public Phone fetchByC_C_C_P_Last(long companyId, long classNameId, 867 long classPK, boolean primary, 868 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 869 870 /** 871 * Returns the phones before and after the current phone in the ordered set where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 872 * 873 * @param phoneId the primary key of the current phone 874 * @param companyId the company ID 875 * @param classNameId the class name ID 876 * @param classPK the class p k 877 * @param primary the primary 878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 879 * @return the previous, current, and next phone 880 * @throws NoSuchPhoneException if a phone with the primary key could not be found 881 */ 882 public Phone[] findByC_C_C_P_PrevAndNext(long phoneId, long companyId, 883 long classNameId, long classPK, boolean primary, 884 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator) 885 throws com.liferay.portal.NoSuchPhoneException; 886 887 /** 888 * Removes all the phones where companyId = ? and classNameId = ? and classPK = ? and primary = ? from the database. 889 * 890 * @param companyId the company ID 891 * @param classNameId the class name ID 892 * @param classPK the class p k 893 * @param primary the primary 894 */ 895 public void removeByC_C_C_P(long companyId, long classNameId, long classPK, 896 boolean primary); 897 898 /** 899 * Returns the number of phones where companyId = ? and classNameId = ? and classPK = ? and primary = ?. 900 * 901 * @param companyId the company ID 902 * @param classNameId the class name ID 903 * @param classPK the class p k 904 * @param primary the primary 905 * @return the number of matching phones 906 */ 907 public int countByC_C_C_P(long companyId, long classNameId, long classPK, 908 boolean primary); 909 910 /** 911 * Caches the phone in the entity cache if it is enabled. 912 * 913 * @param phone the phone 914 */ 915 public void cacheResult(Phone phone); 916 917 /** 918 * Caches the phones in the entity cache if it is enabled. 919 * 920 * @param phones the phones 921 */ 922 public void cacheResult(java.util.List<Phone> phones); 923 924 /** 925 * Creates a new phone with the primary key. Does not add the phone to the database. 926 * 927 * @param phoneId the primary key for the new phone 928 * @return the new phone 929 */ 930 public Phone create(long phoneId); 931 932 /** 933 * Removes the phone with the primary key from the database. Also notifies the appropriate model listeners. 934 * 935 * @param phoneId the primary key of the phone 936 * @return the phone that was removed 937 * @throws NoSuchPhoneException if a phone with the primary key could not be found 938 */ 939 public Phone remove(long phoneId) 940 throws com.liferay.portal.NoSuchPhoneException; 941 942 public Phone updateImpl(Phone phone); 943 944 /** 945 * Returns the phone with the primary key or throws a {@link NoSuchPhoneException} if it could not be found. 946 * 947 * @param phoneId the primary key of the phone 948 * @return the phone 949 * @throws NoSuchPhoneException if a phone with the primary key could not be found 950 */ 951 public Phone findByPrimaryKey(long phoneId) 952 throws com.liferay.portal.NoSuchPhoneException; 953 954 /** 955 * Returns the phone with the primary key or returns <code>null</code> if it could not be found. 956 * 957 * @param phoneId the primary key of the phone 958 * @return the phone, or <code>null</code> if a phone with the primary key could not be found 959 */ 960 public Phone fetchByPrimaryKey(long phoneId); 961 962 @Override 963 public java.util.Map<java.io.Serializable, Phone> fetchByPrimaryKeys( 964 java.util.Set<java.io.Serializable> primaryKeys); 965 966 /** 967 * Returns all the phones. 968 * 969 * @return the phones 970 */ 971 public java.util.List<Phone> findAll(); 972 973 /** 974 * Returns a range of all the phones. 975 * 976 * <p> 977 * 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. 978 * </p> 979 * 980 * @param start the lower bound of the range of phones 981 * @param end the upper bound of the range of phones (not inclusive) 982 * @return the range of phones 983 */ 984 public java.util.List<Phone> findAll(int start, int end); 985 986 /** 987 * Returns an ordered range of all the phones. 988 * 989 * <p> 990 * 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. 991 * </p> 992 * 993 * @param start the lower bound of the range of phones 994 * @param end the upper bound of the range of phones (not inclusive) 995 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 996 * @return the ordered range of phones 997 */ 998 public java.util.List<Phone> findAll(int start, int end, 999 com.liferay.portal.kernel.util.OrderByComparator<Phone> orderByComparator); 1000 1001 /** 1002 * Removes all the phones from the database. 1003 */ 1004 public void removeAll(); 1005 1006 /** 1007 * Returns the number of phones. 1008 * 1009 * @return the number of phones 1010 */ 1011 public int countAll(); 1012 }