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.portlet.mobiledevicerules.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.service.ServiceContext; 024 025 import com.liferay.portlet.mobiledevicerules.model.MDRRuleGroup; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the m d r rule group service. This utility wraps {@link com.liferay.portlet.mobiledevicerules.service.persistence.impl.MDRRuleGroupPersistenceImpl} 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 Edward C. Han 037 * @see MDRRuleGroupPersistence 038 * @see com.liferay.portlet.mobiledevicerules.service.persistence.impl.MDRRuleGroupPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class MDRRuleGroupUtil { 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(MDRRuleGroup mdrRuleGroup) { 060 getPersistence().clearCache(mdrRuleGroup); 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<MDRRuleGroup> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<MDRRuleGroup> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<MDRRuleGroup> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<MDRRuleGroup> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static MDRRuleGroup update(MDRRuleGroup mdrRuleGroup) { 101 return getPersistence().update(mdrRuleGroup); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static MDRRuleGroup update(MDRRuleGroup mdrRuleGroup, 108 ServiceContext serviceContext) { 109 return getPersistence().update(mdrRuleGroup, serviceContext); 110 } 111 112 /** 113 * Returns all the m d r rule groups where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching m d r rule groups 117 */ 118 public static List<MDRRuleGroup> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the m d r rule groups where uuid = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 MDRRuleGroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of m d r rule groups 131 * @param end the upper bound of the range of m d r rule groups (not inclusive) 132 * @return the range of matching m d r rule groups 133 */ 134 public static List<MDRRuleGroup> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the m d r rule groups where uuid = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 MDRRuleGroupModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of m d r rule groups 148 * @param end the upper bound of the range of m d r rule groups (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching m d r rule groups 151 */ 152 public static List<MDRRuleGroup> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<MDRRuleGroup> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first m d r rule group in the ordered set where uuid = ?. 159 * 160 * @param uuid the uuid 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching m d r rule group 163 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 164 */ 165 public static MDRRuleGroup findByUuid_First(java.lang.String uuid, 166 OrderByComparator<MDRRuleGroup> orderByComparator) 167 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 168 return getPersistence().findByUuid_First(uuid, orderByComparator); 169 } 170 171 /** 172 * Returns the first m d r rule group in the ordered set where uuid = ?. 173 * 174 * @param uuid the uuid 175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 176 * @return the first matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 177 */ 178 public static MDRRuleGroup fetchByUuid_First(java.lang.String uuid, 179 OrderByComparator<MDRRuleGroup> orderByComparator) { 180 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the last m d r rule group in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the last matching m d r rule group 189 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 190 */ 191 public static MDRRuleGroup findByUuid_Last(java.lang.String uuid, 192 OrderByComparator<MDRRuleGroup> orderByComparator) 193 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 194 return getPersistence().findByUuid_Last(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last m d r rule group in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 203 */ 204 public static MDRRuleGroup fetchByUuid_Last(java.lang.String uuid, 205 OrderByComparator<MDRRuleGroup> orderByComparator) { 206 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 207 } 208 209 /** 210 * Returns the m d r rule groups before and after the current m d r rule group in the ordered set where uuid = ?. 211 * 212 * @param ruleGroupId the primary key of the current m d r rule group 213 * @param uuid the uuid 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next m d r rule group 216 * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found 217 */ 218 public static MDRRuleGroup[] findByUuid_PrevAndNext(long ruleGroupId, 219 java.lang.String uuid, OrderByComparator<MDRRuleGroup> orderByComparator) 220 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 221 return getPersistence() 222 .findByUuid_PrevAndNext(ruleGroupId, uuid, orderByComparator); 223 } 224 225 /** 226 * Removes all the m d r rule groups where uuid = ? from the database. 227 * 228 * @param uuid the uuid 229 */ 230 public static void removeByUuid(java.lang.String uuid) { 231 getPersistence().removeByUuid(uuid); 232 } 233 234 /** 235 * Returns the number of m d r rule groups where uuid = ?. 236 * 237 * @param uuid the uuid 238 * @return the number of matching m d r rule groups 239 */ 240 public static int countByUuid(java.lang.String uuid) { 241 return getPersistence().countByUuid(uuid); 242 } 243 244 /** 245 * Returns the m d r rule group where uuid = ? and groupId = ? or throws a {@link NoSuchRuleGroupException} if it could not be found. 246 * 247 * @param uuid the uuid 248 * @param groupId the group ID 249 * @return the matching m d r rule group 250 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 251 */ 252 public static MDRRuleGroup findByUUID_G(java.lang.String uuid, long groupId) 253 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 254 return getPersistence().findByUUID_G(uuid, groupId); 255 } 256 257 /** 258 * Returns the m d r rule group where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 259 * 260 * @param uuid the uuid 261 * @param groupId the group ID 262 * @return the matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 263 */ 264 public static MDRRuleGroup fetchByUUID_G(java.lang.String uuid, long groupId) { 265 return getPersistence().fetchByUUID_G(uuid, groupId); 266 } 267 268 /** 269 * Returns the m d r rule group where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 270 * 271 * @param uuid the uuid 272 * @param groupId the group ID 273 * @param retrieveFromCache whether to use the finder cache 274 * @return the matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 275 */ 276 public static MDRRuleGroup fetchByUUID_G(java.lang.String uuid, 277 long groupId, boolean retrieveFromCache) { 278 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 279 } 280 281 /** 282 * Removes the m d r rule group where uuid = ? and groupId = ? from the database. 283 * 284 * @param uuid the uuid 285 * @param groupId the group ID 286 * @return the m d r rule group that was removed 287 */ 288 public static MDRRuleGroup removeByUUID_G(java.lang.String uuid, 289 long groupId) 290 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 291 return getPersistence().removeByUUID_G(uuid, groupId); 292 } 293 294 /** 295 * Returns the number of m d r rule groups where uuid = ? and groupId = ?. 296 * 297 * @param uuid the uuid 298 * @param groupId the group ID 299 * @return the number of matching m d r rule groups 300 */ 301 public static int countByUUID_G(java.lang.String uuid, long groupId) { 302 return getPersistence().countByUUID_G(uuid, groupId); 303 } 304 305 /** 306 * Returns all the m d r rule groups where uuid = ? and companyId = ?. 307 * 308 * @param uuid the uuid 309 * @param companyId the company ID 310 * @return the matching m d r rule groups 311 */ 312 public static List<MDRRuleGroup> findByUuid_C(java.lang.String uuid, 313 long companyId) { 314 return getPersistence().findByUuid_C(uuid, companyId); 315 } 316 317 /** 318 * Returns a range of all the m d r rule groups where uuid = ? and companyId = ?. 319 * 320 * <p> 321 * 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 MDRRuleGroupModelImpl}. 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. 322 * </p> 323 * 324 * @param uuid the uuid 325 * @param companyId the company ID 326 * @param start the lower bound of the range of m d r rule groups 327 * @param end the upper bound of the range of m d r rule groups (not inclusive) 328 * @return the range of matching m d r rule groups 329 */ 330 public static List<MDRRuleGroup> findByUuid_C(java.lang.String uuid, 331 long companyId, int start, int end) { 332 return getPersistence().findByUuid_C(uuid, companyId, start, end); 333 } 334 335 /** 336 * Returns an ordered range of all the m d r rule groups where uuid = ? and companyId = ?. 337 * 338 * <p> 339 * 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 MDRRuleGroupModelImpl}. 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. 340 * </p> 341 * 342 * @param uuid the uuid 343 * @param companyId the company ID 344 * @param start the lower bound of the range of m d r rule groups 345 * @param end the upper bound of the range of m d r rule groups (not inclusive) 346 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 347 * @return the ordered range of matching m d r rule groups 348 */ 349 public static List<MDRRuleGroup> findByUuid_C(java.lang.String uuid, 350 long companyId, int start, int end, 351 OrderByComparator<MDRRuleGroup> orderByComparator) { 352 return getPersistence() 353 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 354 } 355 356 /** 357 * Returns the first m d r rule group in the ordered set where uuid = ? and companyId = ?. 358 * 359 * @param uuid the uuid 360 * @param companyId the company ID 361 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 362 * @return the first matching m d r rule group 363 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 364 */ 365 public static MDRRuleGroup findByUuid_C_First(java.lang.String uuid, 366 long companyId, OrderByComparator<MDRRuleGroup> orderByComparator) 367 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 368 return getPersistence() 369 .findByUuid_C_First(uuid, companyId, orderByComparator); 370 } 371 372 /** 373 * Returns the first m d r rule group in the ordered set where uuid = ? and companyId = ?. 374 * 375 * @param uuid the uuid 376 * @param companyId the company ID 377 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 378 * @return the first matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 379 */ 380 public static MDRRuleGroup fetchByUuid_C_First(java.lang.String uuid, 381 long companyId, OrderByComparator<MDRRuleGroup> orderByComparator) { 382 return getPersistence() 383 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 384 } 385 386 /** 387 * Returns the last m d r rule group in the ordered set where uuid = ? and companyId = ?. 388 * 389 * @param uuid the uuid 390 * @param companyId the company ID 391 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 392 * @return the last matching m d r rule group 393 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 394 */ 395 public static MDRRuleGroup findByUuid_C_Last(java.lang.String uuid, 396 long companyId, OrderByComparator<MDRRuleGroup> orderByComparator) 397 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 398 return getPersistence() 399 .findByUuid_C_Last(uuid, companyId, orderByComparator); 400 } 401 402 /** 403 * Returns the last m d r rule group in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the last matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 409 */ 410 public static MDRRuleGroup fetchByUuid_C_Last(java.lang.String uuid, 411 long companyId, OrderByComparator<MDRRuleGroup> orderByComparator) { 412 return getPersistence() 413 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 414 } 415 416 /** 417 * Returns the m d r rule groups before and after the current m d r rule group in the ordered set where uuid = ? and companyId = ?. 418 * 419 * @param ruleGroupId the primary key of the current m d r rule group 420 * @param uuid the uuid 421 * @param companyId the company ID 422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 423 * @return the previous, current, and next m d r rule group 424 * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found 425 */ 426 public static MDRRuleGroup[] findByUuid_C_PrevAndNext(long ruleGroupId, 427 java.lang.String uuid, long companyId, 428 OrderByComparator<MDRRuleGroup> orderByComparator) 429 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 430 return getPersistence() 431 .findByUuid_C_PrevAndNext(ruleGroupId, uuid, companyId, 432 orderByComparator); 433 } 434 435 /** 436 * Removes all the m d r rule groups where uuid = ? and companyId = ? from the database. 437 * 438 * @param uuid the uuid 439 * @param companyId the company ID 440 */ 441 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 442 getPersistence().removeByUuid_C(uuid, companyId); 443 } 444 445 /** 446 * Returns the number of m d r rule groups where uuid = ? and companyId = ?. 447 * 448 * @param uuid the uuid 449 * @param companyId the company ID 450 * @return the number of matching m d r rule groups 451 */ 452 public static int countByUuid_C(java.lang.String uuid, long companyId) { 453 return getPersistence().countByUuid_C(uuid, companyId); 454 } 455 456 /** 457 * Returns all the m d r rule groups where groupId = ?. 458 * 459 * @param groupId the group ID 460 * @return the matching m d r rule groups 461 */ 462 public static List<MDRRuleGroup> findByGroupId(long groupId) { 463 return getPersistence().findByGroupId(groupId); 464 } 465 466 /** 467 * Returns a range of all the m d r rule groups where groupId = ?. 468 * 469 * <p> 470 * 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 MDRRuleGroupModelImpl}. 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. 471 * </p> 472 * 473 * @param groupId the group ID 474 * @param start the lower bound of the range of m d r rule groups 475 * @param end the upper bound of the range of m d r rule groups (not inclusive) 476 * @return the range of matching m d r rule groups 477 */ 478 public static List<MDRRuleGroup> findByGroupId(long groupId, int start, 479 int end) { 480 return getPersistence().findByGroupId(groupId, start, end); 481 } 482 483 /** 484 * Returns an ordered range of all the m d r rule groups where groupId = ?. 485 * 486 * <p> 487 * 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 MDRRuleGroupModelImpl}. 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. 488 * </p> 489 * 490 * @param groupId the group ID 491 * @param start the lower bound of the range of m d r rule groups 492 * @param end the upper bound of the range of m d r rule groups (not inclusive) 493 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 494 * @return the ordered range of matching m d r rule groups 495 */ 496 public static List<MDRRuleGroup> findByGroupId(long groupId, int start, 497 int end, OrderByComparator<MDRRuleGroup> orderByComparator) { 498 return getPersistence() 499 .findByGroupId(groupId, start, end, orderByComparator); 500 } 501 502 /** 503 * Returns the first m d r rule group in the ordered set where groupId = ?. 504 * 505 * @param groupId the group ID 506 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 507 * @return the first matching m d r rule group 508 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 509 */ 510 public static MDRRuleGroup findByGroupId_First(long groupId, 511 OrderByComparator<MDRRuleGroup> orderByComparator) 512 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 513 return getPersistence().findByGroupId_First(groupId, orderByComparator); 514 } 515 516 /** 517 * Returns the first m d r rule group in the ordered set where groupId = ?. 518 * 519 * @param groupId the group ID 520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 521 * @return the first matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 522 */ 523 public static MDRRuleGroup fetchByGroupId_First(long groupId, 524 OrderByComparator<MDRRuleGroup> orderByComparator) { 525 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 526 } 527 528 /** 529 * Returns the last m d r rule group in the ordered set where groupId = ?. 530 * 531 * @param groupId the group ID 532 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 533 * @return the last matching m d r rule group 534 * @throws NoSuchRuleGroupException if a matching m d r rule group could not be found 535 */ 536 public static MDRRuleGroup findByGroupId_Last(long groupId, 537 OrderByComparator<MDRRuleGroup> orderByComparator) 538 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 539 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 540 } 541 542 /** 543 * Returns the last m d r rule group in the ordered set where groupId = ?. 544 * 545 * @param groupId the group ID 546 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 547 * @return the last matching m d r rule group, or <code>null</code> if a matching m d r rule group could not be found 548 */ 549 public static MDRRuleGroup fetchByGroupId_Last(long groupId, 550 OrderByComparator<MDRRuleGroup> orderByComparator) { 551 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 552 } 553 554 /** 555 * Returns the m d r rule groups before and after the current m d r rule group in the ordered set where groupId = ?. 556 * 557 * @param ruleGroupId the primary key of the current m d r rule group 558 * @param groupId the group ID 559 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 560 * @return the previous, current, and next m d r rule group 561 * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found 562 */ 563 public static MDRRuleGroup[] findByGroupId_PrevAndNext(long ruleGroupId, 564 long groupId, OrderByComparator<MDRRuleGroup> orderByComparator) 565 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 566 return getPersistence() 567 .findByGroupId_PrevAndNext(ruleGroupId, groupId, 568 orderByComparator); 569 } 570 571 /** 572 * Returns all the m d r rule groups that the user has permission to view where groupId = ?. 573 * 574 * @param groupId the group ID 575 * @return the matching m d r rule groups that the user has permission to view 576 */ 577 public static List<MDRRuleGroup> filterFindByGroupId(long groupId) { 578 return getPersistence().filterFindByGroupId(groupId); 579 } 580 581 /** 582 * Returns a range of all the m d r rule groups that the user has permission to view where groupId = ?. 583 * 584 * <p> 585 * 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 MDRRuleGroupModelImpl}. 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. 586 * </p> 587 * 588 * @param groupId the group ID 589 * @param start the lower bound of the range of m d r rule groups 590 * @param end the upper bound of the range of m d r rule groups (not inclusive) 591 * @return the range of matching m d r rule groups that the user has permission to view 592 */ 593 public static List<MDRRuleGroup> filterFindByGroupId(long groupId, 594 int start, int end) { 595 return getPersistence().filterFindByGroupId(groupId, start, end); 596 } 597 598 /** 599 * Returns an ordered range of all the m d r rule groups that the user has permissions to view where groupId = ?. 600 * 601 * <p> 602 * 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 MDRRuleGroupModelImpl}. 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. 603 * </p> 604 * 605 * @param groupId the group ID 606 * @param start the lower bound of the range of m d r rule groups 607 * @param end the upper bound of the range of m d r rule groups (not inclusive) 608 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 609 * @return the ordered range of matching m d r rule groups that the user has permission to view 610 */ 611 public static List<MDRRuleGroup> filterFindByGroupId(long groupId, 612 int start, int end, OrderByComparator<MDRRuleGroup> orderByComparator) { 613 return getPersistence() 614 .filterFindByGroupId(groupId, start, end, orderByComparator); 615 } 616 617 /** 618 * Returns the m d r rule groups before and after the current m d r rule group in the ordered set of m d r rule groups that the user has permission to view where groupId = ?. 619 * 620 * @param ruleGroupId the primary key of the current m d r rule group 621 * @param groupId the group ID 622 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 623 * @return the previous, current, and next m d r rule group 624 * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found 625 */ 626 public static MDRRuleGroup[] filterFindByGroupId_PrevAndNext( 627 long ruleGroupId, long groupId, 628 OrderByComparator<MDRRuleGroup> orderByComparator) 629 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 630 return getPersistence() 631 .filterFindByGroupId_PrevAndNext(ruleGroupId, groupId, 632 orderByComparator); 633 } 634 635 /** 636 * Returns all the m d r rule groups that the user has permission to view where groupId = any ?. 637 * 638 * @param groupIds the group IDs 639 * @return the matching m d r rule groups that the user has permission to view 640 */ 641 public static List<MDRRuleGroup> filterFindByGroupId(long[] groupIds) { 642 return getPersistence().filterFindByGroupId(groupIds); 643 } 644 645 /** 646 * Returns a range of all the m d r rule groups that the user has permission to view where groupId = any ?. 647 * 648 * <p> 649 * 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 MDRRuleGroupModelImpl}. 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. 650 * </p> 651 * 652 * @param groupIds the group IDs 653 * @param start the lower bound of the range of m d r rule groups 654 * @param end the upper bound of the range of m d r rule groups (not inclusive) 655 * @return the range of matching m d r rule groups that the user has permission to view 656 */ 657 public static List<MDRRuleGroup> filterFindByGroupId(long[] groupIds, 658 int start, int end) { 659 return getPersistence().filterFindByGroupId(groupIds, start, end); 660 } 661 662 /** 663 * Returns an ordered range of all the m d r rule groups that the user has permission to view where groupId = any ?. 664 * 665 * <p> 666 * 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 MDRRuleGroupModelImpl}. 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. 667 * </p> 668 * 669 * @param groupIds the group IDs 670 * @param start the lower bound of the range of m d r rule groups 671 * @param end the upper bound of the range of m d r rule groups (not inclusive) 672 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 673 * @return the ordered range of matching m d r rule groups that the user has permission to view 674 */ 675 public static List<MDRRuleGroup> filterFindByGroupId(long[] groupIds, 676 int start, int end, OrderByComparator<MDRRuleGroup> orderByComparator) { 677 return getPersistence() 678 .filterFindByGroupId(groupIds, start, end, orderByComparator); 679 } 680 681 /** 682 * Returns all the m d r rule groups where groupId = any ?. 683 * 684 * <p> 685 * 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 MDRRuleGroupModelImpl}. 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. 686 * </p> 687 * 688 * @param groupIds the group IDs 689 * @return the matching m d r rule groups 690 */ 691 public static List<MDRRuleGroup> findByGroupId(long[] groupIds) { 692 return getPersistence().findByGroupId(groupIds); 693 } 694 695 /** 696 * Returns a range of all the m d r rule groups where groupId = any ?. 697 * 698 * <p> 699 * 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 MDRRuleGroupModelImpl}. 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. 700 * </p> 701 * 702 * @param groupIds the group IDs 703 * @param start the lower bound of the range of m d r rule groups 704 * @param end the upper bound of the range of m d r rule groups (not inclusive) 705 * @return the range of matching m d r rule groups 706 */ 707 public static List<MDRRuleGroup> findByGroupId(long[] groupIds, int start, 708 int end) { 709 return getPersistence().findByGroupId(groupIds, start, end); 710 } 711 712 /** 713 * Returns an ordered range of all the m d r rule groups where groupId = any ?. 714 * 715 * <p> 716 * 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 MDRRuleGroupModelImpl}. 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. 717 * </p> 718 * 719 * @param groupIds the group IDs 720 * @param start the lower bound of the range of m d r rule groups 721 * @param end the upper bound of the range of m d r rule groups (not inclusive) 722 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 723 * @return the ordered range of matching m d r rule groups 724 */ 725 public static List<MDRRuleGroup> findByGroupId(long[] groupIds, int start, 726 int end, OrderByComparator<MDRRuleGroup> orderByComparator) { 727 return getPersistence() 728 .findByGroupId(groupIds, start, end, orderByComparator); 729 } 730 731 /** 732 * Removes all the m d r rule groups where groupId = ? from the database. 733 * 734 * @param groupId the group ID 735 */ 736 public static void removeByGroupId(long groupId) { 737 getPersistence().removeByGroupId(groupId); 738 } 739 740 /** 741 * Returns the number of m d r rule groups where groupId = ?. 742 * 743 * @param groupId the group ID 744 * @return the number of matching m d r rule groups 745 */ 746 public static int countByGroupId(long groupId) { 747 return getPersistence().countByGroupId(groupId); 748 } 749 750 /** 751 * Returns the number of m d r rule groups where groupId = any ?. 752 * 753 * @param groupIds the group IDs 754 * @return the number of matching m d r rule groups 755 */ 756 public static int countByGroupId(long[] groupIds) { 757 return getPersistence().countByGroupId(groupIds); 758 } 759 760 /** 761 * Returns the number of m d r rule groups that the user has permission to view where groupId = ?. 762 * 763 * @param groupId the group ID 764 * @return the number of matching m d r rule groups that the user has permission to view 765 */ 766 public static int filterCountByGroupId(long groupId) { 767 return getPersistence().filterCountByGroupId(groupId); 768 } 769 770 /** 771 * Returns the number of m d r rule groups that the user has permission to view where groupId = any ?. 772 * 773 * @param groupIds the group IDs 774 * @return the number of matching m d r rule groups that the user has permission to view 775 */ 776 public static int filterCountByGroupId(long[] groupIds) { 777 return getPersistence().filterCountByGroupId(groupIds); 778 } 779 780 /** 781 * Caches the m d r rule group in the entity cache if it is enabled. 782 * 783 * @param mdrRuleGroup the m d r rule group 784 */ 785 public static void cacheResult(MDRRuleGroup mdrRuleGroup) { 786 getPersistence().cacheResult(mdrRuleGroup); 787 } 788 789 /** 790 * Caches the m d r rule groups in the entity cache if it is enabled. 791 * 792 * @param mdrRuleGroups the m d r rule groups 793 */ 794 public static void cacheResult(List<MDRRuleGroup> mdrRuleGroups) { 795 getPersistence().cacheResult(mdrRuleGroups); 796 } 797 798 /** 799 * Creates a new m d r rule group with the primary key. Does not add the m d r rule group to the database. 800 * 801 * @param ruleGroupId the primary key for the new m d r rule group 802 * @return the new m d r rule group 803 */ 804 public static MDRRuleGroup create(long ruleGroupId) { 805 return getPersistence().create(ruleGroupId); 806 } 807 808 /** 809 * Removes the m d r rule group with the primary key from the database. Also notifies the appropriate model listeners. 810 * 811 * @param ruleGroupId the primary key of the m d r rule group 812 * @return the m d r rule group that was removed 813 * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found 814 */ 815 public static MDRRuleGroup remove(long ruleGroupId) 816 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 817 return getPersistence().remove(ruleGroupId); 818 } 819 820 public static MDRRuleGroup updateImpl(MDRRuleGroup mdrRuleGroup) { 821 return getPersistence().updateImpl(mdrRuleGroup); 822 } 823 824 /** 825 * Returns the m d r rule group with the primary key or throws a {@link NoSuchRuleGroupException} if it could not be found. 826 * 827 * @param ruleGroupId the primary key of the m d r rule group 828 * @return the m d r rule group 829 * @throws NoSuchRuleGroupException if a m d r rule group with the primary key could not be found 830 */ 831 public static MDRRuleGroup findByPrimaryKey(long ruleGroupId) 832 throws com.liferay.portlet.mobiledevicerules.NoSuchRuleGroupException { 833 return getPersistence().findByPrimaryKey(ruleGroupId); 834 } 835 836 /** 837 * Returns the m d r rule group with the primary key or returns <code>null</code> if it could not be found. 838 * 839 * @param ruleGroupId the primary key of the m d r rule group 840 * @return the m d r rule group, or <code>null</code> if a m d r rule group with the primary key could not be found 841 */ 842 public static MDRRuleGroup fetchByPrimaryKey(long ruleGroupId) { 843 return getPersistence().fetchByPrimaryKey(ruleGroupId); 844 } 845 846 public static java.util.Map<java.io.Serializable, MDRRuleGroup> fetchByPrimaryKeys( 847 java.util.Set<java.io.Serializable> primaryKeys) { 848 return getPersistence().fetchByPrimaryKeys(primaryKeys); 849 } 850 851 /** 852 * Returns all the m d r rule groups. 853 * 854 * @return the m d r rule groups 855 */ 856 public static List<MDRRuleGroup> findAll() { 857 return getPersistence().findAll(); 858 } 859 860 /** 861 * Returns a range of all the m d r rule groups. 862 * 863 * <p> 864 * 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 MDRRuleGroupModelImpl}. 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. 865 * </p> 866 * 867 * @param start the lower bound of the range of m d r rule groups 868 * @param end the upper bound of the range of m d r rule groups (not inclusive) 869 * @return the range of m d r rule groups 870 */ 871 public static List<MDRRuleGroup> findAll(int start, int end) { 872 return getPersistence().findAll(start, end); 873 } 874 875 /** 876 * Returns an ordered range of all the m d r rule groups. 877 * 878 * <p> 879 * 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 MDRRuleGroupModelImpl}. 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. 880 * </p> 881 * 882 * @param start the lower bound of the range of m d r rule groups 883 * @param end the upper bound of the range of m d r rule groups (not inclusive) 884 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 885 * @return the ordered range of m d r rule groups 886 */ 887 public static List<MDRRuleGroup> findAll(int start, int end, 888 OrderByComparator<MDRRuleGroup> orderByComparator) { 889 return getPersistence().findAll(start, end, orderByComparator); 890 } 891 892 /** 893 * Removes all the m d r rule groups from the database. 894 */ 895 public static void removeAll() { 896 getPersistence().removeAll(); 897 } 898 899 /** 900 * Returns the number of m d r rule groups. 901 * 902 * @return the number of m d r rule groups 903 */ 904 public static int countAll() { 905 return getPersistence().countAll(); 906 } 907 908 public static MDRRuleGroupPersistence getPersistence() { 909 if (_persistence == null) { 910 _persistence = (MDRRuleGroupPersistence)PortalBeanLocatorUtil.locate(MDRRuleGroupPersistence.class.getName()); 911 912 ReferenceRegistry.registerReference(MDRRuleGroupUtil.class, 913 "_persistence"); 914 } 915 916 return _persistence; 917 } 918 919 /** 920 * @deprecated As of 6.2.0 921 */ 922 @Deprecated 923 public void setPersistence(MDRRuleGroupPersistence persistence) { 924 } 925 926 private static MDRRuleGroupPersistence _persistence; 927 }