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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63;.
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 = &#63; and companyId = &#63; 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 = &#63; and companyId = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63; 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 = &#63; and classNameId = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63; 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 = &#63; and classNameId = &#63; and classPK = &#63; and primary = &#63;.
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    }