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.User;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.Date;
027    import java.util.List;
028    
029    /**
030     * The persistence utility for the user service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserPersistenceImpl} 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.
031     *
032     * <p>
033     * Caching information and settings can be found in <code>portal.properties</code>
034     * </p>
035     *
036     * @author Brian Wing Shun Chan
037     * @see UserPersistence
038     * @see com.liferay.portal.service.persistence.impl.UserPersistenceImpl
039     * @generated
040     */
041    @ProviderType
042    public class UserUtil {
043            /*
044             * NOTE FOR DEVELOPERS:
045             *
046             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
047             */
048    
049            /**
050             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
051             */
052            public static void clearCache() {
053                    getPersistence().clearCache();
054            }
055    
056            /**
057             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
058             */
059            public static void clearCache(User user) {
060                    getPersistence().clearCache(user);
061            }
062    
063            /**
064             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
065             */
066            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
067                    return getPersistence().countWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
072             */
073            public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery,
081                    int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery,
089                    int start, int end, OrderByComparator<User> orderByComparator) {
090                    return getPersistence()
091                                       .findWithDynamicQuery(dynamicQuery, start, end,
092                            orderByComparator);
093            }
094    
095            /**
096             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
097             */
098            public static User update(User user) {
099                    return getPersistence().update(user);
100            }
101    
102            /**
103             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
104             */
105            public static User update(User user, ServiceContext serviceContext) {
106                    return getPersistence().update(user, serviceContext);
107            }
108    
109            /**
110            * Returns all the users where uuid = &#63;.
111            *
112            * @param uuid the uuid
113            * @return the matching users
114            */
115            public static List<User> findByUuid(java.lang.String uuid) {
116                    return getPersistence().findByUuid(uuid);
117            }
118    
119            /**
120            * Returns a range of all the users where uuid = &#63;.
121            *
122            * <p>
123            * 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 UserModelImpl}. 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.
124            * </p>
125            *
126            * @param uuid the uuid
127            * @param start the lower bound of the range of users
128            * @param end the upper bound of the range of users (not inclusive)
129            * @return the range of matching users
130            */
131            public static List<User> findByUuid(java.lang.String uuid, int start,
132                    int end) {
133                    return getPersistence().findByUuid(uuid, start, end);
134            }
135    
136            /**
137            * Returns an ordered range of all the users where uuid = &#63;.
138            *
139            * <p>
140            * 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 UserModelImpl}. 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.
141            * </p>
142            *
143            * @param uuid the uuid
144            * @param start the lower bound of the range of users
145            * @param end the upper bound of the range of users (not inclusive)
146            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
147            * @return the ordered range of matching users
148            */
149            public static List<User> findByUuid(java.lang.String uuid, int start,
150                    int end, OrderByComparator<User> orderByComparator) {
151                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
152            }
153    
154            /**
155            * Returns an ordered range of all the users where uuid = &#63;.
156            *
157            * <p>
158            * 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 UserModelImpl}. 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.
159            * </p>
160            *
161            * @param uuid the uuid
162            * @param start the lower bound of the range of users
163            * @param end the upper bound of the range of users (not inclusive)
164            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
165            * @param retrieveFromCache whether to retrieve from the finder cache
166            * @return the ordered range of matching users
167            */
168            public static List<User> findByUuid(java.lang.String uuid, int start,
169                    int end, OrderByComparator<User> orderByComparator,
170                    boolean retrieveFromCache) {
171                    return getPersistence()
172                                       .findByUuid(uuid, start, end, orderByComparator,
173                            retrieveFromCache);
174            }
175    
176            /**
177            * Returns the first user in the ordered set where uuid = &#63;.
178            *
179            * @param uuid the uuid
180            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
181            * @return the first matching user
182            * @throws NoSuchUserException if a matching user could not be found
183            */
184            public static User findByUuid_First(java.lang.String uuid,
185                    OrderByComparator<User> orderByComparator)
186                    throws com.liferay.portal.exception.NoSuchUserException {
187                    return getPersistence().findByUuid_First(uuid, orderByComparator);
188            }
189    
190            /**
191            * Returns the first user in the ordered set where uuid = &#63;.
192            *
193            * @param uuid the uuid
194            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
195            * @return the first matching user, or <code>null</code> if a matching user could not be found
196            */
197            public static User fetchByUuid_First(java.lang.String uuid,
198                    OrderByComparator<User> orderByComparator) {
199                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
200            }
201    
202            /**
203            * Returns the last user in the ordered set where uuid = &#63;.
204            *
205            * @param uuid the uuid
206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
207            * @return the last matching user
208            * @throws NoSuchUserException if a matching user could not be found
209            */
210            public static User findByUuid_Last(java.lang.String uuid,
211                    OrderByComparator<User> orderByComparator)
212                    throws com.liferay.portal.exception.NoSuchUserException {
213                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
214            }
215    
216            /**
217            * Returns the last user in the ordered set where uuid = &#63;.
218            *
219            * @param uuid the uuid
220            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
221            * @return the last matching user, or <code>null</code> if a matching user could not be found
222            */
223            public static User fetchByUuid_Last(java.lang.String uuid,
224                    OrderByComparator<User> orderByComparator) {
225                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
226            }
227    
228            /**
229            * Returns the users before and after the current user in the ordered set where uuid = &#63;.
230            *
231            * @param userId the primary key of the current user
232            * @param uuid the uuid
233            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
234            * @return the previous, current, and next user
235            * @throws NoSuchUserException if a user with the primary key could not be found
236            */
237            public static User[] findByUuid_PrevAndNext(long userId,
238                    java.lang.String uuid, OrderByComparator<User> orderByComparator)
239                    throws com.liferay.portal.exception.NoSuchUserException {
240                    return getPersistence()
241                                       .findByUuid_PrevAndNext(userId, uuid, orderByComparator);
242            }
243    
244            /**
245            * Removes all the users where uuid = &#63; from the database.
246            *
247            * @param uuid the uuid
248            */
249            public static void removeByUuid(java.lang.String uuid) {
250                    getPersistence().removeByUuid(uuid);
251            }
252    
253            /**
254            * Returns the number of users where uuid = &#63;.
255            *
256            * @param uuid the uuid
257            * @return the number of matching users
258            */
259            public static int countByUuid(java.lang.String uuid) {
260                    return getPersistence().countByUuid(uuid);
261            }
262    
263            /**
264            * Returns all the users where uuid = &#63; and companyId = &#63;.
265            *
266            * @param uuid the uuid
267            * @param companyId the company ID
268            * @return the matching users
269            */
270            public static List<User> findByUuid_C(java.lang.String uuid, long companyId) {
271                    return getPersistence().findByUuid_C(uuid, companyId);
272            }
273    
274            /**
275            * Returns a range of all the users where uuid = &#63; and companyId = &#63;.
276            *
277            * <p>
278            * 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 UserModelImpl}. 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.
279            * </p>
280            *
281            * @param uuid the uuid
282            * @param companyId the company ID
283            * @param start the lower bound of the range of users
284            * @param end the upper bound of the range of users (not inclusive)
285            * @return the range of matching users
286            */
287            public static List<User> findByUuid_C(java.lang.String uuid,
288                    long companyId, int start, int end) {
289                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
290            }
291    
292            /**
293            * Returns an ordered range of all the users where uuid = &#63; and companyId = &#63;.
294            *
295            * <p>
296            * 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 UserModelImpl}. 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.
297            * </p>
298            *
299            * @param uuid the uuid
300            * @param companyId the company ID
301            * @param start the lower bound of the range of users
302            * @param end the upper bound of the range of users (not inclusive)
303            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
304            * @return the ordered range of matching users
305            */
306            public static List<User> findByUuid_C(java.lang.String uuid,
307                    long companyId, int start, int end,
308                    OrderByComparator<User> orderByComparator) {
309                    return getPersistence()
310                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
311            }
312    
313            /**
314            * Returns an ordered range of all the users where uuid = &#63; and companyId = &#63;.
315            *
316            * <p>
317            * 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 UserModelImpl}. 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.
318            * </p>
319            *
320            * @param uuid the uuid
321            * @param companyId the company ID
322            * @param start the lower bound of the range of users
323            * @param end the upper bound of the range of users (not inclusive)
324            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
325            * @param retrieveFromCache whether to retrieve from the finder cache
326            * @return the ordered range of matching users
327            */
328            public static List<User> findByUuid_C(java.lang.String uuid,
329                    long companyId, int start, int end,
330                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
331                    return getPersistence()
332                                       .findByUuid_C(uuid, companyId, start, end,
333                            orderByComparator, retrieveFromCache);
334            }
335    
336            /**
337            * Returns the first user in the ordered set where uuid = &#63; and companyId = &#63;.
338            *
339            * @param uuid the uuid
340            * @param companyId the company ID
341            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
342            * @return the first matching user
343            * @throws NoSuchUserException if a matching user could not be found
344            */
345            public static User findByUuid_C_First(java.lang.String uuid,
346                    long companyId, OrderByComparator<User> orderByComparator)
347                    throws com.liferay.portal.exception.NoSuchUserException {
348                    return getPersistence()
349                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
350            }
351    
352            /**
353            * Returns the first user in the ordered set where uuid = &#63; and companyId = &#63;.
354            *
355            * @param uuid the uuid
356            * @param companyId the company ID
357            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
358            * @return the first matching user, or <code>null</code> if a matching user could not be found
359            */
360            public static User fetchByUuid_C_First(java.lang.String uuid,
361                    long companyId, OrderByComparator<User> orderByComparator) {
362                    return getPersistence()
363                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
364            }
365    
366            /**
367            * Returns the last user in the ordered set where uuid = &#63; and companyId = &#63;.
368            *
369            * @param uuid the uuid
370            * @param companyId the company ID
371            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
372            * @return the last matching user
373            * @throws NoSuchUserException if a matching user could not be found
374            */
375            public static User findByUuid_C_Last(java.lang.String uuid, long companyId,
376                    OrderByComparator<User> orderByComparator)
377                    throws com.liferay.portal.exception.NoSuchUserException {
378                    return getPersistence()
379                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
380            }
381    
382            /**
383            * Returns the last user in the ordered set where uuid = &#63; and companyId = &#63;.
384            *
385            * @param uuid the uuid
386            * @param companyId the company ID
387            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
388            * @return the last matching user, or <code>null</code> if a matching user could not be found
389            */
390            public static User fetchByUuid_C_Last(java.lang.String uuid,
391                    long companyId, OrderByComparator<User> orderByComparator) {
392                    return getPersistence()
393                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
394            }
395    
396            /**
397            * Returns the users before and after the current user in the ordered set where uuid = &#63; and companyId = &#63;.
398            *
399            * @param userId the primary key of the current user
400            * @param uuid the uuid
401            * @param companyId the company ID
402            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
403            * @return the previous, current, and next user
404            * @throws NoSuchUserException if a user with the primary key could not be found
405            */
406            public static User[] findByUuid_C_PrevAndNext(long userId,
407                    java.lang.String uuid, long companyId,
408                    OrderByComparator<User> orderByComparator)
409                    throws com.liferay.portal.exception.NoSuchUserException {
410                    return getPersistence()
411                                       .findByUuid_C_PrevAndNext(userId, uuid, companyId,
412                            orderByComparator);
413            }
414    
415            /**
416            * Removes all the users where uuid = &#63; and companyId = &#63; from the database.
417            *
418            * @param uuid the uuid
419            * @param companyId the company ID
420            */
421            public static void removeByUuid_C(java.lang.String uuid, long companyId) {
422                    getPersistence().removeByUuid_C(uuid, companyId);
423            }
424    
425            /**
426            * Returns the number of users where uuid = &#63; and companyId = &#63;.
427            *
428            * @param uuid the uuid
429            * @param companyId the company ID
430            * @return the number of matching users
431            */
432            public static int countByUuid_C(java.lang.String uuid, long companyId) {
433                    return getPersistence().countByUuid_C(uuid, companyId);
434            }
435    
436            /**
437            * Returns all the users where companyId = &#63;.
438            *
439            * @param companyId the company ID
440            * @return the matching users
441            */
442            public static List<User> findByCompanyId(long companyId) {
443                    return getPersistence().findByCompanyId(companyId);
444            }
445    
446            /**
447            * Returns a range of all the users where companyId = &#63;.
448            *
449            * <p>
450            * 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 UserModelImpl}. 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.
451            * </p>
452            *
453            * @param companyId the company ID
454            * @param start the lower bound of the range of users
455            * @param end the upper bound of the range of users (not inclusive)
456            * @return the range of matching users
457            */
458            public static List<User> findByCompanyId(long companyId, int start, int end) {
459                    return getPersistence().findByCompanyId(companyId, start, end);
460            }
461    
462            /**
463            * Returns an ordered range of all the users where companyId = &#63;.
464            *
465            * <p>
466            * 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 UserModelImpl}. 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.
467            * </p>
468            *
469            * @param companyId the company ID
470            * @param start the lower bound of the range of users
471            * @param end the upper bound of the range of users (not inclusive)
472            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
473            * @return the ordered range of matching users
474            */
475            public static List<User> findByCompanyId(long companyId, int start,
476                    int end, OrderByComparator<User> orderByComparator) {
477                    return getPersistence()
478                                       .findByCompanyId(companyId, start, end, orderByComparator);
479            }
480    
481            /**
482            * Returns an ordered range of all the users where companyId = &#63;.
483            *
484            * <p>
485            * 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 UserModelImpl}. 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.
486            * </p>
487            *
488            * @param companyId the company ID
489            * @param start the lower bound of the range of users
490            * @param end the upper bound of the range of users (not inclusive)
491            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
492            * @param retrieveFromCache whether to retrieve from the finder cache
493            * @return the ordered range of matching users
494            */
495            public static List<User> findByCompanyId(long companyId, int start,
496                    int end, OrderByComparator<User> orderByComparator,
497                    boolean retrieveFromCache) {
498                    return getPersistence()
499                                       .findByCompanyId(companyId, start, end, orderByComparator,
500                            retrieveFromCache);
501            }
502    
503            /**
504            * Returns the first user in the ordered set where companyId = &#63;.
505            *
506            * @param companyId the company ID
507            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
508            * @return the first matching user
509            * @throws NoSuchUserException if a matching user could not be found
510            */
511            public static User findByCompanyId_First(long companyId,
512                    OrderByComparator<User> orderByComparator)
513                    throws com.liferay.portal.exception.NoSuchUserException {
514                    return getPersistence()
515                                       .findByCompanyId_First(companyId, orderByComparator);
516            }
517    
518            /**
519            * Returns the first user in the ordered set where companyId = &#63;.
520            *
521            * @param companyId the company ID
522            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
523            * @return the first matching user, or <code>null</code> if a matching user could not be found
524            */
525            public static User fetchByCompanyId_First(long companyId,
526                    OrderByComparator<User> orderByComparator) {
527                    return getPersistence()
528                                       .fetchByCompanyId_First(companyId, orderByComparator);
529            }
530    
531            /**
532            * Returns the last user in the ordered set where companyId = &#63;.
533            *
534            * @param companyId the company ID
535            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
536            * @return the last matching user
537            * @throws NoSuchUserException if a matching user could not be found
538            */
539            public static User findByCompanyId_Last(long companyId,
540                    OrderByComparator<User> orderByComparator)
541                    throws com.liferay.portal.exception.NoSuchUserException {
542                    return getPersistence()
543                                       .findByCompanyId_Last(companyId, orderByComparator);
544            }
545    
546            /**
547            * Returns the last user in the ordered set where companyId = &#63;.
548            *
549            * @param companyId the company ID
550            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
551            * @return the last matching user, or <code>null</code> if a matching user could not be found
552            */
553            public static User fetchByCompanyId_Last(long companyId,
554                    OrderByComparator<User> orderByComparator) {
555                    return getPersistence()
556                                       .fetchByCompanyId_Last(companyId, orderByComparator);
557            }
558    
559            /**
560            * Returns the users before and after the current user in the ordered set where companyId = &#63;.
561            *
562            * @param userId the primary key of the current user
563            * @param companyId the company ID
564            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
565            * @return the previous, current, and next user
566            * @throws NoSuchUserException if a user with the primary key could not be found
567            */
568            public static User[] findByCompanyId_PrevAndNext(long userId,
569                    long companyId, OrderByComparator<User> orderByComparator)
570                    throws com.liferay.portal.exception.NoSuchUserException {
571                    return getPersistence()
572                                       .findByCompanyId_PrevAndNext(userId, companyId,
573                            orderByComparator);
574            }
575    
576            /**
577            * Removes all the users where companyId = &#63; from the database.
578            *
579            * @param companyId the company ID
580            */
581            public static void removeByCompanyId(long companyId) {
582                    getPersistence().removeByCompanyId(companyId);
583            }
584    
585            /**
586            * Returns the number of users where companyId = &#63;.
587            *
588            * @param companyId the company ID
589            * @return the number of matching users
590            */
591            public static int countByCompanyId(long companyId) {
592                    return getPersistence().countByCompanyId(companyId);
593            }
594    
595            /**
596            * Returns the user where contactId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
597            *
598            * @param contactId the contact ID
599            * @return the matching user
600            * @throws NoSuchUserException if a matching user could not be found
601            */
602            public static User findByContactId(long contactId)
603                    throws com.liferay.portal.exception.NoSuchUserException {
604                    return getPersistence().findByContactId(contactId);
605            }
606    
607            /**
608            * Returns the user where contactId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
609            *
610            * @param contactId the contact ID
611            * @return the matching user, or <code>null</code> if a matching user could not be found
612            */
613            public static User fetchByContactId(long contactId) {
614                    return getPersistence().fetchByContactId(contactId);
615            }
616    
617            /**
618            * Returns the user where contactId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
619            *
620            * @param contactId the contact ID
621            * @param retrieveFromCache whether to retrieve from the finder cache
622            * @return the matching user, or <code>null</code> if a matching user could not be found
623            */
624            public static User fetchByContactId(long contactId,
625                    boolean retrieveFromCache) {
626                    return getPersistence().fetchByContactId(contactId, retrieveFromCache);
627            }
628    
629            /**
630            * Removes the user where contactId = &#63; from the database.
631            *
632            * @param contactId the contact ID
633            * @return the user that was removed
634            */
635            public static User removeByContactId(long contactId)
636                    throws com.liferay.portal.exception.NoSuchUserException {
637                    return getPersistence().removeByContactId(contactId);
638            }
639    
640            /**
641            * Returns the number of users where contactId = &#63;.
642            *
643            * @param contactId the contact ID
644            * @return the number of matching users
645            */
646            public static int countByContactId(long contactId) {
647                    return getPersistence().countByContactId(contactId);
648            }
649    
650            /**
651            * Returns all the users where emailAddress = &#63;.
652            *
653            * @param emailAddress the email address
654            * @return the matching users
655            */
656            public static List<User> findByEmailAddress(java.lang.String emailAddress) {
657                    return getPersistence().findByEmailAddress(emailAddress);
658            }
659    
660            /**
661            * Returns a range of all the users where emailAddress = &#63;.
662            *
663            * <p>
664            * 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 UserModelImpl}. 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.
665            * </p>
666            *
667            * @param emailAddress the email address
668            * @param start the lower bound of the range of users
669            * @param end the upper bound of the range of users (not inclusive)
670            * @return the range of matching users
671            */
672            public static List<User> findByEmailAddress(java.lang.String emailAddress,
673                    int start, int end) {
674                    return getPersistence().findByEmailAddress(emailAddress, start, end);
675            }
676    
677            /**
678            * Returns an ordered range of all the users where emailAddress = &#63;.
679            *
680            * <p>
681            * 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 UserModelImpl}. 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.
682            * </p>
683            *
684            * @param emailAddress the email address
685            * @param start the lower bound of the range of users
686            * @param end the upper bound of the range of users (not inclusive)
687            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
688            * @return the ordered range of matching users
689            */
690            public static List<User> findByEmailAddress(java.lang.String emailAddress,
691                    int start, int end, OrderByComparator<User> orderByComparator) {
692                    return getPersistence()
693                                       .findByEmailAddress(emailAddress, start, end,
694                            orderByComparator);
695            }
696    
697            /**
698            * Returns an ordered range of all the users where emailAddress = &#63;.
699            *
700            * <p>
701            * 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 UserModelImpl}. 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.
702            * </p>
703            *
704            * @param emailAddress the email address
705            * @param start the lower bound of the range of users
706            * @param end the upper bound of the range of users (not inclusive)
707            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
708            * @param retrieveFromCache whether to retrieve from the finder cache
709            * @return the ordered range of matching users
710            */
711            public static List<User> findByEmailAddress(java.lang.String emailAddress,
712                    int start, int end, OrderByComparator<User> orderByComparator,
713                    boolean retrieveFromCache) {
714                    return getPersistence()
715                                       .findByEmailAddress(emailAddress, start, end,
716                            orderByComparator, retrieveFromCache);
717            }
718    
719            /**
720            * Returns the first user in the ordered set where emailAddress = &#63;.
721            *
722            * @param emailAddress the email address
723            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
724            * @return the first matching user
725            * @throws NoSuchUserException if a matching user could not be found
726            */
727            public static User findByEmailAddress_First(java.lang.String emailAddress,
728                    OrderByComparator<User> orderByComparator)
729                    throws com.liferay.portal.exception.NoSuchUserException {
730                    return getPersistence()
731                                       .findByEmailAddress_First(emailAddress, orderByComparator);
732            }
733    
734            /**
735            * Returns the first user in the ordered set where emailAddress = &#63;.
736            *
737            * @param emailAddress the email address
738            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
739            * @return the first matching user, or <code>null</code> if a matching user could not be found
740            */
741            public static User fetchByEmailAddress_First(
742                    java.lang.String emailAddress, OrderByComparator<User> orderByComparator) {
743                    return getPersistence()
744                                       .fetchByEmailAddress_First(emailAddress, orderByComparator);
745            }
746    
747            /**
748            * Returns the last user in the ordered set where emailAddress = &#63;.
749            *
750            * @param emailAddress the email address
751            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
752            * @return the last matching user
753            * @throws NoSuchUserException if a matching user could not be found
754            */
755            public static User findByEmailAddress_Last(java.lang.String emailAddress,
756                    OrderByComparator<User> orderByComparator)
757                    throws com.liferay.portal.exception.NoSuchUserException {
758                    return getPersistence()
759                                       .findByEmailAddress_Last(emailAddress, orderByComparator);
760            }
761    
762            /**
763            * Returns the last user in the ordered set where emailAddress = &#63;.
764            *
765            * @param emailAddress the email address
766            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
767            * @return the last matching user, or <code>null</code> if a matching user could not be found
768            */
769            public static User fetchByEmailAddress_Last(java.lang.String emailAddress,
770                    OrderByComparator<User> orderByComparator) {
771                    return getPersistence()
772                                       .fetchByEmailAddress_Last(emailAddress, orderByComparator);
773            }
774    
775            /**
776            * Returns the users before and after the current user in the ordered set where emailAddress = &#63;.
777            *
778            * @param userId the primary key of the current user
779            * @param emailAddress the email address
780            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
781            * @return the previous, current, and next user
782            * @throws NoSuchUserException if a user with the primary key could not be found
783            */
784            public static User[] findByEmailAddress_PrevAndNext(long userId,
785                    java.lang.String emailAddress, OrderByComparator<User> orderByComparator)
786                    throws com.liferay.portal.exception.NoSuchUserException {
787                    return getPersistence()
788                                       .findByEmailAddress_PrevAndNext(userId, emailAddress,
789                            orderByComparator);
790            }
791    
792            /**
793            * Removes all the users where emailAddress = &#63; from the database.
794            *
795            * @param emailAddress the email address
796            */
797            public static void removeByEmailAddress(java.lang.String emailAddress) {
798                    getPersistence().removeByEmailAddress(emailAddress);
799            }
800    
801            /**
802            * Returns the number of users where emailAddress = &#63;.
803            *
804            * @param emailAddress the email address
805            * @return the number of matching users
806            */
807            public static int countByEmailAddress(java.lang.String emailAddress) {
808                    return getPersistence().countByEmailAddress(emailAddress);
809            }
810    
811            /**
812            * Returns the user where portraitId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
813            *
814            * @param portraitId the portrait ID
815            * @return the matching user
816            * @throws NoSuchUserException if a matching user could not be found
817            */
818            public static User findByPortraitId(long portraitId)
819                    throws com.liferay.portal.exception.NoSuchUserException {
820                    return getPersistence().findByPortraitId(portraitId);
821            }
822    
823            /**
824            * Returns the user where portraitId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
825            *
826            * @param portraitId the portrait ID
827            * @return the matching user, or <code>null</code> if a matching user could not be found
828            */
829            public static User fetchByPortraitId(long portraitId) {
830                    return getPersistence().fetchByPortraitId(portraitId);
831            }
832    
833            /**
834            * Returns the user where portraitId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
835            *
836            * @param portraitId the portrait ID
837            * @param retrieveFromCache whether to retrieve from the finder cache
838            * @return the matching user, or <code>null</code> if a matching user could not be found
839            */
840            public static User fetchByPortraitId(long portraitId,
841                    boolean retrieveFromCache) {
842                    return getPersistence().fetchByPortraitId(portraitId, retrieveFromCache);
843            }
844    
845            /**
846            * Removes the user where portraitId = &#63; from the database.
847            *
848            * @param portraitId the portrait ID
849            * @return the user that was removed
850            */
851            public static User removeByPortraitId(long portraitId)
852                    throws com.liferay.portal.exception.NoSuchUserException {
853                    return getPersistence().removeByPortraitId(portraitId);
854            }
855    
856            /**
857            * Returns the number of users where portraitId = &#63;.
858            *
859            * @param portraitId the portrait ID
860            * @return the number of matching users
861            */
862            public static int countByPortraitId(long portraitId) {
863                    return getPersistence().countByPortraitId(portraitId);
864            }
865    
866            /**
867            * Returns the user where companyId = &#63; and userId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
868            *
869            * @param companyId the company ID
870            * @param userId the user ID
871            * @return the matching user
872            * @throws NoSuchUserException if a matching user could not be found
873            */
874            public static User findByC_U(long companyId, long userId)
875                    throws com.liferay.portal.exception.NoSuchUserException {
876                    return getPersistence().findByC_U(companyId, userId);
877            }
878    
879            /**
880            * Returns the user where companyId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
881            *
882            * @param companyId the company ID
883            * @param userId the user ID
884            * @return the matching user, or <code>null</code> if a matching user could not be found
885            */
886            public static User fetchByC_U(long companyId, long userId) {
887                    return getPersistence().fetchByC_U(companyId, userId);
888            }
889    
890            /**
891            * Returns the user where companyId = &#63; and userId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
892            *
893            * @param companyId the company ID
894            * @param userId the user ID
895            * @param retrieveFromCache whether to retrieve from the finder cache
896            * @return the matching user, or <code>null</code> if a matching user could not be found
897            */
898            public static User fetchByC_U(long companyId, long userId,
899                    boolean retrieveFromCache) {
900                    return getPersistence().fetchByC_U(companyId, userId, retrieveFromCache);
901            }
902    
903            /**
904            * Removes the user where companyId = &#63; and userId = &#63; from the database.
905            *
906            * @param companyId the company ID
907            * @param userId the user ID
908            * @return the user that was removed
909            */
910            public static User removeByC_U(long companyId, long userId)
911                    throws com.liferay.portal.exception.NoSuchUserException {
912                    return getPersistence().removeByC_U(companyId, userId);
913            }
914    
915            /**
916            * Returns the number of users where companyId = &#63; and userId = &#63;.
917            *
918            * @param companyId the company ID
919            * @param userId the user ID
920            * @return the number of matching users
921            */
922            public static int countByC_U(long companyId, long userId) {
923                    return getPersistence().countByC_U(companyId, userId);
924            }
925    
926            /**
927            * Returns all the users where companyId = &#63; and createDate = &#63;.
928            *
929            * @param companyId the company ID
930            * @param createDate the create date
931            * @return the matching users
932            */
933            public static List<User> findByC_CD(long companyId, Date createDate) {
934                    return getPersistence().findByC_CD(companyId, createDate);
935            }
936    
937            /**
938            * Returns a range of all the users where companyId = &#63; and createDate = &#63;.
939            *
940            * <p>
941            * 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 UserModelImpl}. 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.
942            * </p>
943            *
944            * @param companyId the company ID
945            * @param createDate the create date
946            * @param start the lower bound of the range of users
947            * @param end the upper bound of the range of users (not inclusive)
948            * @return the range of matching users
949            */
950            public static List<User> findByC_CD(long companyId, Date createDate,
951                    int start, int end) {
952                    return getPersistence().findByC_CD(companyId, createDate, start, end);
953            }
954    
955            /**
956            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63;.
957            *
958            * <p>
959            * 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 UserModelImpl}. 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.
960            * </p>
961            *
962            * @param companyId the company ID
963            * @param createDate the create date
964            * @param start the lower bound of the range of users
965            * @param end the upper bound of the range of users (not inclusive)
966            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
967            * @return the ordered range of matching users
968            */
969            public static List<User> findByC_CD(long companyId, Date createDate,
970                    int start, int end, OrderByComparator<User> orderByComparator) {
971                    return getPersistence()
972                                       .findByC_CD(companyId, createDate, start, end,
973                            orderByComparator);
974            }
975    
976            /**
977            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63;.
978            *
979            * <p>
980            * 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 UserModelImpl}. 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.
981            * </p>
982            *
983            * @param companyId the company ID
984            * @param createDate the create date
985            * @param start the lower bound of the range of users
986            * @param end the upper bound of the range of users (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 users
990            */
991            public static List<User> findByC_CD(long companyId, Date createDate,
992                    int start, int end, OrderByComparator<User> orderByComparator,
993                    boolean retrieveFromCache) {
994                    return getPersistence()
995                                       .findByC_CD(companyId, createDate, start, end,
996                            orderByComparator, retrieveFromCache);
997            }
998    
999            /**
1000            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63;.
1001            *
1002            * @param companyId the company ID
1003            * @param createDate the create date
1004            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1005            * @return the first matching user
1006            * @throws NoSuchUserException if a matching user could not be found
1007            */
1008            public static User findByC_CD_First(long companyId, Date createDate,
1009                    OrderByComparator<User> orderByComparator)
1010                    throws com.liferay.portal.exception.NoSuchUserException {
1011                    return getPersistence()
1012                                       .findByC_CD_First(companyId, createDate, orderByComparator);
1013            }
1014    
1015            /**
1016            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63;.
1017            *
1018            * @param companyId the company ID
1019            * @param createDate the create date
1020            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1021            * @return the first matching user, or <code>null</code> if a matching user could not be found
1022            */
1023            public static User fetchByC_CD_First(long companyId, Date createDate,
1024                    OrderByComparator<User> orderByComparator) {
1025                    return getPersistence()
1026                                       .fetchByC_CD_First(companyId, createDate, orderByComparator);
1027            }
1028    
1029            /**
1030            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63;.
1031            *
1032            * @param companyId the company ID
1033            * @param createDate the create date
1034            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1035            * @return the last matching user
1036            * @throws NoSuchUserException if a matching user could not be found
1037            */
1038            public static User findByC_CD_Last(long companyId, Date createDate,
1039                    OrderByComparator<User> orderByComparator)
1040                    throws com.liferay.portal.exception.NoSuchUserException {
1041                    return getPersistence()
1042                                       .findByC_CD_Last(companyId, createDate, orderByComparator);
1043            }
1044    
1045            /**
1046            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63;.
1047            *
1048            * @param companyId the company ID
1049            * @param createDate the create date
1050            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1051            * @return the last matching user, or <code>null</code> if a matching user could not be found
1052            */
1053            public static User fetchByC_CD_Last(long companyId, Date createDate,
1054                    OrderByComparator<User> orderByComparator) {
1055                    return getPersistence()
1056                                       .fetchByC_CD_Last(companyId, createDate, orderByComparator);
1057            }
1058    
1059            /**
1060            * Returns the users before and after the current user in the ordered set where companyId = &#63; and createDate = &#63;.
1061            *
1062            * @param userId the primary key of the current user
1063            * @param companyId the company ID
1064            * @param createDate the create date
1065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1066            * @return the previous, current, and next user
1067            * @throws NoSuchUserException if a user with the primary key could not be found
1068            */
1069            public static User[] findByC_CD_PrevAndNext(long userId, long companyId,
1070                    Date createDate, OrderByComparator<User> orderByComparator)
1071                    throws com.liferay.portal.exception.NoSuchUserException {
1072                    return getPersistence()
1073                                       .findByC_CD_PrevAndNext(userId, companyId, createDate,
1074                            orderByComparator);
1075            }
1076    
1077            /**
1078            * Removes all the users where companyId = &#63; and createDate = &#63; from the database.
1079            *
1080            * @param companyId the company ID
1081            * @param createDate the create date
1082            */
1083            public static void removeByC_CD(long companyId, Date createDate) {
1084                    getPersistence().removeByC_CD(companyId, createDate);
1085            }
1086    
1087            /**
1088            * Returns the number of users where companyId = &#63; and createDate = &#63;.
1089            *
1090            * @param companyId the company ID
1091            * @param createDate the create date
1092            * @return the number of matching users
1093            */
1094            public static int countByC_CD(long companyId, Date createDate) {
1095                    return getPersistence().countByC_CD(companyId, createDate);
1096            }
1097    
1098            /**
1099            * Returns all the users where companyId = &#63; and modifiedDate = &#63;.
1100            *
1101            * @param companyId the company ID
1102            * @param modifiedDate the modified date
1103            * @return the matching users
1104            */
1105            public static List<User> findByC_MD(long companyId, Date modifiedDate) {
1106                    return getPersistence().findByC_MD(companyId, modifiedDate);
1107            }
1108    
1109            /**
1110            * Returns a range of all the users where companyId = &#63; and modifiedDate = &#63;.
1111            *
1112            * <p>
1113            * 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 UserModelImpl}. 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.
1114            * </p>
1115            *
1116            * @param companyId the company ID
1117            * @param modifiedDate the modified date
1118            * @param start the lower bound of the range of users
1119            * @param end the upper bound of the range of users (not inclusive)
1120            * @return the range of matching users
1121            */
1122            public static List<User> findByC_MD(long companyId, Date modifiedDate,
1123                    int start, int end) {
1124                    return getPersistence().findByC_MD(companyId, modifiedDate, start, end);
1125            }
1126    
1127            /**
1128            * Returns an ordered range of all the users where companyId = &#63; and modifiedDate = &#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 UserModelImpl}. 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 modifiedDate the modified date
1136            * @param start the lower bound of the range of users
1137            * @param end the upper bound of the range of users (not inclusive)
1138            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1139            * @return the ordered range of matching users
1140            */
1141            public static List<User> findByC_MD(long companyId, Date modifiedDate,
1142                    int start, int end, OrderByComparator<User> orderByComparator) {
1143                    return getPersistence()
1144                                       .findByC_MD(companyId, modifiedDate, start, end,
1145                            orderByComparator);
1146            }
1147    
1148            /**
1149            * Returns an ordered range of all the users where companyId = &#63; and modifiedDate = &#63;.
1150            *
1151            * <p>
1152            * 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 UserModelImpl}. 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.
1153            * </p>
1154            *
1155            * @param companyId the company ID
1156            * @param modifiedDate the modified date
1157            * @param start the lower bound of the range of users
1158            * @param end the upper bound of the range of users (not inclusive)
1159            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1160            * @param retrieveFromCache whether to retrieve from the finder cache
1161            * @return the ordered range of matching users
1162            */
1163            public static List<User> findByC_MD(long companyId, Date modifiedDate,
1164                    int start, int end, OrderByComparator<User> orderByComparator,
1165                    boolean retrieveFromCache) {
1166                    return getPersistence()
1167                                       .findByC_MD(companyId, modifiedDate, start, end,
1168                            orderByComparator, retrieveFromCache);
1169            }
1170    
1171            /**
1172            * Returns the first user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1173            *
1174            * @param companyId the company ID
1175            * @param modifiedDate the modified date
1176            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1177            * @return the first matching user
1178            * @throws NoSuchUserException if a matching user could not be found
1179            */
1180            public static User findByC_MD_First(long companyId, Date modifiedDate,
1181                    OrderByComparator<User> orderByComparator)
1182                    throws com.liferay.portal.exception.NoSuchUserException {
1183                    return getPersistence()
1184                                       .findByC_MD_First(companyId, modifiedDate, orderByComparator);
1185            }
1186    
1187            /**
1188            * Returns the first user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1189            *
1190            * @param companyId the company ID
1191            * @param modifiedDate the modified date
1192            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1193            * @return the first matching user, or <code>null</code> if a matching user could not be found
1194            */
1195            public static User fetchByC_MD_First(long companyId, Date modifiedDate,
1196                    OrderByComparator<User> orderByComparator) {
1197                    return getPersistence()
1198                                       .fetchByC_MD_First(companyId, modifiedDate, orderByComparator);
1199            }
1200    
1201            /**
1202            * Returns the last user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1203            *
1204            * @param companyId the company ID
1205            * @param modifiedDate the modified date
1206            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1207            * @return the last matching user
1208            * @throws NoSuchUserException if a matching user could not be found
1209            */
1210            public static User findByC_MD_Last(long companyId, Date modifiedDate,
1211                    OrderByComparator<User> orderByComparator)
1212                    throws com.liferay.portal.exception.NoSuchUserException {
1213                    return getPersistence()
1214                                       .findByC_MD_Last(companyId, modifiedDate, orderByComparator);
1215            }
1216    
1217            /**
1218            * Returns the last user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1219            *
1220            * @param companyId the company ID
1221            * @param modifiedDate the modified date
1222            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1223            * @return the last matching user, or <code>null</code> if a matching user could not be found
1224            */
1225            public static User fetchByC_MD_Last(long companyId, Date modifiedDate,
1226                    OrderByComparator<User> orderByComparator) {
1227                    return getPersistence()
1228                                       .fetchByC_MD_Last(companyId, modifiedDate, orderByComparator);
1229            }
1230    
1231            /**
1232            * Returns the users before and after the current user in the ordered set where companyId = &#63; and modifiedDate = &#63;.
1233            *
1234            * @param userId the primary key of the current user
1235            * @param companyId the company ID
1236            * @param modifiedDate the modified date
1237            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1238            * @return the previous, current, and next user
1239            * @throws NoSuchUserException if a user with the primary key could not be found
1240            */
1241            public static User[] findByC_MD_PrevAndNext(long userId, long companyId,
1242                    Date modifiedDate, OrderByComparator<User> orderByComparator)
1243                    throws com.liferay.portal.exception.NoSuchUserException {
1244                    return getPersistence()
1245                                       .findByC_MD_PrevAndNext(userId, companyId, modifiedDate,
1246                            orderByComparator);
1247            }
1248    
1249            /**
1250            * Removes all the users where companyId = &#63; and modifiedDate = &#63; from the database.
1251            *
1252            * @param companyId the company ID
1253            * @param modifiedDate the modified date
1254            */
1255            public static void removeByC_MD(long companyId, Date modifiedDate) {
1256                    getPersistence().removeByC_MD(companyId, modifiedDate);
1257            }
1258    
1259            /**
1260            * Returns the number of users where companyId = &#63; and modifiedDate = &#63;.
1261            *
1262            * @param companyId the company ID
1263            * @param modifiedDate the modified date
1264            * @return the number of matching users
1265            */
1266            public static int countByC_MD(long companyId, Date modifiedDate) {
1267                    return getPersistence().countByC_MD(companyId, modifiedDate);
1268            }
1269    
1270            /**
1271            * Returns the user where companyId = &#63; and defaultUser = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1272            *
1273            * @param companyId the company ID
1274            * @param defaultUser the default user
1275            * @return the matching user
1276            * @throws NoSuchUserException if a matching user could not be found
1277            */
1278            public static User findByC_DU(long companyId, boolean defaultUser)
1279                    throws com.liferay.portal.exception.NoSuchUserException {
1280                    return getPersistence().findByC_DU(companyId, defaultUser);
1281            }
1282    
1283            /**
1284            * Returns the user where companyId = &#63; and defaultUser = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1285            *
1286            * @param companyId the company ID
1287            * @param defaultUser the default user
1288            * @return the matching user, or <code>null</code> if a matching user could not be found
1289            */
1290            public static User fetchByC_DU(long companyId, boolean defaultUser) {
1291                    return getPersistence().fetchByC_DU(companyId, defaultUser);
1292            }
1293    
1294            /**
1295            * Returns the user where companyId = &#63; and defaultUser = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1296            *
1297            * @param companyId the company ID
1298            * @param defaultUser the default user
1299            * @param retrieveFromCache whether to retrieve from the finder cache
1300            * @return the matching user, or <code>null</code> if a matching user could not be found
1301            */
1302            public static User fetchByC_DU(long companyId, boolean defaultUser,
1303                    boolean retrieveFromCache) {
1304                    return getPersistence()
1305                                       .fetchByC_DU(companyId, defaultUser, retrieveFromCache);
1306            }
1307    
1308            /**
1309            * Removes the user where companyId = &#63; and defaultUser = &#63; from the database.
1310            *
1311            * @param companyId the company ID
1312            * @param defaultUser the default user
1313            * @return the user that was removed
1314            */
1315            public static User removeByC_DU(long companyId, boolean defaultUser)
1316                    throws com.liferay.portal.exception.NoSuchUserException {
1317                    return getPersistence().removeByC_DU(companyId, defaultUser);
1318            }
1319    
1320            /**
1321            * Returns the number of users where companyId = &#63; and defaultUser = &#63;.
1322            *
1323            * @param companyId the company ID
1324            * @param defaultUser the default user
1325            * @return the number of matching users
1326            */
1327            public static int countByC_DU(long companyId, boolean defaultUser) {
1328                    return getPersistence().countByC_DU(companyId, defaultUser);
1329            }
1330    
1331            /**
1332            * Returns the user where companyId = &#63; and screenName = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1333            *
1334            * @param companyId the company ID
1335            * @param screenName the screen name
1336            * @return the matching user
1337            * @throws NoSuchUserException if a matching user could not be found
1338            */
1339            public static User findByC_SN(long companyId, java.lang.String screenName)
1340                    throws com.liferay.portal.exception.NoSuchUserException {
1341                    return getPersistence().findByC_SN(companyId, screenName);
1342            }
1343    
1344            /**
1345            * Returns the user where companyId = &#63; and screenName = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1346            *
1347            * @param companyId the company ID
1348            * @param screenName the screen name
1349            * @return the matching user, or <code>null</code> if a matching user could not be found
1350            */
1351            public static User fetchByC_SN(long companyId, java.lang.String screenName) {
1352                    return getPersistence().fetchByC_SN(companyId, screenName);
1353            }
1354    
1355            /**
1356            * Returns the user where companyId = &#63; and screenName = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1357            *
1358            * @param companyId the company ID
1359            * @param screenName the screen name
1360            * @param retrieveFromCache whether to retrieve from the finder cache
1361            * @return the matching user, or <code>null</code> if a matching user could not be found
1362            */
1363            public static User fetchByC_SN(long companyId, java.lang.String screenName,
1364                    boolean retrieveFromCache) {
1365                    return getPersistence()
1366                                       .fetchByC_SN(companyId, screenName, retrieveFromCache);
1367            }
1368    
1369            /**
1370            * Removes the user where companyId = &#63; and screenName = &#63; from the database.
1371            *
1372            * @param companyId the company ID
1373            * @param screenName the screen name
1374            * @return the user that was removed
1375            */
1376            public static User removeByC_SN(long companyId, java.lang.String screenName)
1377                    throws com.liferay.portal.exception.NoSuchUserException {
1378                    return getPersistence().removeByC_SN(companyId, screenName);
1379            }
1380    
1381            /**
1382            * Returns the number of users where companyId = &#63; and screenName = &#63;.
1383            *
1384            * @param companyId the company ID
1385            * @param screenName the screen name
1386            * @return the number of matching users
1387            */
1388            public static int countByC_SN(long companyId, java.lang.String screenName) {
1389                    return getPersistence().countByC_SN(companyId, screenName);
1390            }
1391    
1392            /**
1393            * Returns the user where companyId = &#63; and emailAddress = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1394            *
1395            * @param companyId the company ID
1396            * @param emailAddress the email address
1397            * @return the matching user
1398            * @throws NoSuchUserException if a matching user could not be found
1399            */
1400            public static User findByC_EA(long companyId, java.lang.String emailAddress)
1401                    throws com.liferay.portal.exception.NoSuchUserException {
1402                    return getPersistence().findByC_EA(companyId, emailAddress);
1403            }
1404    
1405            /**
1406            * Returns the user where companyId = &#63; and emailAddress = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1407            *
1408            * @param companyId the company ID
1409            * @param emailAddress the email address
1410            * @return the matching user, or <code>null</code> if a matching user could not be found
1411            */
1412            public static User fetchByC_EA(long companyId, java.lang.String emailAddress) {
1413                    return getPersistence().fetchByC_EA(companyId, emailAddress);
1414            }
1415    
1416            /**
1417            * Returns the user where companyId = &#63; and emailAddress = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1418            *
1419            * @param companyId the company ID
1420            * @param emailAddress the email address
1421            * @param retrieveFromCache whether to retrieve from the finder cache
1422            * @return the matching user, or <code>null</code> if a matching user could not be found
1423            */
1424            public static User fetchByC_EA(long companyId,
1425                    java.lang.String emailAddress, boolean retrieveFromCache) {
1426                    return getPersistence()
1427                                       .fetchByC_EA(companyId, emailAddress, retrieveFromCache);
1428            }
1429    
1430            /**
1431            * Removes the user where companyId = &#63; and emailAddress = &#63; from the database.
1432            *
1433            * @param companyId the company ID
1434            * @param emailAddress the email address
1435            * @return the user that was removed
1436            */
1437            public static User removeByC_EA(long companyId,
1438                    java.lang.String emailAddress)
1439                    throws com.liferay.portal.exception.NoSuchUserException {
1440                    return getPersistence().removeByC_EA(companyId, emailAddress);
1441            }
1442    
1443            /**
1444            * Returns the number of users where companyId = &#63; and emailAddress = &#63;.
1445            *
1446            * @param companyId the company ID
1447            * @param emailAddress the email address
1448            * @return the number of matching users
1449            */
1450            public static int countByC_EA(long companyId, java.lang.String emailAddress) {
1451                    return getPersistence().countByC_EA(companyId, emailAddress);
1452            }
1453    
1454            /**
1455            * Returns the user where companyId = &#63; and facebookId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1456            *
1457            * @param companyId the company ID
1458            * @param facebookId the facebook ID
1459            * @return the matching user
1460            * @throws NoSuchUserException if a matching user could not be found
1461            */
1462            public static User findByC_FID(long companyId, long facebookId)
1463                    throws com.liferay.portal.exception.NoSuchUserException {
1464                    return getPersistence().findByC_FID(companyId, facebookId);
1465            }
1466    
1467            /**
1468            * Returns the user where companyId = &#63; and facebookId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1469            *
1470            * @param companyId the company ID
1471            * @param facebookId the facebook ID
1472            * @return the matching user, or <code>null</code> if a matching user could not be found
1473            */
1474            public static User fetchByC_FID(long companyId, long facebookId) {
1475                    return getPersistence().fetchByC_FID(companyId, facebookId);
1476            }
1477    
1478            /**
1479            * Returns the user where companyId = &#63; and facebookId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1480            *
1481            * @param companyId the company ID
1482            * @param facebookId the facebook ID
1483            * @param retrieveFromCache whether to retrieve from the finder cache
1484            * @return the matching user, or <code>null</code> if a matching user could not be found
1485            */
1486            public static User fetchByC_FID(long companyId, long facebookId,
1487                    boolean retrieveFromCache) {
1488                    return getPersistence()
1489                                       .fetchByC_FID(companyId, facebookId, retrieveFromCache);
1490            }
1491    
1492            /**
1493            * Removes the user where companyId = &#63; and facebookId = &#63; from the database.
1494            *
1495            * @param companyId the company ID
1496            * @param facebookId the facebook ID
1497            * @return the user that was removed
1498            */
1499            public static User removeByC_FID(long companyId, long facebookId)
1500                    throws com.liferay.portal.exception.NoSuchUserException {
1501                    return getPersistence().removeByC_FID(companyId, facebookId);
1502            }
1503    
1504            /**
1505            * Returns the number of users where companyId = &#63; and facebookId = &#63;.
1506            *
1507            * @param companyId the company ID
1508            * @param facebookId the facebook ID
1509            * @return the number of matching users
1510            */
1511            public static int countByC_FID(long companyId, long facebookId) {
1512                    return getPersistence().countByC_FID(companyId, facebookId);
1513            }
1514    
1515            /**
1516            * Returns the user where companyId = &#63; and openId = &#63; or throws a {@link NoSuchUserException} if it could not be found.
1517            *
1518            * @param companyId the company ID
1519            * @param openId the open ID
1520            * @return the matching user
1521            * @throws NoSuchUserException if a matching user could not be found
1522            */
1523            public static User findByC_O(long companyId, java.lang.String openId)
1524                    throws com.liferay.portal.exception.NoSuchUserException {
1525                    return getPersistence().findByC_O(companyId, openId);
1526            }
1527    
1528            /**
1529            * Returns the user where companyId = &#63; and openId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1530            *
1531            * @param companyId the company ID
1532            * @param openId the open ID
1533            * @return the matching user, or <code>null</code> if a matching user could not be found
1534            */
1535            public static User fetchByC_O(long companyId, java.lang.String openId) {
1536                    return getPersistence().fetchByC_O(companyId, openId);
1537            }
1538    
1539            /**
1540            * Returns the user where companyId = &#63; and openId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1541            *
1542            * @param companyId the company ID
1543            * @param openId the open ID
1544            * @param retrieveFromCache whether to retrieve from the finder cache
1545            * @return the matching user, or <code>null</code> if a matching user could not be found
1546            */
1547            public static User fetchByC_O(long companyId, java.lang.String openId,
1548                    boolean retrieveFromCache) {
1549                    return getPersistence().fetchByC_O(companyId, openId, retrieveFromCache);
1550            }
1551    
1552            /**
1553            * Removes the user where companyId = &#63; and openId = &#63; from the database.
1554            *
1555            * @param companyId the company ID
1556            * @param openId the open ID
1557            * @return the user that was removed
1558            */
1559            public static User removeByC_O(long companyId, java.lang.String openId)
1560                    throws com.liferay.portal.exception.NoSuchUserException {
1561                    return getPersistence().removeByC_O(companyId, openId);
1562            }
1563    
1564            /**
1565            * Returns the number of users where companyId = &#63; and openId = &#63;.
1566            *
1567            * @param companyId the company ID
1568            * @param openId the open ID
1569            * @return the number of matching users
1570            */
1571            public static int countByC_O(long companyId, java.lang.String openId) {
1572                    return getPersistence().countByC_O(companyId, openId);
1573            }
1574    
1575            /**
1576            * Returns all the users where companyId = &#63; and status = &#63;.
1577            *
1578            * @param companyId the company ID
1579            * @param status the status
1580            * @return the matching users
1581            */
1582            public static List<User> findByC_S(long companyId, int status) {
1583                    return getPersistence().findByC_S(companyId, status);
1584            }
1585    
1586            /**
1587            * Returns a range of all the users where companyId = &#63; and status = &#63;.
1588            *
1589            * <p>
1590            * 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 UserModelImpl}. 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.
1591            * </p>
1592            *
1593            * @param companyId the company ID
1594            * @param status the status
1595            * @param start the lower bound of the range of users
1596            * @param end the upper bound of the range of users (not inclusive)
1597            * @return the range of matching users
1598            */
1599            public static List<User> findByC_S(long companyId, int status, int start,
1600                    int end) {
1601                    return getPersistence().findByC_S(companyId, status, start, end);
1602            }
1603    
1604            /**
1605            * Returns an ordered range of all the users where companyId = &#63; and status = &#63;.
1606            *
1607            * <p>
1608            * 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 UserModelImpl}. 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.
1609            * </p>
1610            *
1611            * @param companyId the company ID
1612            * @param status the status
1613            * @param start the lower bound of the range of users
1614            * @param end the upper bound of the range of users (not inclusive)
1615            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1616            * @return the ordered range of matching users
1617            */
1618            public static List<User> findByC_S(long companyId, int status, int start,
1619                    int end, OrderByComparator<User> orderByComparator) {
1620                    return getPersistence()
1621                                       .findByC_S(companyId, status, start, end, orderByComparator);
1622            }
1623    
1624            /**
1625            * Returns an ordered range of all the users where companyId = &#63; and status = &#63;.
1626            *
1627            * <p>
1628            * 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 UserModelImpl}. 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.
1629            * </p>
1630            *
1631            * @param companyId the company ID
1632            * @param status the status
1633            * @param start the lower bound of the range of users
1634            * @param end the upper bound of the range of users (not inclusive)
1635            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1636            * @param retrieveFromCache whether to retrieve from the finder cache
1637            * @return the ordered range of matching users
1638            */
1639            public static List<User> findByC_S(long companyId, int status, int start,
1640                    int end, OrderByComparator<User> orderByComparator,
1641                    boolean retrieveFromCache) {
1642                    return getPersistence()
1643                                       .findByC_S(companyId, status, start, end, orderByComparator,
1644                            retrieveFromCache);
1645            }
1646    
1647            /**
1648            * Returns the first user in the ordered set where companyId = &#63; and status = &#63;.
1649            *
1650            * @param companyId the company ID
1651            * @param status the status
1652            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1653            * @return the first matching user
1654            * @throws NoSuchUserException if a matching user could not be found
1655            */
1656            public static User findByC_S_First(long companyId, int status,
1657                    OrderByComparator<User> orderByComparator)
1658                    throws com.liferay.portal.exception.NoSuchUserException {
1659                    return getPersistence()
1660                                       .findByC_S_First(companyId, status, orderByComparator);
1661            }
1662    
1663            /**
1664            * Returns the first user in the ordered set where companyId = &#63; and status = &#63;.
1665            *
1666            * @param companyId the company ID
1667            * @param status the status
1668            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1669            * @return the first matching user, or <code>null</code> if a matching user could not be found
1670            */
1671            public static User fetchByC_S_First(long companyId, int status,
1672                    OrderByComparator<User> orderByComparator) {
1673                    return getPersistence()
1674                                       .fetchByC_S_First(companyId, status, orderByComparator);
1675            }
1676    
1677            /**
1678            * Returns the last user in the ordered set where companyId = &#63; and status = &#63;.
1679            *
1680            * @param companyId the company ID
1681            * @param status the status
1682            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1683            * @return the last matching user
1684            * @throws NoSuchUserException if a matching user could not be found
1685            */
1686            public static User findByC_S_Last(long companyId, int status,
1687                    OrderByComparator<User> orderByComparator)
1688                    throws com.liferay.portal.exception.NoSuchUserException {
1689                    return getPersistence()
1690                                       .findByC_S_Last(companyId, status, orderByComparator);
1691            }
1692    
1693            /**
1694            * Returns the last user in the ordered set where companyId = &#63; and status = &#63;.
1695            *
1696            * @param companyId the company ID
1697            * @param status the status
1698            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1699            * @return the last matching user, or <code>null</code> if a matching user could not be found
1700            */
1701            public static User fetchByC_S_Last(long companyId, int status,
1702                    OrderByComparator<User> orderByComparator) {
1703                    return getPersistence()
1704                                       .fetchByC_S_Last(companyId, status, orderByComparator);
1705            }
1706    
1707            /**
1708            * Returns the users before and after the current user in the ordered set where companyId = &#63; and status = &#63;.
1709            *
1710            * @param userId the primary key of the current user
1711            * @param companyId the company ID
1712            * @param status the status
1713            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1714            * @return the previous, current, and next user
1715            * @throws NoSuchUserException if a user with the primary key could not be found
1716            */
1717            public static User[] findByC_S_PrevAndNext(long userId, long companyId,
1718                    int status, OrderByComparator<User> orderByComparator)
1719                    throws com.liferay.portal.exception.NoSuchUserException {
1720                    return getPersistence()
1721                                       .findByC_S_PrevAndNext(userId, companyId, status,
1722                            orderByComparator);
1723            }
1724    
1725            /**
1726            * Removes all the users where companyId = &#63; and status = &#63; from the database.
1727            *
1728            * @param companyId the company ID
1729            * @param status the status
1730            */
1731            public static void removeByC_S(long companyId, int status) {
1732                    getPersistence().removeByC_S(companyId, status);
1733            }
1734    
1735            /**
1736            * Returns the number of users where companyId = &#63; and status = &#63;.
1737            *
1738            * @param companyId the company ID
1739            * @param status the status
1740            * @return the number of matching users
1741            */
1742            public static int countByC_S(long companyId, int status) {
1743                    return getPersistence().countByC_S(companyId, status);
1744            }
1745    
1746            /**
1747            * Returns all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1748            *
1749            * @param companyId the company ID
1750            * @param createDate the create date
1751            * @param modifiedDate the modified date
1752            * @return the matching users
1753            */
1754            public static List<User> findByC_CD_MD(long companyId, Date createDate,
1755                    Date modifiedDate) {
1756                    return getPersistence()
1757                                       .findByC_CD_MD(companyId, createDate, modifiedDate);
1758            }
1759    
1760            /**
1761            * Returns a range of all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1762            *
1763            * <p>
1764            * 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 UserModelImpl}. 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.
1765            * </p>
1766            *
1767            * @param companyId the company ID
1768            * @param createDate the create date
1769            * @param modifiedDate the modified date
1770            * @param start the lower bound of the range of users
1771            * @param end the upper bound of the range of users (not inclusive)
1772            * @return the range of matching users
1773            */
1774            public static List<User> findByC_CD_MD(long companyId, Date createDate,
1775                    Date modifiedDate, int start, int end) {
1776                    return getPersistence()
1777                                       .findByC_CD_MD(companyId, createDate, modifiedDate, start,
1778                            end);
1779            }
1780    
1781            /**
1782            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1783            *
1784            * <p>
1785            * 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 UserModelImpl}. 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.
1786            * </p>
1787            *
1788            * @param companyId the company ID
1789            * @param createDate the create date
1790            * @param modifiedDate the modified date
1791            * @param start the lower bound of the range of users
1792            * @param end the upper bound of the range of users (not inclusive)
1793            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1794            * @return the ordered range of matching users
1795            */
1796            public static List<User> findByC_CD_MD(long companyId, Date createDate,
1797                    Date modifiedDate, int start, int end,
1798                    OrderByComparator<User> orderByComparator) {
1799                    return getPersistence()
1800                                       .findByC_CD_MD(companyId, createDate, modifiedDate, start,
1801                            end, orderByComparator);
1802            }
1803    
1804            /**
1805            * Returns an ordered range of all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1806            *
1807            * <p>
1808            * 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 UserModelImpl}. 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.
1809            * </p>
1810            *
1811            * @param companyId the company ID
1812            * @param createDate the create date
1813            * @param modifiedDate the modified date
1814            * @param start the lower bound of the range of users
1815            * @param end the upper bound of the range of users (not inclusive)
1816            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1817            * @param retrieveFromCache whether to retrieve from the finder cache
1818            * @return the ordered range of matching users
1819            */
1820            public static List<User> findByC_CD_MD(long companyId, Date createDate,
1821                    Date modifiedDate, int start, int end,
1822                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
1823                    return getPersistence()
1824                                       .findByC_CD_MD(companyId, createDate, modifiedDate, start,
1825                            end, orderByComparator, retrieveFromCache);
1826            }
1827    
1828            /**
1829            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1830            *
1831            * @param companyId the company ID
1832            * @param createDate the create date
1833            * @param modifiedDate the modified date
1834            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1835            * @return the first matching user
1836            * @throws NoSuchUserException if a matching user could not be found
1837            */
1838            public static User findByC_CD_MD_First(long companyId, Date createDate,
1839                    Date modifiedDate, OrderByComparator<User> orderByComparator)
1840                    throws com.liferay.portal.exception.NoSuchUserException {
1841                    return getPersistence()
1842                                       .findByC_CD_MD_First(companyId, createDate, modifiedDate,
1843                            orderByComparator);
1844            }
1845    
1846            /**
1847            * Returns the first user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1848            *
1849            * @param companyId the company ID
1850            * @param createDate the create date
1851            * @param modifiedDate the modified date
1852            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1853            * @return the first matching user, or <code>null</code> if a matching user could not be found
1854            */
1855            public static User fetchByC_CD_MD_First(long companyId, Date createDate,
1856                    Date modifiedDate, OrderByComparator<User> orderByComparator) {
1857                    return getPersistence()
1858                                       .fetchByC_CD_MD_First(companyId, createDate, modifiedDate,
1859                            orderByComparator);
1860            }
1861    
1862            /**
1863            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1864            *
1865            * @param companyId the company ID
1866            * @param createDate the create date
1867            * @param modifiedDate the modified date
1868            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1869            * @return the last matching user
1870            * @throws NoSuchUserException if a matching user could not be found
1871            */
1872            public static User findByC_CD_MD_Last(long companyId, Date createDate,
1873                    Date modifiedDate, OrderByComparator<User> orderByComparator)
1874                    throws com.liferay.portal.exception.NoSuchUserException {
1875                    return getPersistence()
1876                                       .findByC_CD_MD_Last(companyId, createDate, modifiedDate,
1877                            orderByComparator);
1878            }
1879    
1880            /**
1881            * Returns the last user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1882            *
1883            * @param companyId the company ID
1884            * @param createDate the create date
1885            * @param modifiedDate the modified date
1886            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1887            * @return the last matching user, or <code>null</code> if a matching user could not be found
1888            */
1889            public static User fetchByC_CD_MD_Last(long companyId, Date createDate,
1890                    Date modifiedDate, OrderByComparator<User> orderByComparator) {
1891                    return getPersistence()
1892                                       .fetchByC_CD_MD_Last(companyId, createDate, modifiedDate,
1893                            orderByComparator);
1894            }
1895    
1896            /**
1897            * Returns the users before and after the current user in the ordered set where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1898            *
1899            * @param userId the primary key of the current user
1900            * @param companyId the company ID
1901            * @param createDate the create date
1902            * @param modifiedDate the modified date
1903            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1904            * @return the previous, current, and next user
1905            * @throws NoSuchUserException if a user with the primary key could not be found
1906            */
1907            public static User[] findByC_CD_MD_PrevAndNext(long userId, long companyId,
1908                    Date createDate, Date modifiedDate,
1909                    OrderByComparator<User> orderByComparator)
1910                    throws com.liferay.portal.exception.NoSuchUserException {
1911                    return getPersistence()
1912                                       .findByC_CD_MD_PrevAndNext(userId, companyId, createDate,
1913                            modifiedDate, orderByComparator);
1914            }
1915    
1916            /**
1917            * Removes all the users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63; from the database.
1918            *
1919            * @param companyId the company ID
1920            * @param createDate the create date
1921            * @param modifiedDate the modified date
1922            */
1923            public static void removeByC_CD_MD(long companyId, Date createDate,
1924                    Date modifiedDate) {
1925                    getPersistence().removeByC_CD_MD(companyId, createDate, modifiedDate);
1926            }
1927    
1928            /**
1929            * Returns the number of users where companyId = &#63; and createDate = &#63; and modifiedDate = &#63;.
1930            *
1931            * @param companyId the company ID
1932            * @param createDate the create date
1933            * @param modifiedDate the modified date
1934            * @return the number of matching users
1935            */
1936            public static int countByC_CD_MD(long companyId, Date createDate,
1937                    Date modifiedDate) {
1938                    return getPersistence()
1939                                       .countByC_CD_MD(companyId, createDate, modifiedDate);
1940            }
1941    
1942            /**
1943            * Returns all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
1944            *
1945            * @param companyId the company ID
1946            * @param defaultUser the default user
1947            * @param status the status
1948            * @return the matching users
1949            */
1950            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
1951                    int status) {
1952                    return getPersistence().findByC_DU_S(companyId, defaultUser, status);
1953            }
1954    
1955            /**
1956            * Returns a range of all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
1957            *
1958            * <p>
1959            * 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 UserModelImpl}. 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.
1960            * </p>
1961            *
1962            * @param companyId the company ID
1963            * @param defaultUser the default user
1964            * @param status the status
1965            * @param start the lower bound of the range of users
1966            * @param end the upper bound of the range of users (not inclusive)
1967            * @return the range of matching users
1968            */
1969            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
1970                    int status, int start, int end) {
1971                    return getPersistence()
1972                                       .findByC_DU_S(companyId, defaultUser, status, start, end);
1973            }
1974    
1975            /**
1976            * Returns an ordered range of all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
1977            *
1978            * <p>
1979            * 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 UserModelImpl}. 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.
1980            * </p>
1981            *
1982            * @param companyId the company ID
1983            * @param defaultUser the default user
1984            * @param status the status
1985            * @param start the lower bound of the range of users
1986            * @param end the upper bound of the range of users (not inclusive)
1987            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1988            * @return the ordered range of matching users
1989            */
1990            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
1991                    int status, int start, int end,
1992                    OrderByComparator<User> orderByComparator) {
1993                    return getPersistence()
1994                                       .findByC_DU_S(companyId, defaultUser, status, start, end,
1995                            orderByComparator);
1996            }
1997    
1998            /**
1999            * Returns an ordered range of all the users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2000            *
2001            * <p>
2002            * 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 UserModelImpl}. 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.
2003            * </p>
2004            *
2005            * @param companyId the company ID
2006            * @param defaultUser the default user
2007            * @param status the status
2008            * @param start the lower bound of the range of users
2009            * @param end the upper bound of the range of users (not inclusive)
2010            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2011            * @param retrieveFromCache whether to retrieve from the finder cache
2012            * @return the ordered range of matching users
2013            */
2014            public static List<User> findByC_DU_S(long companyId, boolean defaultUser,
2015                    int status, int start, int end,
2016                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
2017                    return getPersistence()
2018                                       .findByC_DU_S(companyId, defaultUser, status, start, end,
2019                            orderByComparator, retrieveFromCache);
2020            }
2021    
2022            /**
2023            * Returns the first user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2024            *
2025            * @param companyId the company ID
2026            * @param defaultUser the default user
2027            * @param status the status
2028            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2029            * @return the first matching user
2030            * @throws NoSuchUserException if a matching user could not be found
2031            */
2032            public static User findByC_DU_S_First(long companyId, boolean defaultUser,
2033                    int status, OrderByComparator<User> orderByComparator)
2034                    throws com.liferay.portal.exception.NoSuchUserException {
2035                    return getPersistence()
2036                                       .findByC_DU_S_First(companyId, defaultUser, status,
2037                            orderByComparator);
2038            }
2039    
2040            /**
2041            * Returns the first user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2042            *
2043            * @param companyId the company ID
2044            * @param defaultUser the default user
2045            * @param status the status
2046            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2047            * @return the first matching user, or <code>null</code> if a matching user could not be found
2048            */
2049            public static User fetchByC_DU_S_First(long companyId, boolean defaultUser,
2050                    int status, OrderByComparator<User> orderByComparator) {
2051                    return getPersistence()
2052                                       .fetchByC_DU_S_First(companyId, defaultUser, status,
2053                            orderByComparator);
2054            }
2055    
2056            /**
2057            * Returns the last user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2058            *
2059            * @param companyId the company ID
2060            * @param defaultUser the default user
2061            * @param status the status
2062            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2063            * @return the last matching user
2064            * @throws NoSuchUserException if a matching user could not be found
2065            */
2066            public static User findByC_DU_S_Last(long companyId, boolean defaultUser,
2067                    int status, OrderByComparator<User> orderByComparator)
2068                    throws com.liferay.portal.exception.NoSuchUserException {
2069                    return getPersistence()
2070                                       .findByC_DU_S_Last(companyId, defaultUser, status,
2071                            orderByComparator);
2072            }
2073    
2074            /**
2075            * Returns the last user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2076            *
2077            * @param companyId the company ID
2078            * @param defaultUser the default user
2079            * @param status the status
2080            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2081            * @return the last matching user, or <code>null</code> if a matching user could not be found
2082            */
2083            public static User fetchByC_DU_S_Last(long companyId, boolean defaultUser,
2084                    int status, OrderByComparator<User> orderByComparator) {
2085                    return getPersistence()
2086                                       .fetchByC_DU_S_Last(companyId, defaultUser, status,
2087                            orderByComparator);
2088            }
2089    
2090            /**
2091            * Returns the users before and after the current user in the ordered set where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2092            *
2093            * @param userId the primary key of the current user
2094            * @param companyId the company ID
2095            * @param defaultUser the default user
2096            * @param status the status
2097            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2098            * @return the previous, current, and next user
2099            * @throws NoSuchUserException if a user with the primary key could not be found
2100            */
2101            public static User[] findByC_DU_S_PrevAndNext(long userId, long companyId,
2102                    boolean defaultUser, int status,
2103                    OrderByComparator<User> orderByComparator)
2104                    throws com.liferay.portal.exception.NoSuchUserException {
2105                    return getPersistence()
2106                                       .findByC_DU_S_PrevAndNext(userId, companyId, defaultUser,
2107                            status, orderByComparator);
2108            }
2109    
2110            /**
2111            * Removes all the users where companyId = &#63; and defaultUser = &#63; and status = &#63; from the database.
2112            *
2113            * @param companyId the company ID
2114            * @param defaultUser the default user
2115            * @param status the status
2116            */
2117            public static void removeByC_DU_S(long companyId, boolean defaultUser,
2118                    int status) {
2119                    getPersistence().removeByC_DU_S(companyId, defaultUser, status);
2120            }
2121    
2122            /**
2123            * Returns the number of users where companyId = &#63; and defaultUser = &#63; and status = &#63;.
2124            *
2125            * @param companyId the company ID
2126            * @param defaultUser the default user
2127            * @param status the status
2128            * @return the number of matching users
2129            */
2130            public static int countByC_DU_S(long companyId, boolean defaultUser,
2131                    int status) {
2132                    return getPersistence().countByC_DU_S(companyId, defaultUser, status);
2133            }
2134    
2135            /**
2136            * Caches the user in the entity cache if it is enabled.
2137            *
2138            * @param user the user
2139            */
2140            public static void cacheResult(User user) {
2141                    getPersistence().cacheResult(user);
2142            }
2143    
2144            /**
2145            * Caches the users in the entity cache if it is enabled.
2146            *
2147            * @param users the users
2148            */
2149            public static void cacheResult(List<User> users) {
2150                    getPersistence().cacheResult(users);
2151            }
2152    
2153            /**
2154            * Creates a new user with the primary key. Does not add the user to the database.
2155            *
2156            * @param userId the primary key for the new user
2157            * @return the new user
2158            */
2159            public static User create(long userId) {
2160                    return getPersistence().create(userId);
2161            }
2162    
2163            /**
2164            * Removes the user with the primary key from the database. Also notifies the appropriate model listeners.
2165            *
2166            * @param userId the primary key of the user
2167            * @return the user that was removed
2168            * @throws NoSuchUserException if a user with the primary key could not be found
2169            */
2170            public static User remove(long userId)
2171                    throws com.liferay.portal.exception.NoSuchUserException {
2172                    return getPersistence().remove(userId);
2173            }
2174    
2175            public static User updateImpl(User user) {
2176                    return getPersistence().updateImpl(user);
2177            }
2178    
2179            /**
2180            * Returns the user with the primary key or throws a {@link NoSuchUserException} if it could not be found.
2181            *
2182            * @param userId the primary key of the user
2183            * @return the user
2184            * @throws NoSuchUserException if a user with the primary key could not be found
2185            */
2186            public static User findByPrimaryKey(long userId)
2187                    throws com.liferay.portal.exception.NoSuchUserException {
2188                    return getPersistence().findByPrimaryKey(userId);
2189            }
2190    
2191            /**
2192            * Returns the user with the primary key or returns <code>null</code> if it could not be found.
2193            *
2194            * @param userId the primary key of the user
2195            * @return the user, or <code>null</code> if a user with the primary key could not be found
2196            */
2197            public static User fetchByPrimaryKey(long userId) {
2198                    return getPersistence().fetchByPrimaryKey(userId);
2199            }
2200    
2201            public static java.util.Map<java.io.Serializable, User> fetchByPrimaryKeys(
2202                    java.util.Set<java.io.Serializable> primaryKeys) {
2203                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
2204            }
2205    
2206            /**
2207            * Returns all the users.
2208            *
2209            * @return the users
2210            */
2211            public static List<User> findAll() {
2212                    return getPersistence().findAll();
2213            }
2214    
2215            /**
2216            * Returns a range of all the users.
2217            *
2218            * <p>
2219            * 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 UserModelImpl}. 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.
2220            * </p>
2221            *
2222            * @param start the lower bound of the range of users
2223            * @param end the upper bound of the range of users (not inclusive)
2224            * @return the range of users
2225            */
2226            public static List<User> findAll(int start, int end) {
2227                    return getPersistence().findAll(start, end);
2228            }
2229    
2230            /**
2231            * Returns an ordered range of all the users.
2232            *
2233            * <p>
2234            * 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 UserModelImpl}. 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.
2235            * </p>
2236            *
2237            * @param start the lower bound of the range of users
2238            * @param end the upper bound of the range of users (not inclusive)
2239            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2240            * @return the ordered range of users
2241            */
2242            public static List<User> findAll(int start, int end,
2243                    OrderByComparator<User> orderByComparator) {
2244                    return getPersistence().findAll(start, end, orderByComparator);
2245            }
2246    
2247            /**
2248            * Returns an ordered range of all the users.
2249            *
2250            * <p>
2251            * 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 UserModelImpl}. 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.
2252            * </p>
2253            *
2254            * @param start the lower bound of the range of users
2255            * @param end the upper bound of the range of users (not inclusive)
2256            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2257            * @param retrieveFromCache whether to retrieve from the finder cache
2258            * @return the ordered range of users
2259            */
2260            public static List<User> findAll(int start, int end,
2261                    OrderByComparator<User> orderByComparator, boolean retrieveFromCache) {
2262                    return getPersistence()
2263                                       .findAll(start, end, orderByComparator, retrieveFromCache);
2264            }
2265    
2266            /**
2267            * Removes all the users from the database.
2268            */
2269            public static void removeAll() {
2270                    getPersistence().removeAll();
2271            }
2272    
2273            /**
2274            * Returns the number of users.
2275            *
2276            * @return the number of users
2277            */
2278            public static int countAll() {
2279                    return getPersistence().countAll();
2280            }
2281    
2282            /**
2283            * Returns the primaryKeys of groups associated with the user.
2284            *
2285            * @param pk the primary key of the user
2286            * @return long[] of the primaryKeys of groups associated with the user
2287            */
2288            public static long[] getGroupPrimaryKeys(long pk) {
2289                    return getPersistence().getGroupPrimaryKeys(pk);
2290            }
2291    
2292            /**
2293            * Returns all the groups associated with the user.
2294            *
2295            * @param pk the primary key of the user
2296            * @return the groups associated with the user
2297            */
2298            public static List<com.liferay.portal.model.Group> getGroups(long pk) {
2299                    return getPersistence().getGroups(pk);
2300            }
2301    
2302            /**
2303            * Returns a range of all the groups associated with the user.
2304            *
2305            * <p>
2306            * 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 UserModelImpl}. 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.
2307            * </p>
2308            *
2309            * @param pk the primary key of the user
2310            * @param start the lower bound of the range of users
2311            * @param end the upper bound of the range of users (not inclusive)
2312            * @return the range of groups associated with the user
2313            */
2314            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2315                    int start, int end) {
2316                    return getPersistence().getGroups(pk, start, end);
2317            }
2318    
2319            /**
2320            * Returns an ordered range of all the groups associated with the user.
2321            *
2322            * <p>
2323            * 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 UserModelImpl}. 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.
2324            * </p>
2325            *
2326            * @param pk the primary key of the user
2327            * @param start the lower bound of the range of users
2328            * @param end the upper bound of the range of users (not inclusive)
2329            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2330            * @return the ordered range of groups associated with the user
2331            */
2332            public static List<com.liferay.portal.model.Group> getGroups(long pk,
2333                    int start, int end,
2334                    OrderByComparator<com.liferay.portal.model.Group> orderByComparator) {
2335                    return getPersistence().getGroups(pk, start, end, orderByComparator);
2336            }
2337    
2338            /**
2339            * Returns the number of groups associated with the user.
2340            *
2341            * @param pk the primary key of the user
2342            * @return the number of groups associated with the user
2343            */
2344            public static int getGroupsSize(long pk) {
2345                    return getPersistence().getGroupsSize(pk);
2346            }
2347    
2348            /**
2349            * Returns <code>true</code> if the group is associated with the user.
2350            *
2351            * @param pk the primary key of the user
2352            * @param groupPK the primary key of the group
2353            * @return <code>true</code> if the group is associated with the user; <code>false</code> otherwise
2354            */
2355            public static boolean containsGroup(long pk, long groupPK) {
2356                    return getPersistence().containsGroup(pk, groupPK);
2357            }
2358    
2359            /**
2360            * Returns <code>true</code> if the user has any groups associated with it.
2361            *
2362            * @param pk the primary key of the user to check for associations with groups
2363            * @return <code>true</code> if the user has any groups associated with it; <code>false</code> otherwise
2364            */
2365            public static boolean containsGroups(long pk) {
2366                    return getPersistence().containsGroups(pk);
2367            }
2368    
2369            /**
2370            * Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2371            *
2372            * @param pk the primary key of the user
2373            * @param groupPK the primary key of the group
2374            */
2375            public static void addGroup(long pk, long groupPK) {
2376                    getPersistence().addGroup(pk, groupPK);
2377            }
2378    
2379            /**
2380            * Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2381            *
2382            * @param pk the primary key of the user
2383            * @param group the group
2384            */
2385            public static void addGroup(long pk, com.liferay.portal.model.Group group) {
2386                    getPersistence().addGroup(pk, group);
2387            }
2388    
2389            /**
2390            * Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2391            *
2392            * @param pk the primary key of the user
2393            * @param groupPKs the primary keys of the groups
2394            */
2395            public static void addGroups(long pk, long[] groupPKs) {
2396                    getPersistence().addGroups(pk, groupPKs);
2397            }
2398    
2399            /**
2400            * Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2401            *
2402            * @param pk the primary key of the user
2403            * @param groups the groups
2404            */
2405            public static void addGroups(long pk,
2406                    List<com.liferay.portal.model.Group> groups) {
2407                    getPersistence().addGroups(pk, groups);
2408            }
2409    
2410            /**
2411            * Clears all associations between the user and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2412            *
2413            * @param pk the primary key of the user to clear the associated groups from
2414            */
2415            public static void clearGroups(long pk) {
2416                    getPersistence().clearGroups(pk);
2417            }
2418    
2419            /**
2420            * Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2421            *
2422            * @param pk the primary key of the user
2423            * @param groupPK the primary key of the group
2424            */
2425            public static void removeGroup(long pk, long groupPK) {
2426                    getPersistence().removeGroup(pk, groupPK);
2427            }
2428    
2429            /**
2430            * Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2431            *
2432            * @param pk the primary key of the user
2433            * @param group the group
2434            */
2435            public static void removeGroup(long pk, com.liferay.portal.model.Group group) {
2436                    getPersistence().removeGroup(pk, group);
2437            }
2438    
2439            /**
2440            * Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2441            *
2442            * @param pk the primary key of the user
2443            * @param groupPKs the primary keys of the groups
2444            */
2445            public static void removeGroups(long pk, long[] groupPKs) {
2446                    getPersistence().removeGroups(pk, groupPKs);
2447            }
2448    
2449            /**
2450            * Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2451            *
2452            * @param pk the primary key of the user
2453            * @param groups the groups
2454            */
2455            public static void removeGroups(long pk,
2456                    List<com.liferay.portal.model.Group> groups) {
2457                    getPersistence().removeGroups(pk, groups);
2458            }
2459    
2460            /**
2461            * Sets the groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2462            *
2463            * @param pk the primary key of the user
2464            * @param groupPKs the primary keys of the groups to be associated with the user
2465            */
2466            public static void setGroups(long pk, long[] groupPKs) {
2467                    getPersistence().setGroups(pk, groupPKs);
2468            }
2469    
2470            /**
2471            * Sets the groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2472            *
2473            * @param pk the primary key of the user
2474            * @param groups the groups to be associated with the user
2475            */
2476            public static void setGroups(long pk,
2477                    List<com.liferay.portal.model.Group> groups) {
2478                    getPersistence().setGroups(pk, groups);
2479            }
2480    
2481            /**
2482            * Returns the primaryKeys of organizations associated with the user.
2483            *
2484            * @param pk the primary key of the user
2485            * @return long[] of the primaryKeys of organizations associated with the user
2486            */
2487            public static long[] getOrganizationPrimaryKeys(long pk) {
2488                    return getPersistence().getOrganizationPrimaryKeys(pk);
2489            }
2490    
2491            /**
2492            * Returns all the organizations associated with the user.
2493            *
2494            * @param pk the primary key of the user
2495            * @return the organizations associated with the user
2496            */
2497            public static List<com.liferay.portal.model.Organization> getOrganizations(
2498                    long pk) {
2499                    return getPersistence().getOrganizations(pk);
2500            }
2501    
2502            /**
2503            * Returns a range of all the organizations associated with the user.
2504            *
2505            * <p>
2506            * 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 UserModelImpl}. 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.
2507            * </p>
2508            *
2509            * @param pk the primary key of the user
2510            * @param start the lower bound of the range of users
2511            * @param end the upper bound of the range of users (not inclusive)
2512            * @return the range of organizations associated with the user
2513            */
2514            public static List<com.liferay.portal.model.Organization> getOrganizations(
2515                    long pk, int start, int end) {
2516                    return getPersistence().getOrganizations(pk, start, end);
2517            }
2518    
2519            /**
2520            * Returns an ordered range of all the organizations associated with the user.
2521            *
2522            * <p>
2523            * 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 UserModelImpl}. 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.
2524            * </p>
2525            *
2526            * @param pk the primary key of the user
2527            * @param start the lower bound of the range of users
2528            * @param end the upper bound of the range of users (not inclusive)
2529            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2530            * @return the ordered range of organizations associated with the user
2531            */
2532            public static List<com.liferay.portal.model.Organization> getOrganizations(
2533                    long pk, int start, int end,
2534                    OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) {
2535                    return getPersistence()
2536                                       .getOrganizations(pk, start, end, orderByComparator);
2537            }
2538    
2539            /**
2540            * Returns the number of organizations associated with the user.
2541            *
2542            * @param pk the primary key of the user
2543            * @return the number of organizations associated with the user
2544            */
2545            public static int getOrganizationsSize(long pk) {
2546                    return getPersistence().getOrganizationsSize(pk);
2547            }
2548    
2549            /**
2550            * Returns <code>true</code> if the organization is associated with the user.
2551            *
2552            * @param pk the primary key of the user
2553            * @param organizationPK the primary key of the organization
2554            * @return <code>true</code> if the organization is associated with the user; <code>false</code> otherwise
2555            */
2556            public static boolean containsOrganization(long pk, long organizationPK) {
2557                    return getPersistence().containsOrganization(pk, organizationPK);
2558            }
2559    
2560            /**
2561            * Returns <code>true</code> if the user has any organizations associated with it.
2562            *
2563            * @param pk the primary key of the user to check for associations with organizations
2564            * @return <code>true</code> if the user has any organizations associated with it; <code>false</code> otherwise
2565            */
2566            public static boolean containsOrganizations(long pk) {
2567                    return getPersistence().containsOrganizations(pk);
2568            }
2569    
2570            /**
2571            * Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2572            *
2573            * @param pk the primary key of the user
2574            * @param organizationPK the primary key of the organization
2575            */
2576            public static void addOrganization(long pk, long organizationPK) {
2577                    getPersistence().addOrganization(pk, organizationPK);
2578            }
2579    
2580            /**
2581            * Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2582            *
2583            * @param pk the primary key of the user
2584            * @param organization the organization
2585            */
2586            public static void addOrganization(long pk,
2587                    com.liferay.portal.model.Organization organization) {
2588                    getPersistence().addOrganization(pk, organization);
2589            }
2590    
2591            /**
2592            * Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2593            *
2594            * @param pk the primary key of the user
2595            * @param organizationPKs the primary keys of the organizations
2596            */
2597            public static void addOrganizations(long pk, long[] organizationPKs) {
2598                    getPersistence().addOrganizations(pk, organizationPKs);
2599            }
2600    
2601            /**
2602            * Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2603            *
2604            * @param pk the primary key of the user
2605            * @param organizations the organizations
2606            */
2607            public static void addOrganizations(long pk,
2608                    List<com.liferay.portal.model.Organization> organizations) {
2609                    getPersistence().addOrganizations(pk, organizations);
2610            }
2611    
2612            /**
2613            * Clears all associations between the user and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2614            *
2615            * @param pk the primary key of the user to clear the associated organizations from
2616            */
2617            public static void clearOrganizations(long pk) {
2618                    getPersistence().clearOrganizations(pk);
2619            }
2620    
2621            /**
2622            * Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2623            *
2624            * @param pk the primary key of the user
2625            * @param organizationPK the primary key of the organization
2626            */
2627            public static void removeOrganization(long pk, long organizationPK) {
2628                    getPersistence().removeOrganization(pk, organizationPK);
2629            }
2630    
2631            /**
2632            * Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2633            *
2634            * @param pk the primary key of the user
2635            * @param organization the organization
2636            */
2637            public static void removeOrganization(long pk,
2638                    com.liferay.portal.model.Organization organization) {
2639                    getPersistence().removeOrganization(pk, organization);
2640            }
2641    
2642            /**
2643            * Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2644            *
2645            * @param pk the primary key of the user
2646            * @param organizationPKs the primary keys of the organizations
2647            */
2648            public static void removeOrganizations(long pk, long[] organizationPKs) {
2649                    getPersistence().removeOrganizations(pk, organizationPKs);
2650            }
2651    
2652            /**
2653            * Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2654            *
2655            * @param pk the primary key of the user
2656            * @param organizations the organizations
2657            */
2658            public static void removeOrganizations(long pk,
2659                    List<com.liferay.portal.model.Organization> organizations) {
2660                    getPersistence().removeOrganizations(pk, organizations);
2661            }
2662    
2663            /**
2664            * Sets the organizations associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2665            *
2666            * @param pk the primary key of the user
2667            * @param organizationPKs the primary keys of the organizations to be associated with the user
2668            */
2669            public static void setOrganizations(long pk, long[] organizationPKs) {
2670                    getPersistence().setOrganizations(pk, organizationPKs);
2671            }
2672    
2673            /**
2674            * Sets the organizations associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2675            *
2676            * @param pk the primary key of the user
2677            * @param organizations the organizations to be associated with the user
2678            */
2679            public static void setOrganizations(long pk,
2680                    List<com.liferay.portal.model.Organization> organizations) {
2681                    getPersistence().setOrganizations(pk, organizations);
2682            }
2683    
2684            /**
2685            * Returns the primaryKeys of roles associated with the user.
2686            *
2687            * @param pk the primary key of the user
2688            * @return long[] of the primaryKeys of roles associated with the user
2689            */
2690            public static long[] getRolePrimaryKeys(long pk) {
2691                    return getPersistence().getRolePrimaryKeys(pk);
2692            }
2693    
2694            /**
2695            * Returns all the roles associated with the user.
2696            *
2697            * @param pk the primary key of the user
2698            * @return the roles associated with the user
2699            */
2700            public static List<com.liferay.portal.model.Role> getRoles(long pk) {
2701                    return getPersistence().getRoles(pk);
2702            }
2703    
2704            /**
2705            * Returns a range of all the roles associated with the user.
2706            *
2707            * <p>
2708            * 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 UserModelImpl}. 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.
2709            * </p>
2710            *
2711            * @param pk the primary key of the user
2712            * @param start the lower bound of the range of users
2713            * @param end the upper bound of the range of users (not inclusive)
2714            * @return the range of roles associated with the user
2715            */
2716            public static List<com.liferay.portal.model.Role> getRoles(long pk,
2717                    int start, int end) {
2718                    return getPersistence().getRoles(pk, start, end);
2719            }
2720    
2721            /**
2722            * Returns an ordered range of all the roles associated with the user.
2723            *
2724            * <p>
2725            * 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 UserModelImpl}. 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.
2726            * </p>
2727            *
2728            * @param pk the primary key of the user
2729            * @param start the lower bound of the range of users
2730            * @param end the upper bound of the range of users (not inclusive)
2731            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2732            * @return the ordered range of roles associated with the user
2733            */
2734            public static List<com.liferay.portal.model.Role> getRoles(long pk,
2735                    int start, int end,
2736                    OrderByComparator<com.liferay.portal.model.Role> orderByComparator) {
2737                    return getPersistence().getRoles(pk, start, end, orderByComparator);
2738            }
2739    
2740            /**
2741            * Returns the number of roles associated with the user.
2742            *
2743            * @param pk the primary key of the user
2744            * @return the number of roles associated with the user
2745            */
2746            public static int getRolesSize(long pk) {
2747                    return getPersistence().getRolesSize(pk);
2748            }
2749    
2750            /**
2751            * Returns <code>true</code> if the role is associated with the user.
2752            *
2753            * @param pk the primary key of the user
2754            * @param rolePK the primary key of the role
2755            * @return <code>true</code> if the role is associated with the user; <code>false</code> otherwise
2756            */
2757            public static boolean containsRole(long pk, long rolePK) {
2758                    return getPersistence().containsRole(pk, rolePK);
2759            }
2760    
2761            /**
2762            * Returns <code>true</code> if the user has any roles associated with it.
2763            *
2764            * @param pk the primary key of the user to check for associations with roles
2765            * @return <code>true</code> if the user has any roles associated with it; <code>false</code> otherwise
2766            */
2767            public static boolean containsRoles(long pk) {
2768                    return getPersistence().containsRoles(pk);
2769            }
2770    
2771            /**
2772            * Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2773            *
2774            * @param pk the primary key of the user
2775            * @param rolePK the primary key of the role
2776            */
2777            public static void addRole(long pk, long rolePK) {
2778                    getPersistence().addRole(pk, rolePK);
2779            }
2780    
2781            /**
2782            * Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2783            *
2784            * @param pk the primary key of the user
2785            * @param role the role
2786            */
2787            public static void addRole(long pk, com.liferay.portal.model.Role role) {
2788                    getPersistence().addRole(pk, role);
2789            }
2790    
2791            /**
2792            * Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2793            *
2794            * @param pk the primary key of the user
2795            * @param rolePKs the primary keys of the roles
2796            */
2797            public static void addRoles(long pk, long[] rolePKs) {
2798                    getPersistence().addRoles(pk, rolePKs);
2799            }
2800    
2801            /**
2802            * Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2803            *
2804            * @param pk the primary key of the user
2805            * @param roles the roles
2806            */
2807            public static void addRoles(long pk,
2808                    List<com.liferay.portal.model.Role> roles) {
2809                    getPersistence().addRoles(pk, roles);
2810            }
2811    
2812            /**
2813            * Clears all associations between the user and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2814            *
2815            * @param pk the primary key of the user to clear the associated roles from
2816            */
2817            public static void clearRoles(long pk) {
2818                    getPersistence().clearRoles(pk);
2819            }
2820    
2821            /**
2822            * Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2823            *
2824            * @param pk the primary key of the user
2825            * @param rolePK the primary key of the role
2826            */
2827            public static void removeRole(long pk, long rolePK) {
2828                    getPersistence().removeRole(pk, rolePK);
2829            }
2830    
2831            /**
2832            * Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2833            *
2834            * @param pk the primary key of the user
2835            * @param role the role
2836            */
2837            public static void removeRole(long pk, com.liferay.portal.model.Role role) {
2838                    getPersistence().removeRole(pk, role);
2839            }
2840    
2841            /**
2842            * Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2843            *
2844            * @param pk the primary key of the user
2845            * @param rolePKs the primary keys of the roles
2846            */
2847            public static void removeRoles(long pk, long[] rolePKs) {
2848                    getPersistence().removeRoles(pk, rolePKs);
2849            }
2850    
2851            /**
2852            * Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2853            *
2854            * @param pk the primary key of the user
2855            * @param roles the roles
2856            */
2857            public static void removeRoles(long pk,
2858                    List<com.liferay.portal.model.Role> roles) {
2859                    getPersistence().removeRoles(pk, roles);
2860            }
2861    
2862            /**
2863            * Sets the roles associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2864            *
2865            * @param pk the primary key of the user
2866            * @param rolePKs the primary keys of the roles to be associated with the user
2867            */
2868            public static void setRoles(long pk, long[] rolePKs) {
2869                    getPersistence().setRoles(pk, rolePKs);
2870            }
2871    
2872            /**
2873            * Sets the roles associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2874            *
2875            * @param pk the primary key of the user
2876            * @param roles the roles to be associated with the user
2877            */
2878            public static void setRoles(long pk,
2879                    List<com.liferay.portal.model.Role> roles) {
2880                    getPersistence().setRoles(pk, roles);
2881            }
2882    
2883            /**
2884            * Returns the primaryKeys of teams associated with the user.
2885            *
2886            * @param pk the primary key of the user
2887            * @return long[] of the primaryKeys of teams associated with the user
2888            */
2889            public static long[] getTeamPrimaryKeys(long pk) {
2890                    return getPersistence().getTeamPrimaryKeys(pk);
2891            }
2892    
2893            /**
2894            * Returns all the teams associated with the user.
2895            *
2896            * @param pk the primary key of the user
2897            * @return the teams associated with the user
2898            */
2899            public static List<com.liferay.portal.model.Team> getTeams(long pk) {
2900                    return getPersistence().getTeams(pk);
2901            }
2902    
2903            /**
2904            * Returns a range of all the teams associated with the user.
2905            *
2906            * <p>
2907            * 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 UserModelImpl}. 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.
2908            * </p>
2909            *
2910            * @param pk the primary key of the user
2911            * @param start the lower bound of the range of users
2912            * @param end the upper bound of the range of users (not inclusive)
2913            * @return the range of teams associated with the user
2914            */
2915            public static List<com.liferay.portal.model.Team> getTeams(long pk,
2916                    int start, int end) {
2917                    return getPersistence().getTeams(pk, start, end);
2918            }
2919    
2920            /**
2921            * Returns an ordered range of all the teams associated with the user.
2922            *
2923            * <p>
2924            * 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 UserModelImpl}. 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.
2925            * </p>
2926            *
2927            * @param pk the primary key of the user
2928            * @param start the lower bound of the range of users
2929            * @param end the upper bound of the range of users (not inclusive)
2930            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2931            * @return the ordered range of teams associated with the user
2932            */
2933            public static List<com.liferay.portal.model.Team> getTeams(long pk,
2934                    int start, int end,
2935                    OrderByComparator<com.liferay.portal.model.Team> orderByComparator) {
2936                    return getPersistence().getTeams(pk, start, end, orderByComparator);
2937            }
2938    
2939            /**
2940            * Returns the number of teams associated with the user.
2941            *
2942            * @param pk the primary key of the user
2943            * @return the number of teams associated with the user
2944            */
2945            public static int getTeamsSize(long pk) {
2946                    return getPersistence().getTeamsSize(pk);
2947            }
2948    
2949            /**
2950            * Returns <code>true</code> if the team is associated with the user.
2951            *
2952            * @param pk the primary key of the user
2953            * @param teamPK the primary key of the team
2954            * @return <code>true</code> if the team is associated with the user; <code>false</code> otherwise
2955            */
2956            public static boolean containsTeam(long pk, long teamPK) {
2957                    return getPersistence().containsTeam(pk, teamPK);
2958            }
2959    
2960            /**
2961            * Returns <code>true</code> if the user has any teams associated with it.
2962            *
2963            * @param pk the primary key of the user to check for associations with teams
2964            * @return <code>true</code> if the user has any teams associated with it; <code>false</code> otherwise
2965            */
2966            public static boolean containsTeams(long pk) {
2967                    return getPersistence().containsTeams(pk);
2968            }
2969    
2970            /**
2971            * Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2972            *
2973            * @param pk the primary key of the user
2974            * @param teamPK the primary key of the team
2975            */
2976            public static void addTeam(long pk, long teamPK) {
2977                    getPersistence().addTeam(pk, teamPK);
2978            }
2979    
2980            /**
2981            * Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2982            *
2983            * @param pk the primary key of the user
2984            * @param team the team
2985            */
2986            public static void addTeam(long pk, com.liferay.portal.model.Team team) {
2987                    getPersistence().addTeam(pk, team);
2988            }
2989    
2990            /**
2991            * Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2992            *
2993            * @param pk the primary key of the user
2994            * @param teamPKs the primary keys of the teams
2995            */
2996            public static void addTeams(long pk, long[] teamPKs) {
2997                    getPersistence().addTeams(pk, teamPKs);
2998            }
2999    
3000            /**
3001            * Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3002            *
3003            * @param pk the primary key of the user
3004            * @param teams the teams
3005            */
3006            public static void addTeams(long pk,
3007                    List<com.liferay.portal.model.Team> teams) {
3008                    getPersistence().addTeams(pk, teams);
3009            }
3010    
3011            /**
3012            * Clears all associations between the user and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3013            *
3014            * @param pk the primary key of the user to clear the associated teams from
3015            */
3016            public static void clearTeams(long pk) {
3017                    getPersistence().clearTeams(pk);
3018            }
3019    
3020            /**
3021            * Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3022            *
3023            * @param pk the primary key of the user
3024            * @param teamPK the primary key of the team
3025            */
3026            public static void removeTeam(long pk, long teamPK) {
3027                    getPersistence().removeTeam(pk, teamPK);
3028            }
3029    
3030            /**
3031            * Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3032            *
3033            * @param pk the primary key of the user
3034            * @param team the team
3035            */
3036            public static void removeTeam(long pk, com.liferay.portal.model.Team team) {
3037                    getPersistence().removeTeam(pk, team);
3038            }
3039    
3040            /**
3041            * Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3042            *
3043            * @param pk the primary key of the user
3044            * @param teamPKs the primary keys of the teams
3045            */
3046            public static void removeTeams(long pk, long[] teamPKs) {
3047                    getPersistence().removeTeams(pk, teamPKs);
3048            }
3049    
3050            /**
3051            * Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3052            *
3053            * @param pk the primary key of the user
3054            * @param teams the teams
3055            */
3056            public static void removeTeams(long pk,
3057                    List<com.liferay.portal.model.Team> teams) {
3058                    getPersistence().removeTeams(pk, teams);
3059            }
3060    
3061            /**
3062            * Sets the teams associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3063            *
3064            * @param pk the primary key of the user
3065            * @param teamPKs the primary keys of the teams to be associated with the user
3066            */
3067            public static void setTeams(long pk, long[] teamPKs) {
3068                    getPersistence().setTeams(pk, teamPKs);
3069            }
3070    
3071            /**
3072            * Sets the teams associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3073            *
3074            * @param pk the primary key of the user
3075            * @param teams the teams to be associated with the user
3076            */
3077            public static void setTeams(long pk,
3078                    List<com.liferay.portal.model.Team> teams) {
3079                    getPersistence().setTeams(pk, teams);
3080            }
3081    
3082            /**
3083            * Returns the primaryKeys of user groups associated with the user.
3084            *
3085            * @param pk the primary key of the user
3086            * @return long[] of the primaryKeys of user groups associated with the user
3087            */
3088            public static long[] getUserGroupPrimaryKeys(long pk) {
3089                    return getPersistence().getUserGroupPrimaryKeys(pk);
3090            }
3091    
3092            /**
3093            * Returns all the user groups associated with the user.
3094            *
3095            * @param pk the primary key of the user
3096            * @return the user groups associated with the user
3097            */
3098            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3099                    long pk) {
3100                    return getPersistence().getUserGroups(pk);
3101            }
3102    
3103            /**
3104            * Returns a range of all the user groups associated with the user.
3105            *
3106            * <p>
3107            * 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 UserModelImpl}. 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.
3108            * </p>
3109            *
3110            * @param pk the primary key of the user
3111            * @param start the lower bound of the range of users
3112            * @param end the upper bound of the range of users (not inclusive)
3113            * @return the range of user groups associated with the user
3114            */
3115            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3116                    long pk, int start, int end) {
3117                    return getPersistence().getUserGroups(pk, start, end);
3118            }
3119    
3120            /**
3121            * Returns an ordered range of all the user groups associated with the user.
3122            *
3123            * <p>
3124            * 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 UserModelImpl}. 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.
3125            * </p>
3126            *
3127            * @param pk the primary key of the user
3128            * @param start the lower bound of the range of users
3129            * @param end the upper bound of the range of users (not inclusive)
3130            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3131            * @return the ordered range of user groups associated with the user
3132            */
3133            public static List<com.liferay.portal.model.UserGroup> getUserGroups(
3134                    long pk, int start, int end,
3135                    OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) {
3136                    return getPersistence().getUserGroups(pk, start, end, orderByComparator);
3137            }
3138    
3139            /**
3140            * Returns the number of user groups associated with the user.
3141            *
3142            * @param pk the primary key of the user
3143            * @return the number of user groups associated with the user
3144            */
3145            public static int getUserGroupsSize(long pk) {
3146                    return getPersistence().getUserGroupsSize(pk);
3147            }
3148    
3149            /**
3150            * Returns <code>true</code> if the user group is associated with the user.
3151            *
3152            * @param pk the primary key of the user
3153            * @param userGroupPK the primary key of the user group
3154            * @return <code>true</code> if the user group is associated with the user; <code>false</code> otherwise
3155            */
3156            public static boolean containsUserGroup(long pk, long userGroupPK) {
3157                    return getPersistence().containsUserGroup(pk, userGroupPK);
3158            }
3159    
3160            /**
3161            * Returns <code>true</code> if the user has any user groups associated with it.
3162            *
3163            * @param pk the primary key of the user to check for associations with user groups
3164            * @return <code>true</code> if the user has any user groups associated with it; <code>false</code> otherwise
3165            */
3166            public static boolean containsUserGroups(long pk) {
3167                    return getPersistence().containsUserGroups(pk);
3168            }
3169    
3170            /**
3171            * Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3172            *
3173            * @param pk the primary key of the user
3174            * @param userGroupPK the primary key of the user group
3175            */
3176            public static void addUserGroup(long pk, long userGroupPK) {
3177                    getPersistence().addUserGroup(pk, userGroupPK);
3178            }
3179    
3180            /**
3181            * Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3182            *
3183            * @param pk the primary key of the user
3184            * @param userGroup the user group
3185            */
3186            public static void addUserGroup(long pk,
3187                    com.liferay.portal.model.UserGroup userGroup) {
3188                    getPersistence().addUserGroup(pk, userGroup);
3189            }
3190    
3191            /**
3192            * Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3193            *
3194            * @param pk the primary key of the user
3195            * @param userGroupPKs the primary keys of the user groups
3196            */
3197            public static void addUserGroups(long pk, long[] userGroupPKs) {
3198                    getPersistence().addUserGroups(pk, userGroupPKs);
3199            }
3200    
3201            /**
3202            * Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3203            *
3204            * @param pk the primary key of the user
3205            * @param userGroups the user groups
3206            */
3207            public static void addUserGroups(long pk,
3208                    List<com.liferay.portal.model.UserGroup> userGroups) {
3209                    getPersistence().addUserGroups(pk, userGroups);
3210            }
3211    
3212            /**
3213            * Clears all associations between the user and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3214            *
3215            * @param pk the primary key of the user to clear the associated user groups from
3216            */
3217            public static void clearUserGroups(long pk) {
3218                    getPersistence().clearUserGroups(pk);
3219            }
3220    
3221            /**
3222            * Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3223            *
3224            * @param pk the primary key of the user
3225            * @param userGroupPK the primary key of the user group
3226            */
3227            public static void removeUserGroup(long pk, long userGroupPK) {
3228                    getPersistence().removeUserGroup(pk, userGroupPK);
3229            }
3230    
3231            /**
3232            * Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3233            *
3234            * @param pk the primary key of the user
3235            * @param userGroup the user group
3236            */
3237            public static void removeUserGroup(long pk,
3238                    com.liferay.portal.model.UserGroup userGroup) {
3239                    getPersistence().removeUserGroup(pk, userGroup);
3240            }
3241    
3242            /**
3243            * Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3244            *
3245            * @param pk the primary key of the user
3246            * @param userGroupPKs the primary keys of the user groups
3247            */
3248            public static void removeUserGroups(long pk, long[] userGroupPKs) {
3249                    getPersistence().removeUserGroups(pk, userGroupPKs);
3250            }
3251    
3252            /**
3253            * Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3254            *
3255            * @param pk the primary key of the user
3256            * @param userGroups the user groups
3257            */
3258            public static void removeUserGroups(long pk,
3259                    List<com.liferay.portal.model.UserGroup> userGroups) {
3260                    getPersistence().removeUserGroups(pk, userGroups);
3261            }
3262    
3263            /**
3264            * Sets the user groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3265            *
3266            * @param pk the primary key of the user
3267            * @param userGroupPKs the primary keys of the user groups to be associated with the user
3268            */
3269            public static void setUserGroups(long pk, long[] userGroupPKs) {
3270                    getPersistence().setUserGroups(pk, userGroupPKs);
3271            }
3272    
3273            /**
3274            * Sets the user groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3275            *
3276            * @param pk the primary key of the user
3277            * @param userGroups the user groups to be associated with the user
3278            */
3279            public static void setUserGroups(long pk,
3280                    List<com.liferay.portal.model.UserGroup> userGroups) {
3281                    getPersistence().setUserGroups(pk, userGroups);
3282            }
3283    
3284            public static java.util.Set<java.lang.String> getBadColumnNames() {
3285                    return getPersistence().getBadColumnNames();
3286            }
3287    
3288            public static UserPersistence getPersistence() {
3289                    if (_persistence == null) {
3290                            _persistence = (UserPersistence)PortalBeanLocatorUtil.locate(UserPersistence.class.getName());
3291    
3292                            ReferenceRegistry.registerReference(UserUtil.class, "_persistence");
3293                    }
3294    
3295                    return _persistence;
3296            }
3297    
3298            private static UserPersistence _persistence;
3299    }