001 /** 002 * Copyright (c) 2000-2013 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.dynamicdatamapping.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.dynamicdatamapping.model.DDMStructure; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the d d m structure service. This utility wraps {@link DDMStructurePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see DDMStructurePersistence 037 * @see DDMStructurePersistenceImpl 038 * @generated 039 */ 040 public class DDMStructureUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(DDMStructure ddmStructure) { 058 getPersistence().clearCache(ddmStructure); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<DDMStructure> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 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<DDMStructure> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 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<DDMStructure> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 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 DDMStructure update(DDMStructure ddmStructure) 101 throws SystemException { 102 return getPersistence().update(ddmStructure); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static DDMStructure update(DDMStructure ddmStructure, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(ddmStructure, serviceContext); 111 } 112 113 /** 114 * Returns all the d d m structures where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching d d m structures 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the d d m structures where uuid = ?. 128 * 129 * <p> 130 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of d d m structures 135 * @param end the upper bound of the range of d d m structures (not inclusive) 136 * @return the range of matching d d m structures 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the d d m structures where uuid = ?. 147 * 148 * <p> 149 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of d d m structures 154 * @param end the upper bound of the range of d d m structures (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching d d m structures 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first d d m structure in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching d d m structure 172 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first d d m structure 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 first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last d d m structure in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching d d m structure 204 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last d d m structure in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = ?. 232 * 233 * @param structureId the primary key of the current d d m structure 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next d d m structure 237 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_PrevAndNext( 241 long structureId, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(structureId, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the d d m structures where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of d d m structures where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching d d m structures 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the d d m structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching d d m structure 278 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the d d m structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the d d m structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the d d m structure where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the d d m structure that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of d d m structures where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching d d m structures 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the d d m structures where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching d d m structures 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the d d m structures where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of d d m structures 369 * @param end the upper bound of the range of d d m structures (not inclusive) 370 * @return the range of matching d d m structures 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the d d m structures where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of d d m structures 389 * @param end the upper bound of the range of d d m structures (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching d d m structures 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first d d m structure 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 first matching d d m structure 409 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first d d m structure in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last d d m structure in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching d d m structure 445 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last d d m structure in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param structureId the primary key of the current d d m structure 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next d d m structure 482 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_C_PrevAndNext( 486 long structureId, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(structureId, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the d d m structures where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of d d m structures where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching d d m structures 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the d d m structures where groupId = ?. 522 * 523 * @param groupId the group ID 524 * @return the matching d d m structures 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId( 528 long groupId) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByGroupId(groupId); 531 } 532 533 /** 534 * Returns a range of all the d d m structures where groupId = ?. 535 * 536 * <p> 537 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 538 * </p> 539 * 540 * @param groupId the group ID 541 * @param start the lower bound of the range of d d m structures 542 * @param end the upper bound of the range of d d m structures (not inclusive) 543 * @return the range of matching d d m structures 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId( 547 long groupId, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence().findByGroupId(groupId, start, end); 550 } 551 552 /** 553 * Returns an ordered range of all the d d m structures where groupId = ?. 554 * 555 * <p> 556 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 557 * </p> 558 * 559 * @param groupId the group ID 560 * @param start the lower bound of the range of d d m structures 561 * @param end the upper bound of the range of d d m structures (not inclusive) 562 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 563 * @return the ordered range of matching d d m structures 564 * @throws SystemException if a system exception occurred 565 */ 566 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId( 567 long groupId, int start, int end, 568 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 569 throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence() 571 .findByGroupId(groupId, start, end, orderByComparator); 572 } 573 574 /** 575 * Returns the first d d m structure in the ordered set where groupId = ?. 576 * 577 * @param groupId the group ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching d d m structure 580 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_First( 584 long groupId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 588 return getPersistence().findByGroupId_First(groupId, orderByComparator); 589 } 590 591 /** 592 * Returns the first d d m structure in the ordered set where groupId = ?. 593 * 594 * @param groupId the group ID 595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 596 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 597 * @throws SystemException if a system exception occurred 598 */ 599 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_First( 600 long groupId, 601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 602 throws com.liferay.portal.kernel.exception.SystemException { 603 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last d d m structure in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching d d m structure 612 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 613 * @throws SystemException if a system exception occurred 614 */ 615 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_Last( 616 long groupId, 617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 618 throws com.liferay.portal.kernel.exception.SystemException, 619 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 620 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the last d d m structure in the ordered set where groupId = ?. 625 * 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 629 * @throws SystemException if a system exception occurred 630 */ 631 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_Last( 632 long groupId, 633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 636 } 637 638 /** 639 * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = ?. 640 * 641 * @param structureId the primary key of the current d d m structure 642 * @param groupId the group ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next d d m structure 645 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByGroupId_PrevAndNext( 649 long structureId, long groupId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 653 return getPersistence() 654 .findByGroupId_PrevAndNext(structureId, groupId, 655 orderByComparator); 656 } 657 658 /** 659 * Returns all the d d m structures that the user has permission to view where groupId = ?. 660 * 661 * @param groupId the group ID 662 * @return the matching d d m structures that the user has permission to view 663 * @throws SystemException if a system exception occurred 664 */ 665 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId( 666 long groupId) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 return getPersistence().filterFindByGroupId(groupId); 669 } 670 671 /** 672 * Returns a range of all the d d m structures that the user has permission to view where groupId = ?. 673 * 674 * <p> 675 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 676 * </p> 677 * 678 * @param groupId the group ID 679 * @param start the lower bound of the range of d d m structures 680 * @param end the upper bound of the range of d d m structures (not inclusive) 681 * @return the range of matching d d m structures that the user has permission to view 682 * @throws SystemException if a system exception occurred 683 */ 684 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId( 685 long groupId, int start, int end) 686 throws com.liferay.portal.kernel.exception.SystemException { 687 return getPersistence().filterFindByGroupId(groupId, start, end); 688 } 689 690 /** 691 * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = ?. 692 * 693 * <p> 694 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 695 * </p> 696 * 697 * @param groupId the group ID 698 * @param start the lower bound of the range of d d m structures 699 * @param end the upper bound of the range of d d m structures (not inclusive) 700 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 701 * @return the ordered range of matching d d m structures that the user has permission to view 702 * @throws SystemException if a system exception occurred 703 */ 704 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId( 705 long groupId, int start, int end, 706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence() 709 .filterFindByGroupId(groupId, start, end, orderByComparator); 710 } 711 712 /** 713 * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = ?. 714 * 715 * @param structureId the primary key of the current d d m structure 716 * @param groupId the group ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the previous, current, and next d d m structure 719 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 720 * @throws SystemException if a system exception occurred 721 */ 722 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByGroupId_PrevAndNext( 723 long structureId, long groupId, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.kernel.exception.SystemException, 726 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 727 return getPersistence() 728 .filterFindByGroupId_PrevAndNext(structureId, groupId, 729 orderByComparator); 730 } 731 732 /** 733 * Returns all the d d m structures that the user has permission to view where groupId = any ?. 734 * 735 * @param groupIds the group IDs 736 * @return the matching d d m structures that the user has permission to view 737 * @throws SystemException if a system exception occurred 738 */ 739 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId( 740 long[] groupIds) 741 throws com.liferay.portal.kernel.exception.SystemException { 742 return getPersistence().filterFindByGroupId(groupIds); 743 } 744 745 /** 746 * Returns a range of all the d d m structures that the user has permission to view where groupId = any ?. 747 * 748 * <p> 749 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 750 * </p> 751 * 752 * @param groupIds the group IDs 753 * @param start the lower bound of the range of d d m structures 754 * @param end the upper bound of the range of d d m structures (not inclusive) 755 * @return the range of matching d d m structures that the user has permission to view 756 * @throws SystemException if a system exception occurred 757 */ 758 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId( 759 long[] groupIds, int start, int end) 760 throws com.liferay.portal.kernel.exception.SystemException { 761 return getPersistence().filterFindByGroupId(groupIds, start, end); 762 } 763 764 /** 765 * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any ?. 766 * 767 * <p> 768 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 769 * </p> 770 * 771 * @param groupIds the group IDs 772 * @param start the lower bound of the range of d d m structures 773 * @param end the upper bound of the range of d d m structures (not inclusive) 774 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 775 * @return the ordered range of matching d d m structures that the user has permission to view 776 * @throws SystemException if a system exception occurred 777 */ 778 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId( 779 long[] groupIds, int start, int end, 780 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 781 throws com.liferay.portal.kernel.exception.SystemException { 782 return getPersistence() 783 .filterFindByGroupId(groupIds, start, end, orderByComparator); 784 } 785 786 /** 787 * Returns all the d d m structures where groupId = any ?. 788 * 789 * <p> 790 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 791 * </p> 792 * 793 * @param groupIds the group IDs 794 * @return the matching d d m structures 795 * @throws SystemException if a system exception occurred 796 */ 797 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId( 798 long[] groupIds) 799 throws com.liferay.portal.kernel.exception.SystemException { 800 return getPersistence().findByGroupId(groupIds); 801 } 802 803 /** 804 * Returns a range of all the d d m structures where groupId = any ?. 805 * 806 * <p> 807 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 808 * </p> 809 * 810 * @param groupIds the group IDs 811 * @param start the lower bound of the range of d d m structures 812 * @param end the upper bound of the range of d d m structures (not inclusive) 813 * @return the range of matching d d m structures 814 * @throws SystemException if a system exception occurred 815 */ 816 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId( 817 long[] groupIds, int start, int end) 818 throws com.liferay.portal.kernel.exception.SystemException { 819 return getPersistence().findByGroupId(groupIds, start, end); 820 } 821 822 /** 823 * Returns an ordered range of all the d d m structures where groupId = any ?. 824 * 825 * <p> 826 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 827 * </p> 828 * 829 * @param groupIds the group IDs 830 * @param start the lower bound of the range of d d m structures 831 * @param end the upper bound of the range of d d m structures (not inclusive) 832 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 833 * @return the ordered range of matching d d m structures 834 * @throws SystemException if a system exception occurred 835 */ 836 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId( 837 long[] groupIds, int start, int end, 838 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 839 throws com.liferay.portal.kernel.exception.SystemException { 840 return getPersistence() 841 .findByGroupId(groupIds, start, end, orderByComparator); 842 } 843 844 /** 845 * Removes all the d d m structures where groupId = ? from the database. 846 * 847 * @param groupId the group ID 848 * @throws SystemException if a system exception occurred 849 */ 850 public static void removeByGroupId(long groupId) 851 throws com.liferay.portal.kernel.exception.SystemException { 852 getPersistence().removeByGroupId(groupId); 853 } 854 855 /** 856 * Returns the number of d d m structures where groupId = ?. 857 * 858 * @param groupId the group ID 859 * @return the number of matching d d m structures 860 * @throws SystemException if a system exception occurred 861 */ 862 public static int countByGroupId(long groupId) 863 throws com.liferay.portal.kernel.exception.SystemException { 864 return getPersistence().countByGroupId(groupId); 865 } 866 867 /** 868 * Returns the number of d d m structures where groupId = any ?. 869 * 870 * @param groupIds the group IDs 871 * @return the number of matching d d m structures 872 * @throws SystemException if a system exception occurred 873 */ 874 public static int countByGroupId(long[] groupIds) 875 throws com.liferay.portal.kernel.exception.SystemException { 876 return getPersistence().countByGroupId(groupIds); 877 } 878 879 /** 880 * Returns the number of d d m structures that the user has permission to view where groupId = ?. 881 * 882 * @param groupId the group ID 883 * @return the number of matching d d m structures that the user has permission to view 884 * @throws SystemException if a system exception occurred 885 */ 886 public static int filterCountByGroupId(long groupId) 887 throws com.liferay.portal.kernel.exception.SystemException { 888 return getPersistence().filterCountByGroupId(groupId); 889 } 890 891 /** 892 * Returns the number of d d m structures that the user has permission to view where groupId = any ?. 893 * 894 * @param groupIds the group IDs 895 * @return the number of matching d d m structures that the user has permission to view 896 * @throws SystemException if a system exception occurred 897 */ 898 public static int filterCountByGroupId(long[] groupIds) 899 throws com.liferay.portal.kernel.exception.SystemException { 900 return getPersistence().filterCountByGroupId(groupIds); 901 } 902 903 /** 904 * Returns all the d d m structures where classNameId = ?. 905 * 906 * @param classNameId the class name ID 907 * @return the matching d d m structures 908 * @throws SystemException if a system exception occurred 909 */ 910 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId( 911 long classNameId) 912 throws com.liferay.portal.kernel.exception.SystemException { 913 return getPersistence().findByClassNameId(classNameId); 914 } 915 916 /** 917 * Returns a range of all the d d m structures where classNameId = ?. 918 * 919 * <p> 920 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 921 * </p> 922 * 923 * @param classNameId the class name ID 924 * @param start the lower bound of the range of d d m structures 925 * @param end the upper bound of the range of d d m structures (not inclusive) 926 * @return the range of matching d d m structures 927 * @throws SystemException if a system exception occurred 928 */ 929 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId( 930 long classNameId, int start, int end) 931 throws com.liferay.portal.kernel.exception.SystemException { 932 return getPersistence().findByClassNameId(classNameId, start, end); 933 } 934 935 /** 936 * Returns an ordered range of all the d d m structures where classNameId = ?. 937 * 938 * <p> 939 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 940 * </p> 941 * 942 * @param classNameId the class name ID 943 * @param start the lower bound of the range of d d m structures 944 * @param end the upper bound of the range of d d m structures (not inclusive) 945 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 946 * @return the ordered range of matching d d m structures 947 * @throws SystemException if a system exception occurred 948 */ 949 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId( 950 long classNameId, int start, int end, 951 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 952 throws com.liferay.portal.kernel.exception.SystemException { 953 return getPersistence() 954 .findByClassNameId(classNameId, start, end, orderByComparator); 955 } 956 957 /** 958 * Returns the first d d m structure in the ordered set where classNameId = ?. 959 * 960 * @param classNameId the class name ID 961 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 962 * @return the first matching d d m structure 963 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 964 * @throws SystemException if a system exception occurred 965 */ 966 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_First( 967 long classNameId, 968 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 969 throws com.liferay.portal.kernel.exception.SystemException, 970 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 971 return getPersistence() 972 .findByClassNameId_First(classNameId, orderByComparator); 973 } 974 975 /** 976 * Returns the first d d m structure in the ordered set where classNameId = ?. 977 * 978 * @param classNameId the class name ID 979 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 980 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 981 * @throws SystemException if a system exception occurred 982 */ 983 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_First( 984 long classNameId, 985 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 986 throws com.liferay.portal.kernel.exception.SystemException { 987 return getPersistence() 988 .fetchByClassNameId_First(classNameId, orderByComparator); 989 } 990 991 /** 992 * Returns the last d d m structure in the ordered set where classNameId = ?. 993 * 994 * @param classNameId the class name ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the last matching d d m structure 997 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_Last( 1001 long classNameId, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1005 return getPersistence() 1006 .findByClassNameId_Last(classNameId, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns the last d d m structure in the ordered set where classNameId = ?. 1011 * 1012 * @param classNameId the class name ID 1013 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1014 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1015 * @throws SystemException if a system exception occurred 1016 */ 1017 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_Last( 1018 long classNameId, 1019 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1020 throws com.liferay.portal.kernel.exception.SystemException { 1021 return getPersistence() 1022 .fetchByClassNameId_Last(classNameId, orderByComparator); 1023 } 1024 1025 /** 1026 * Returns the d d m structures before and after the current d d m structure in the ordered set where classNameId = ?. 1027 * 1028 * @param structureId the primary key of the current d d m structure 1029 * @param classNameId the class name ID 1030 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1031 * @return the previous, current, and next d d m structure 1032 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByClassNameId_PrevAndNext( 1036 long structureId, long classNameId, 1037 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1038 throws com.liferay.portal.kernel.exception.SystemException, 1039 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1040 return getPersistence() 1041 .findByClassNameId_PrevAndNext(structureId, classNameId, 1042 orderByComparator); 1043 } 1044 1045 /** 1046 * Removes all the d d m structures where classNameId = ? from the database. 1047 * 1048 * @param classNameId the class name ID 1049 * @throws SystemException if a system exception occurred 1050 */ 1051 public static void removeByClassNameId(long classNameId) 1052 throws com.liferay.portal.kernel.exception.SystemException { 1053 getPersistence().removeByClassNameId(classNameId); 1054 } 1055 1056 /** 1057 * Returns the number of d d m structures where classNameId = ?. 1058 * 1059 * @param classNameId the class name ID 1060 * @return the number of matching d d m structures 1061 * @throws SystemException if a system exception occurred 1062 */ 1063 public static int countByClassNameId(long classNameId) 1064 throws com.liferay.portal.kernel.exception.SystemException { 1065 return getPersistence().countByClassNameId(classNameId); 1066 } 1067 1068 /** 1069 * Returns all the d d m structures where structureKey = ?. 1070 * 1071 * @param structureKey the structure key 1072 * @return the matching d d m structures 1073 * @throws SystemException if a system exception occurred 1074 */ 1075 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey( 1076 java.lang.String structureKey) 1077 throws com.liferay.portal.kernel.exception.SystemException { 1078 return getPersistence().findByStructureKey(structureKey); 1079 } 1080 1081 /** 1082 * Returns a range of all the d d m structures where structureKey = ?. 1083 * 1084 * <p> 1085 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1086 * </p> 1087 * 1088 * @param structureKey the structure key 1089 * @param start the lower bound of the range of d d m structures 1090 * @param end the upper bound of the range of d d m structures (not inclusive) 1091 * @return the range of matching d d m structures 1092 * @throws SystemException if a system exception occurred 1093 */ 1094 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey( 1095 java.lang.String structureKey, int start, int end) 1096 throws com.liferay.portal.kernel.exception.SystemException { 1097 return getPersistence().findByStructureKey(structureKey, start, end); 1098 } 1099 1100 /** 1101 * Returns an ordered range of all the d d m structures where structureKey = ?. 1102 * 1103 * <p> 1104 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1105 * </p> 1106 * 1107 * @param structureKey the structure key 1108 * @param start the lower bound of the range of d d m structures 1109 * @param end the upper bound of the range of d d m structures (not inclusive) 1110 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1111 * @return the ordered range of matching d d m structures 1112 * @throws SystemException if a system exception occurred 1113 */ 1114 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey( 1115 java.lang.String structureKey, int start, int end, 1116 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1117 throws com.liferay.portal.kernel.exception.SystemException { 1118 return getPersistence() 1119 .findByStructureKey(structureKey, start, end, 1120 orderByComparator); 1121 } 1122 1123 /** 1124 * Returns the first d d m structure in the ordered set where structureKey = ?. 1125 * 1126 * @param structureKey the structure key 1127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1128 * @return the first matching d d m structure 1129 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1130 * @throws SystemException if a system exception occurred 1131 */ 1132 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_First( 1133 java.lang.String structureKey, 1134 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1135 throws com.liferay.portal.kernel.exception.SystemException, 1136 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1137 return getPersistence() 1138 .findByStructureKey_First(structureKey, orderByComparator); 1139 } 1140 1141 /** 1142 * Returns the first d d m structure in the ordered set where structureKey = ?. 1143 * 1144 * @param structureKey the structure key 1145 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1146 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1147 * @throws SystemException if a system exception occurred 1148 */ 1149 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_First( 1150 java.lang.String structureKey, 1151 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1152 throws com.liferay.portal.kernel.exception.SystemException { 1153 return getPersistence() 1154 .fetchByStructureKey_First(structureKey, orderByComparator); 1155 } 1156 1157 /** 1158 * Returns the last d d m structure in the ordered set where structureKey = ?. 1159 * 1160 * @param structureKey the structure key 1161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1162 * @return the last matching d d m structure 1163 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1164 * @throws SystemException if a system exception occurred 1165 */ 1166 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_Last( 1167 java.lang.String structureKey, 1168 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1169 throws com.liferay.portal.kernel.exception.SystemException, 1170 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1171 return getPersistence() 1172 .findByStructureKey_Last(structureKey, orderByComparator); 1173 } 1174 1175 /** 1176 * Returns the last d d m structure in the ordered set where structureKey = ?. 1177 * 1178 * @param structureKey the structure key 1179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1180 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1181 * @throws SystemException if a system exception occurred 1182 */ 1183 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_Last( 1184 java.lang.String structureKey, 1185 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1186 throws com.liferay.portal.kernel.exception.SystemException { 1187 return getPersistence() 1188 .fetchByStructureKey_Last(structureKey, orderByComparator); 1189 } 1190 1191 /** 1192 * Returns the d d m structures before and after the current d d m structure in the ordered set where structureKey = ?. 1193 * 1194 * @param structureId the primary key of the current d d m structure 1195 * @param structureKey the structure key 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the previous, current, and next d d m structure 1198 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByStructureKey_PrevAndNext( 1202 long structureId, java.lang.String structureKey, 1203 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1204 throws com.liferay.portal.kernel.exception.SystemException, 1205 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1206 return getPersistence() 1207 .findByStructureKey_PrevAndNext(structureId, structureKey, 1208 orderByComparator); 1209 } 1210 1211 /** 1212 * Removes all the d d m structures where structureKey = ? from the database. 1213 * 1214 * @param structureKey the structure key 1215 * @throws SystemException if a system exception occurred 1216 */ 1217 public static void removeByStructureKey(java.lang.String structureKey) 1218 throws com.liferay.portal.kernel.exception.SystemException { 1219 getPersistence().removeByStructureKey(structureKey); 1220 } 1221 1222 /** 1223 * Returns the number of d d m structures where structureKey = ?. 1224 * 1225 * @param structureKey the structure key 1226 * @return the number of matching d d m structures 1227 * @throws SystemException if a system exception occurred 1228 */ 1229 public static int countByStructureKey(java.lang.String structureKey) 1230 throws com.liferay.portal.kernel.exception.SystemException { 1231 return getPersistence().countByStructureKey(structureKey); 1232 } 1233 1234 /** 1235 * Returns all the d d m structures where groupId = ? and parentStructureId = ?. 1236 * 1237 * @param groupId the group ID 1238 * @param parentStructureId the parent structure ID 1239 * @return the matching d d m structures 1240 * @throws SystemException if a system exception occurred 1241 */ 1242 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P( 1243 long groupId, long parentStructureId) 1244 throws com.liferay.portal.kernel.exception.SystemException { 1245 return getPersistence().findByG_P(groupId, parentStructureId); 1246 } 1247 1248 /** 1249 * Returns a range of all the d d m structures where groupId = ? and parentStructureId = ?. 1250 * 1251 * <p> 1252 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1253 * </p> 1254 * 1255 * @param groupId the group ID 1256 * @param parentStructureId the parent structure ID 1257 * @param start the lower bound of the range of d d m structures 1258 * @param end the upper bound of the range of d d m structures (not inclusive) 1259 * @return the range of matching d d m structures 1260 * @throws SystemException if a system exception occurred 1261 */ 1262 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P( 1263 long groupId, long parentStructureId, int start, int end) 1264 throws com.liferay.portal.kernel.exception.SystemException { 1265 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 1266 } 1267 1268 /** 1269 * Returns an ordered range of all the d d m structures where groupId = ? and parentStructureId = ?. 1270 * 1271 * <p> 1272 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1273 * </p> 1274 * 1275 * @param groupId the group ID 1276 * @param parentStructureId the parent structure ID 1277 * @param start the lower bound of the range of d d m structures 1278 * @param end the upper bound of the range of d d m structures (not inclusive) 1279 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1280 * @return the ordered range of matching d d m structures 1281 * @throws SystemException if a system exception occurred 1282 */ 1283 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P( 1284 long groupId, long parentStructureId, int start, int end, 1285 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1286 throws com.liferay.portal.kernel.exception.SystemException { 1287 return getPersistence() 1288 .findByG_P(groupId, parentStructureId, start, end, 1289 orderByComparator); 1290 } 1291 1292 /** 1293 * Returns the first d d m structure in the ordered set where groupId = ? and parentStructureId = ?. 1294 * 1295 * @param groupId the group ID 1296 * @param parentStructureId the parent structure ID 1297 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1298 * @return the first matching d d m structure 1299 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1300 * @throws SystemException if a system exception occurred 1301 */ 1302 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_First( 1303 long groupId, long parentStructureId, 1304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1305 throws com.liferay.portal.kernel.exception.SystemException, 1306 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1307 return getPersistence() 1308 .findByG_P_First(groupId, parentStructureId, 1309 orderByComparator); 1310 } 1311 1312 /** 1313 * Returns the first d d m structure in the ordered set where groupId = ? and parentStructureId = ?. 1314 * 1315 * @param groupId the group ID 1316 * @param parentStructureId the parent structure ID 1317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1318 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1319 * @throws SystemException if a system exception occurred 1320 */ 1321 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_First( 1322 long groupId, long parentStructureId, 1323 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1324 throws com.liferay.portal.kernel.exception.SystemException { 1325 return getPersistence() 1326 .fetchByG_P_First(groupId, parentStructureId, 1327 orderByComparator); 1328 } 1329 1330 /** 1331 * Returns the last d d m structure in the ordered set where groupId = ? and parentStructureId = ?. 1332 * 1333 * @param groupId the group ID 1334 * @param parentStructureId the parent structure ID 1335 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1336 * @return the last matching d d m structure 1337 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1338 * @throws SystemException if a system exception occurred 1339 */ 1340 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_Last( 1341 long groupId, long parentStructureId, 1342 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1343 throws com.liferay.portal.kernel.exception.SystemException, 1344 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1345 return getPersistence() 1346 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 1347 } 1348 1349 /** 1350 * Returns the last d d m structure in the ordered set where groupId = ? and parentStructureId = ?. 1351 * 1352 * @param groupId the group ID 1353 * @param parentStructureId the parent structure ID 1354 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1355 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1356 * @throws SystemException if a system exception occurred 1357 */ 1358 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_Last( 1359 long groupId, long parentStructureId, 1360 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1361 throws com.liferay.portal.kernel.exception.SystemException { 1362 return getPersistence() 1363 .fetchByG_P_Last(groupId, parentStructureId, 1364 orderByComparator); 1365 } 1366 1367 /** 1368 * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = ? and parentStructureId = ?. 1369 * 1370 * @param structureId the primary key of the current d d m structure 1371 * @param groupId the group ID 1372 * @param parentStructureId the parent structure ID 1373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1374 * @return the previous, current, and next d d m structure 1375 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 1376 * @throws SystemException if a system exception occurred 1377 */ 1378 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_P_PrevAndNext( 1379 long structureId, long groupId, long parentStructureId, 1380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1381 throws com.liferay.portal.kernel.exception.SystemException, 1382 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1383 return getPersistence() 1384 .findByG_P_PrevAndNext(structureId, groupId, 1385 parentStructureId, orderByComparator); 1386 } 1387 1388 /** 1389 * Returns all the d d m structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1390 * 1391 * @param groupId the group ID 1392 * @param parentStructureId the parent structure ID 1393 * @return the matching d d m structures that the user has permission to view 1394 * @throws SystemException if a system exception occurred 1395 */ 1396 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P( 1397 long groupId, long parentStructureId) 1398 throws com.liferay.portal.kernel.exception.SystemException { 1399 return getPersistence().filterFindByG_P(groupId, parentStructureId); 1400 } 1401 1402 /** 1403 * Returns a range of all the d d m structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1404 * 1405 * <p> 1406 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1407 * </p> 1408 * 1409 * @param groupId the group ID 1410 * @param parentStructureId the parent structure ID 1411 * @param start the lower bound of the range of d d m structures 1412 * @param end the upper bound of the range of d d m structures (not inclusive) 1413 * @return the range of matching d d m structures that the user has permission to view 1414 * @throws SystemException if a system exception occurred 1415 */ 1416 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P( 1417 long groupId, long parentStructureId, int start, int end) 1418 throws com.liferay.portal.kernel.exception.SystemException { 1419 return getPersistence() 1420 .filterFindByG_P(groupId, parentStructureId, start, end); 1421 } 1422 1423 /** 1424 * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 1425 * 1426 * <p> 1427 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1428 * </p> 1429 * 1430 * @param groupId the group ID 1431 * @param parentStructureId the parent structure ID 1432 * @param start the lower bound of the range of d d m structures 1433 * @param end the upper bound of the range of d d m structures (not inclusive) 1434 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1435 * @return the ordered range of matching d d m structures that the user has permission to view 1436 * @throws SystemException if a system exception occurred 1437 */ 1438 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P( 1439 long groupId, long parentStructureId, int start, int end, 1440 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1441 throws com.liferay.portal.kernel.exception.SystemException { 1442 return getPersistence() 1443 .filterFindByG_P(groupId, parentStructureId, start, end, 1444 orderByComparator); 1445 } 1446 1447 /** 1448 * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1449 * 1450 * @param structureId the primary key of the current d d m structure 1451 * @param groupId the group ID 1452 * @param parentStructureId the parent structure ID 1453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1454 * @return the previous, current, and next d d m structure 1455 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 1456 * @throws SystemException if a system exception occurred 1457 */ 1458 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_P_PrevAndNext( 1459 long structureId, long groupId, long parentStructureId, 1460 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1461 throws com.liferay.portal.kernel.exception.SystemException, 1462 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1463 return getPersistence() 1464 .filterFindByG_P_PrevAndNext(structureId, groupId, 1465 parentStructureId, orderByComparator); 1466 } 1467 1468 /** 1469 * Removes all the d d m structures where groupId = ? and parentStructureId = ? from the database. 1470 * 1471 * @param groupId the group ID 1472 * @param parentStructureId the parent structure ID 1473 * @throws SystemException if a system exception occurred 1474 */ 1475 public static void removeByG_P(long groupId, long parentStructureId) 1476 throws com.liferay.portal.kernel.exception.SystemException { 1477 getPersistence().removeByG_P(groupId, parentStructureId); 1478 } 1479 1480 /** 1481 * Returns the number of d d m structures where groupId = ? and parentStructureId = ?. 1482 * 1483 * @param groupId the group ID 1484 * @param parentStructureId the parent structure ID 1485 * @return the number of matching d d m structures 1486 * @throws SystemException if a system exception occurred 1487 */ 1488 public static int countByG_P(long groupId, long parentStructureId) 1489 throws com.liferay.portal.kernel.exception.SystemException { 1490 return getPersistence().countByG_P(groupId, parentStructureId); 1491 } 1492 1493 /** 1494 * Returns the number of d d m structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1495 * 1496 * @param groupId the group ID 1497 * @param parentStructureId the parent structure ID 1498 * @return the number of matching d d m structures that the user has permission to view 1499 * @throws SystemException if a system exception occurred 1500 */ 1501 public static int filterCountByG_P(long groupId, long parentStructureId) 1502 throws com.liferay.portal.kernel.exception.SystemException { 1503 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1504 } 1505 1506 /** 1507 * Returns all the d d m structures where groupId = ? and classNameId = ?. 1508 * 1509 * @param groupId the group ID 1510 * @param classNameId the class name ID 1511 * @return the matching d d m structures 1512 * @throws SystemException if a system exception occurred 1513 */ 1514 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C( 1515 long groupId, long classNameId) 1516 throws com.liferay.portal.kernel.exception.SystemException { 1517 return getPersistence().findByG_C(groupId, classNameId); 1518 } 1519 1520 /** 1521 * Returns a range of all the d d m structures where groupId = ? and classNameId = ?. 1522 * 1523 * <p> 1524 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1525 * </p> 1526 * 1527 * @param groupId the group ID 1528 * @param classNameId the class name ID 1529 * @param start the lower bound of the range of d d m structures 1530 * @param end the upper bound of the range of d d m structures (not inclusive) 1531 * @return the range of matching d d m structures 1532 * @throws SystemException if a system exception occurred 1533 */ 1534 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C( 1535 long groupId, long classNameId, int start, int end) 1536 throws com.liferay.portal.kernel.exception.SystemException { 1537 return getPersistence().findByG_C(groupId, classNameId, start, end); 1538 } 1539 1540 /** 1541 * Returns an ordered range of all the d d m structures where groupId = ? and classNameId = ?. 1542 * 1543 * <p> 1544 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1545 * </p> 1546 * 1547 * @param groupId the group ID 1548 * @param classNameId the class name ID 1549 * @param start the lower bound of the range of d d m structures 1550 * @param end the upper bound of the range of d d m structures (not inclusive) 1551 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1552 * @return the ordered range of matching d d m structures 1553 * @throws SystemException if a system exception occurred 1554 */ 1555 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C( 1556 long groupId, long classNameId, int start, int end, 1557 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1558 throws com.liferay.portal.kernel.exception.SystemException { 1559 return getPersistence() 1560 .findByG_C(groupId, classNameId, start, end, 1561 orderByComparator); 1562 } 1563 1564 /** 1565 * Returns the first d d m structure in the ordered set where groupId = ? and classNameId = ?. 1566 * 1567 * @param groupId the group ID 1568 * @param classNameId the class name ID 1569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1570 * @return the first matching d d m structure 1571 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1572 * @throws SystemException if a system exception occurred 1573 */ 1574 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_First( 1575 long groupId, long classNameId, 1576 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1577 throws com.liferay.portal.kernel.exception.SystemException, 1578 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1579 return getPersistence() 1580 .findByG_C_First(groupId, classNameId, orderByComparator); 1581 } 1582 1583 /** 1584 * Returns the first d d m structure in the ordered set where groupId = ? and classNameId = ?. 1585 * 1586 * @param groupId the group ID 1587 * @param classNameId the class name ID 1588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1589 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1590 * @throws SystemException if a system exception occurred 1591 */ 1592 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_First( 1593 long groupId, long classNameId, 1594 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1595 throws com.liferay.portal.kernel.exception.SystemException { 1596 return getPersistence() 1597 .fetchByG_C_First(groupId, classNameId, orderByComparator); 1598 } 1599 1600 /** 1601 * Returns the last d d m structure in the ordered set where groupId = ? and classNameId = ?. 1602 * 1603 * @param groupId the group ID 1604 * @param classNameId the class name ID 1605 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1606 * @return the last matching d d m structure 1607 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1608 * @throws SystemException if a system exception occurred 1609 */ 1610 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_Last( 1611 long groupId, long classNameId, 1612 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1613 throws com.liferay.portal.kernel.exception.SystemException, 1614 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1615 return getPersistence() 1616 .findByG_C_Last(groupId, classNameId, orderByComparator); 1617 } 1618 1619 /** 1620 * Returns the last d d m structure in the ordered set where groupId = ? and classNameId = ?. 1621 * 1622 * @param groupId the group ID 1623 * @param classNameId the class name ID 1624 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1625 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 1626 * @throws SystemException if a system exception occurred 1627 */ 1628 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_Last( 1629 long groupId, long classNameId, 1630 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1631 throws com.liferay.portal.kernel.exception.SystemException { 1632 return getPersistence() 1633 .fetchByG_C_Last(groupId, classNameId, orderByComparator); 1634 } 1635 1636 /** 1637 * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = ? and classNameId = ?. 1638 * 1639 * @param structureId the primary key of the current d d m structure 1640 * @param groupId the group ID 1641 * @param classNameId the class name ID 1642 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1643 * @return the previous, current, and next d d m structure 1644 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 1645 * @throws SystemException if a system exception occurred 1646 */ 1647 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_C_PrevAndNext( 1648 long structureId, long groupId, long classNameId, 1649 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1650 throws com.liferay.portal.kernel.exception.SystemException, 1651 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1652 return getPersistence() 1653 .findByG_C_PrevAndNext(structureId, groupId, classNameId, 1654 orderByComparator); 1655 } 1656 1657 /** 1658 * Returns all the d d m structures that the user has permission to view where groupId = ? and classNameId = ?. 1659 * 1660 * @param groupId the group ID 1661 * @param classNameId the class name ID 1662 * @return the matching d d m structures that the user has permission to view 1663 * @throws SystemException if a system exception occurred 1664 */ 1665 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C( 1666 long groupId, long classNameId) 1667 throws com.liferay.portal.kernel.exception.SystemException { 1668 return getPersistence().filterFindByG_C(groupId, classNameId); 1669 } 1670 1671 /** 1672 * Returns a range of all the d d m structures that the user has permission to view where groupId = ? and classNameId = ?. 1673 * 1674 * <p> 1675 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1676 * </p> 1677 * 1678 * @param groupId the group ID 1679 * @param classNameId the class name ID 1680 * @param start the lower bound of the range of d d m structures 1681 * @param end the upper bound of the range of d d m structures (not inclusive) 1682 * @return the range of matching d d m structures that the user has permission to view 1683 * @throws SystemException if a system exception occurred 1684 */ 1685 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C( 1686 long groupId, long classNameId, int start, int end) 1687 throws com.liferay.portal.kernel.exception.SystemException { 1688 return getPersistence().filterFindByG_C(groupId, classNameId, start, end); 1689 } 1690 1691 /** 1692 * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = ? and classNameId = ?. 1693 * 1694 * <p> 1695 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1696 * </p> 1697 * 1698 * @param groupId the group ID 1699 * @param classNameId the class name ID 1700 * @param start the lower bound of the range of d d m structures 1701 * @param end the upper bound of the range of d d m structures (not inclusive) 1702 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1703 * @return the ordered range of matching d d m structures that the user has permission to view 1704 * @throws SystemException if a system exception occurred 1705 */ 1706 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C( 1707 long groupId, long classNameId, int start, int end, 1708 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1709 throws com.liferay.portal.kernel.exception.SystemException { 1710 return getPersistence() 1711 .filterFindByG_C(groupId, classNameId, start, end, 1712 orderByComparator); 1713 } 1714 1715 /** 1716 * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = ? and classNameId = ?. 1717 * 1718 * @param structureId the primary key of the current d d m structure 1719 * @param groupId the group ID 1720 * @param classNameId the class name ID 1721 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1722 * @return the previous, current, and next d d m structure 1723 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 1724 * @throws SystemException if a system exception occurred 1725 */ 1726 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_C_PrevAndNext( 1727 long structureId, long groupId, long classNameId, 1728 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1729 throws com.liferay.portal.kernel.exception.SystemException, 1730 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1731 return getPersistence() 1732 .filterFindByG_C_PrevAndNext(structureId, groupId, 1733 classNameId, orderByComparator); 1734 } 1735 1736 /** 1737 * Returns all the d d m structures that the user has permission to view where groupId = any ? and classNameId = ?. 1738 * 1739 * @param groupIds the group IDs 1740 * @param classNameId the class name ID 1741 * @return the matching d d m structures that the user has permission to view 1742 * @throws SystemException if a system exception occurred 1743 */ 1744 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C( 1745 long[] groupIds, long classNameId) 1746 throws com.liferay.portal.kernel.exception.SystemException { 1747 return getPersistence().filterFindByG_C(groupIds, classNameId); 1748 } 1749 1750 /** 1751 * Returns a range of all the d d m structures that the user has permission to view where groupId = any ? and classNameId = ?. 1752 * 1753 * <p> 1754 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1755 * </p> 1756 * 1757 * @param groupIds the group IDs 1758 * @param classNameId the class name ID 1759 * @param start the lower bound of the range of d d m structures 1760 * @param end the upper bound of the range of d d m structures (not inclusive) 1761 * @return the range of matching d d m structures that the user has permission to view 1762 * @throws SystemException if a system exception occurred 1763 */ 1764 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C( 1765 long[] groupIds, long classNameId, int start, int end) 1766 throws com.liferay.portal.kernel.exception.SystemException { 1767 return getPersistence() 1768 .filterFindByG_C(groupIds, classNameId, start, end); 1769 } 1770 1771 /** 1772 * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any ? and classNameId = ?. 1773 * 1774 * <p> 1775 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1776 * </p> 1777 * 1778 * @param groupIds the group IDs 1779 * @param classNameId the class name ID 1780 * @param start the lower bound of the range of d d m structures 1781 * @param end the upper bound of the range of d d m structures (not inclusive) 1782 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1783 * @return the ordered range of matching d d m structures that the user has permission to view 1784 * @throws SystemException if a system exception occurred 1785 */ 1786 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C( 1787 long[] groupIds, long classNameId, int start, int end, 1788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1789 throws com.liferay.portal.kernel.exception.SystemException { 1790 return getPersistence() 1791 .filterFindByG_C(groupIds, classNameId, start, end, 1792 orderByComparator); 1793 } 1794 1795 /** 1796 * Returns all the d d m structures where groupId = any ? and classNameId = ?. 1797 * 1798 * <p> 1799 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1800 * </p> 1801 * 1802 * @param groupIds the group IDs 1803 * @param classNameId the class name ID 1804 * @return the matching d d m structures 1805 * @throws SystemException if a system exception occurred 1806 */ 1807 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C( 1808 long[] groupIds, long classNameId) 1809 throws com.liferay.portal.kernel.exception.SystemException { 1810 return getPersistence().findByG_C(groupIds, classNameId); 1811 } 1812 1813 /** 1814 * Returns a range of all the d d m structures where groupId = any ? and classNameId = ?. 1815 * 1816 * <p> 1817 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1818 * </p> 1819 * 1820 * @param groupIds the group IDs 1821 * @param classNameId the class name ID 1822 * @param start the lower bound of the range of d d m structures 1823 * @param end the upper bound of the range of d d m structures (not inclusive) 1824 * @return the range of matching d d m structures 1825 * @throws SystemException if a system exception occurred 1826 */ 1827 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C( 1828 long[] groupIds, long classNameId, int start, int end) 1829 throws com.liferay.portal.kernel.exception.SystemException { 1830 return getPersistence().findByG_C(groupIds, classNameId, start, end); 1831 } 1832 1833 /** 1834 * Returns an ordered range of all the d d m structures where groupId = any ? and classNameId = ?. 1835 * 1836 * <p> 1837 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1838 * </p> 1839 * 1840 * @param groupIds the group IDs 1841 * @param classNameId the class name ID 1842 * @param start the lower bound of the range of d d m structures 1843 * @param end the upper bound of the range of d d m structures (not inclusive) 1844 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1845 * @return the ordered range of matching d d m structures 1846 * @throws SystemException if a system exception occurred 1847 */ 1848 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C( 1849 long[] groupIds, long classNameId, int start, int end, 1850 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1851 throws com.liferay.portal.kernel.exception.SystemException { 1852 return getPersistence() 1853 .findByG_C(groupIds, classNameId, start, end, 1854 orderByComparator); 1855 } 1856 1857 /** 1858 * Removes all the d d m structures where groupId = ? and classNameId = ? from the database. 1859 * 1860 * @param groupId the group ID 1861 * @param classNameId the class name ID 1862 * @throws SystemException if a system exception occurred 1863 */ 1864 public static void removeByG_C(long groupId, long classNameId) 1865 throws com.liferay.portal.kernel.exception.SystemException { 1866 getPersistence().removeByG_C(groupId, classNameId); 1867 } 1868 1869 /** 1870 * Returns the number of d d m structures where groupId = ? and classNameId = ?. 1871 * 1872 * @param groupId the group ID 1873 * @param classNameId the class name ID 1874 * @return the number of matching d d m structures 1875 * @throws SystemException if a system exception occurred 1876 */ 1877 public static int countByG_C(long groupId, long classNameId) 1878 throws com.liferay.portal.kernel.exception.SystemException { 1879 return getPersistence().countByG_C(groupId, classNameId); 1880 } 1881 1882 /** 1883 * Returns the number of d d m structures where groupId = any ? and classNameId = ?. 1884 * 1885 * @param groupIds the group IDs 1886 * @param classNameId the class name ID 1887 * @return the number of matching d d m structures 1888 * @throws SystemException if a system exception occurred 1889 */ 1890 public static int countByG_C(long[] groupIds, long classNameId) 1891 throws com.liferay.portal.kernel.exception.SystemException { 1892 return getPersistence().countByG_C(groupIds, classNameId); 1893 } 1894 1895 /** 1896 * Returns the number of d d m structures that the user has permission to view where groupId = ? and classNameId = ?. 1897 * 1898 * @param groupId the group ID 1899 * @param classNameId the class name ID 1900 * @return the number of matching d d m structures that the user has permission to view 1901 * @throws SystemException if a system exception occurred 1902 */ 1903 public static int filterCountByG_C(long groupId, long classNameId) 1904 throws com.liferay.portal.kernel.exception.SystemException { 1905 return getPersistence().filterCountByG_C(groupId, classNameId); 1906 } 1907 1908 /** 1909 * Returns the number of d d m structures that the user has permission to view where groupId = any ? and classNameId = ?. 1910 * 1911 * @param groupIds the group IDs 1912 * @param classNameId the class name ID 1913 * @return the number of matching d d m structures that the user has permission to view 1914 * @throws SystemException if a system exception occurred 1915 */ 1916 public static int filterCountByG_C(long[] groupIds, long classNameId) 1917 throws com.liferay.portal.kernel.exception.SystemException { 1918 return getPersistence().filterCountByG_C(groupIds, classNameId); 1919 } 1920 1921 /** 1922 * Returns all the d d m structures where companyId = ? and classNameId = ?. 1923 * 1924 * @param companyId the company ID 1925 * @param classNameId the class name ID 1926 * @return the matching d d m structures 1927 * @throws SystemException if a system exception occurred 1928 */ 1929 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C( 1930 long companyId, long classNameId) 1931 throws com.liferay.portal.kernel.exception.SystemException { 1932 return getPersistence().findByC_C(companyId, classNameId); 1933 } 1934 1935 /** 1936 * Returns a range of all the d d m structures where companyId = ? and classNameId = ?. 1937 * 1938 * <p> 1939 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 1940 * </p> 1941 * 1942 * @param companyId the company ID 1943 * @param classNameId the class name ID 1944 * @param start the lower bound of the range of d d m structures 1945 * @param end the upper bound of the range of d d m structures (not inclusive) 1946 * @return the range of matching d d m structures 1947 * @throws SystemException if a system exception occurred 1948 */ 1949 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C( 1950 long companyId, long classNameId, int start, int end) 1951 throws com.liferay.portal.kernel.exception.SystemException { 1952 return getPersistence().findByC_C(companyId, classNameId, start, end); 1953 } 1954 1955 /** 1956 * Returns an ordered range of all the d d m structures where companyId = ? and classNameId = ?. 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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 classNameId the class name ID 1964 * @param start the lower bound of the range of d d m structures 1965 * @param end the upper bound of the range of d d m structures (not inclusive) 1966 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1967 * @return the ordered range of matching d d m structures 1968 * @throws SystemException if a system exception occurred 1969 */ 1970 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C( 1971 long companyId, long classNameId, int start, int end, 1972 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1973 throws com.liferay.portal.kernel.exception.SystemException { 1974 return getPersistence() 1975 .findByC_C(companyId, classNameId, start, end, 1976 orderByComparator); 1977 } 1978 1979 /** 1980 * Returns the first d d m structure in the ordered set where companyId = ? and classNameId = ?. 1981 * 1982 * @param companyId the company ID 1983 * @param classNameId the class name ID 1984 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1985 * @return the first matching d d m structure 1986 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 1987 * @throws SystemException if a system exception occurred 1988 */ 1989 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_First( 1990 long companyId, long classNameId, 1991 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1992 throws com.liferay.portal.kernel.exception.SystemException, 1993 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 1994 return getPersistence() 1995 .findByC_C_First(companyId, classNameId, orderByComparator); 1996 } 1997 1998 /** 1999 * Returns the first d d m structure in the ordered set where companyId = ? and classNameId = ?. 2000 * 2001 * @param companyId the company ID 2002 * @param classNameId the class name ID 2003 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2004 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 2005 * @throws SystemException if a system exception occurred 2006 */ 2007 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_First( 2008 long companyId, long classNameId, 2009 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2010 throws com.liferay.portal.kernel.exception.SystemException { 2011 return getPersistence() 2012 .fetchByC_C_First(companyId, classNameId, orderByComparator); 2013 } 2014 2015 /** 2016 * Returns the last d d m structure in the ordered set where companyId = ? and classNameId = ?. 2017 * 2018 * @param companyId the company ID 2019 * @param classNameId the class name ID 2020 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2021 * @return the last matching d d m structure 2022 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 2023 * @throws SystemException if a system exception occurred 2024 */ 2025 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_Last( 2026 long companyId, long classNameId, 2027 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2028 throws com.liferay.portal.kernel.exception.SystemException, 2029 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2030 return getPersistence() 2031 .findByC_C_Last(companyId, classNameId, orderByComparator); 2032 } 2033 2034 /** 2035 * Returns the last d d m structure in the ordered set where companyId = ? and classNameId = ?. 2036 * 2037 * @param companyId the company ID 2038 * @param classNameId the class name ID 2039 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2040 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 2041 * @throws SystemException if a system exception occurred 2042 */ 2043 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_Last( 2044 long companyId, long classNameId, 2045 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2046 throws com.liferay.portal.kernel.exception.SystemException { 2047 return getPersistence() 2048 .fetchByC_C_Last(companyId, classNameId, orderByComparator); 2049 } 2050 2051 /** 2052 * Returns the d d m structures before and after the current d d m structure in the ordered set where companyId = ? and classNameId = ?. 2053 * 2054 * @param structureId the primary key of the current d d m structure 2055 * @param companyId the company ID 2056 * @param classNameId the class name ID 2057 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2058 * @return the previous, current, and next d d m structure 2059 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 2060 * @throws SystemException if a system exception occurred 2061 */ 2062 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByC_C_PrevAndNext( 2063 long structureId, long companyId, long classNameId, 2064 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2065 throws com.liferay.portal.kernel.exception.SystemException, 2066 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2067 return getPersistence() 2068 .findByC_C_PrevAndNext(structureId, companyId, classNameId, 2069 orderByComparator); 2070 } 2071 2072 /** 2073 * Removes all the d d m structures where companyId = ? and classNameId = ? from the database. 2074 * 2075 * @param companyId the company ID 2076 * @param classNameId the class name ID 2077 * @throws SystemException if a system exception occurred 2078 */ 2079 public static void removeByC_C(long companyId, long classNameId) 2080 throws com.liferay.portal.kernel.exception.SystemException { 2081 getPersistence().removeByC_C(companyId, classNameId); 2082 } 2083 2084 /** 2085 * Returns the number of d d m structures where companyId = ? and classNameId = ?. 2086 * 2087 * @param companyId the company ID 2088 * @param classNameId the class name ID 2089 * @return the number of matching d d m structures 2090 * @throws SystemException if a system exception occurred 2091 */ 2092 public static int countByC_C(long companyId, long classNameId) 2093 throws com.liferay.portal.kernel.exception.SystemException { 2094 return getPersistence().countByC_C(companyId, classNameId); 2095 } 2096 2097 /** 2098 * Returns the d d m structure where groupId = ? and classNameId = ? and structureKey = ? or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found. 2099 * 2100 * @param groupId the group ID 2101 * @param classNameId the class name ID 2102 * @param structureKey the structure key 2103 * @return the matching d d m structure 2104 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 2105 * @throws SystemException if a system exception occurred 2106 */ 2107 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_S( 2108 long groupId, long classNameId, java.lang.String structureKey) 2109 throws com.liferay.portal.kernel.exception.SystemException, 2110 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2111 return getPersistence().findByG_C_S(groupId, classNameId, structureKey); 2112 } 2113 2114 /** 2115 * Returns the d d m structure where groupId = ? and classNameId = ? and structureKey = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2116 * 2117 * @param groupId the group ID 2118 * @param classNameId the class name ID 2119 * @param structureKey the structure key 2120 * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 2121 * @throws SystemException if a system exception occurred 2122 */ 2123 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S( 2124 long groupId, long classNameId, java.lang.String structureKey) 2125 throws com.liferay.portal.kernel.exception.SystemException { 2126 return getPersistence().fetchByG_C_S(groupId, classNameId, structureKey); 2127 } 2128 2129 /** 2130 * Returns the d d m structure where groupId = ? and classNameId = ? and structureKey = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2131 * 2132 * @param groupId the group ID 2133 * @param classNameId the class name ID 2134 * @param structureKey the structure key 2135 * @param retrieveFromCache whether to use the finder cache 2136 * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 2137 * @throws SystemException if a system exception occurred 2138 */ 2139 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S( 2140 long groupId, long classNameId, java.lang.String structureKey, 2141 boolean retrieveFromCache) 2142 throws com.liferay.portal.kernel.exception.SystemException { 2143 return getPersistence() 2144 .fetchByG_C_S(groupId, classNameId, structureKey, 2145 retrieveFromCache); 2146 } 2147 2148 /** 2149 * Removes the d d m structure where groupId = ? and classNameId = ? and structureKey = ? from the database. 2150 * 2151 * @param groupId the group ID 2152 * @param classNameId the class name ID 2153 * @param structureKey the structure key 2154 * @return the d d m structure that was removed 2155 * @throws SystemException if a system exception occurred 2156 */ 2157 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByG_C_S( 2158 long groupId, long classNameId, java.lang.String structureKey) 2159 throws com.liferay.portal.kernel.exception.SystemException, 2160 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2161 return getPersistence().removeByG_C_S(groupId, classNameId, structureKey); 2162 } 2163 2164 /** 2165 * Returns the number of d d m structures where groupId = ? and classNameId = ? and structureKey = ?. 2166 * 2167 * @param groupId the group ID 2168 * @param classNameId the class name ID 2169 * @param structureKey the structure key 2170 * @return the number of matching d d m structures 2171 * @throws SystemException if a system exception occurred 2172 */ 2173 public static int countByG_C_S(long groupId, long classNameId, 2174 java.lang.String structureKey) 2175 throws com.liferay.portal.kernel.exception.SystemException { 2176 return getPersistence().countByG_C_S(groupId, classNameId, structureKey); 2177 } 2178 2179 /** 2180 * Returns all the d d m structures where groupId = ? and name = ? and description = ?. 2181 * 2182 * @param groupId the group ID 2183 * @param name the name 2184 * @param description the description 2185 * @return the matching d d m structures 2186 * @throws SystemException if a system exception occurred 2187 */ 2188 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D( 2189 long groupId, java.lang.String name, java.lang.String description) 2190 throws com.liferay.portal.kernel.exception.SystemException { 2191 return getPersistence().findByG_N_D(groupId, name, description); 2192 } 2193 2194 /** 2195 * Returns a range of all the d d m structures where groupId = ? and name = ? and description = ?. 2196 * 2197 * <p> 2198 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2199 * </p> 2200 * 2201 * @param groupId the group ID 2202 * @param name the name 2203 * @param description the description 2204 * @param start the lower bound of the range of d d m structures 2205 * @param end the upper bound of the range of d d m structures (not inclusive) 2206 * @return the range of matching d d m structures 2207 * @throws SystemException if a system exception occurred 2208 */ 2209 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D( 2210 long groupId, java.lang.String name, java.lang.String description, 2211 int start, int end) 2212 throws com.liferay.portal.kernel.exception.SystemException { 2213 return getPersistence() 2214 .findByG_N_D(groupId, name, description, start, end); 2215 } 2216 2217 /** 2218 * Returns an ordered range of all the d d m structures where groupId = ? and name = ? and description = ?. 2219 * 2220 * <p> 2221 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2222 * </p> 2223 * 2224 * @param groupId the group ID 2225 * @param name the name 2226 * @param description the description 2227 * @param start the lower bound of the range of d d m structures 2228 * @param end the upper bound of the range of d d m structures (not inclusive) 2229 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2230 * @return the ordered range of matching d d m structures 2231 * @throws SystemException if a system exception occurred 2232 */ 2233 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D( 2234 long groupId, java.lang.String name, java.lang.String description, 2235 int start, int end, 2236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2237 throws com.liferay.portal.kernel.exception.SystemException { 2238 return getPersistence() 2239 .findByG_N_D(groupId, name, description, start, end, 2240 orderByComparator); 2241 } 2242 2243 /** 2244 * Returns the first d d m structure in the ordered set where groupId = ? and name = ? and description = ?. 2245 * 2246 * @param groupId the group ID 2247 * @param name the name 2248 * @param description the description 2249 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2250 * @return the first matching d d m structure 2251 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 2252 * @throws SystemException if a system exception occurred 2253 */ 2254 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_First( 2255 long groupId, java.lang.String name, java.lang.String description, 2256 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2257 throws com.liferay.portal.kernel.exception.SystemException, 2258 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2259 return getPersistence() 2260 .findByG_N_D_First(groupId, name, description, 2261 orderByComparator); 2262 } 2263 2264 /** 2265 * Returns the first d d m structure in the ordered set where groupId = ? and name = ? and description = ?. 2266 * 2267 * @param groupId the group ID 2268 * @param name the name 2269 * @param description the description 2270 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2271 * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 2272 * @throws SystemException if a system exception occurred 2273 */ 2274 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_First( 2275 long groupId, java.lang.String name, java.lang.String description, 2276 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2277 throws com.liferay.portal.kernel.exception.SystemException { 2278 return getPersistence() 2279 .fetchByG_N_D_First(groupId, name, description, 2280 orderByComparator); 2281 } 2282 2283 /** 2284 * Returns the last d d m structure in the ordered set where groupId = ? and name = ? and description = ?. 2285 * 2286 * @param groupId the group ID 2287 * @param name the name 2288 * @param description the description 2289 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2290 * @return the last matching d d m structure 2291 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found 2292 * @throws SystemException if a system exception occurred 2293 */ 2294 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_Last( 2295 long groupId, java.lang.String name, java.lang.String description, 2296 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2297 throws com.liferay.portal.kernel.exception.SystemException, 2298 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2299 return getPersistence() 2300 .findByG_N_D_Last(groupId, name, description, 2301 orderByComparator); 2302 } 2303 2304 /** 2305 * Returns the last d d m structure in the ordered set where groupId = ? and name = ? and description = ?. 2306 * 2307 * @param groupId the group ID 2308 * @param name the name 2309 * @param description the description 2310 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2311 * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found 2312 * @throws SystemException if a system exception occurred 2313 */ 2314 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_Last( 2315 long groupId, java.lang.String name, java.lang.String description, 2316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2317 throws com.liferay.portal.kernel.exception.SystemException { 2318 return getPersistence() 2319 .fetchByG_N_D_Last(groupId, name, description, 2320 orderByComparator); 2321 } 2322 2323 /** 2324 * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = ? and name = ? and description = ?. 2325 * 2326 * @param structureId the primary key of the current d d m structure 2327 * @param groupId the group ID 2328 * @param name the name 2329 * @param description the description 2330 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2331 * @return the previous, current, and next d d m structure 2332 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 2333 * @throws SystemException if a system exception occurred 2334 */ 2335 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_N_D_PrevAndNext( 2336 long structureId, long groupId, java.lang.String name, 2337 java.lang.String description, 2338 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2339 throws com.liferay.portal.kernel.exception.SystemException, 2340 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2341 return getPersistence() 2342 .findByG_N_D_PrevAndNext(structureId, groupId, name, 2343 description, orderByComparator); 2344 } 2345 2346 /** 2347 * Returns all the d d m structures that the user has permission to view where groupId = ? and name = ? and description = ?. 2348 * 2349 * @param groupId the group ID 2350 * @param name the name 2351 * @param description the description 2352 * @return the matching d d m structures that the user has permission to view 2353 * @throws SystemException if a system exception occurred 2354 */ 2355 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D( 2356 long groupId, java.lang.String name, java.lang.String description) 2357 throws com.liferay.portal.kernel.exception.SystemException { 2358 return getPersistence().filterFindByG_N_D(groupId, name, description); 2359 } 2360 2361 /** 2362 * Returns a range of all the d d m structures that the user has permission to view where groupId = ? and name = ? and description = ?. 2363 * 2364 * <p> 2365 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2366 * </p> 2367 * 2368 * @param groupId the group ID 2369 * @param name the name 2370 * @param description the description 2371 * @param start the lower bound of the range of d d m structures 2372 * @param end the upper bound of the range of d d m structures (not inclusive) 2373 * @return the range of matching d d m structures that the user has permission to view 2374 * @throws SystemException if a system exception occurred 2375 */ 2376 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D( 2377 long groupId, java.lang.String name, java.lang.String description, 2378 int start, int end) 2379 throws com.liferay.portal.kernel.exception.SystemException { 2380 return getPersistence() 2381 .filterFindByG_N_D(groupId, name, description, start, end); 2382 } 2383 2384 /** 2385 * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = ? and name = ? and description = ?. 2386 * 2387 * <p> 2388 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2389 * </p> 2390 * 2391 * @param groupId the group ID 2392 * @param name the name 2393 * @param description the description 2394 * @param start the lower bound of the range of d d m structures 2395 * @param end the upper bound of the range of d d m structures (not inclusive) 2396 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2397 * @return the ordered range of matching d d m structures that the user has permission to view 2398 * @throws SystemException if a system exception occurred 2399 */ 2400 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D( 2401 long groupId, java.lang.String name, java.lang.String description, 2402 int start, int end, 2403 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2404 throws com.liferay.portal.kernel.exception.SystemException { 2405 return getPersistence() 2406 .filterFindByG_N_D(groupId, name, description, start, end, 2407 orderByComparator); 2408 } 2409 2410 /** 2411 * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = ? and name = ? and description = ?. 2412 * 2413 * @param structureId the primary key of the current d d m structure 2414 * @param groupId the group ID 2415 * @param name the name 2416 * @param description the description 2417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2418 * @return the previous, current, and next d d m structure 2419 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 2420 * @throws SystemException if a system exception occurred 2421 */ 2422 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_N_D_PrevAndNext( 2423 long structureId, long groupId, java.lang.String name, 2424 java.lang.String description, 2425 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2426 throws com.liferay.portal.kernel.exception.SystemException, 2427 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2428 return getPersistence() 2429 .filterFindByG_N_D_PrevAndNext(structureId, groupId, name, 2430 description, orderByComparator); 2431 } 2432 2433 /** 2434 * Removes all the d d m structures where groupId = ? and name = ? and description = ? from the database. 2435 * 2436 * @param groupId the group ID 2437 * @param name the name 2438 * @param description the description 2439 * @throws SystemException if a system exception occurred 2440 */ 2441 public static void removeByG_N_D(long groupId, java.lang.String name, 2442 java.lang.String description) 2443 throws com.liferay.portal.kernel.exception.SystemException { 2444 getPersistence().removeByG_N_D(groupId, name, description); 2445 } 2446 2447 /** 2448 * Returns the number of d d m structures where groupId = ? and name = ? and description = ?. 2449 * 2450 * @param groupId the group ID 2451 * @param name the name 2452 * @param description the description 2453 * @return the number of matching d d m structures 2454 * @throws SystemException if a system exception occurred 2455 */ 2456 public static int countByG_N_D(long groupId, java.lang.String name, 2457 java.lang.String description) 2458 throws com.liferay.portal.kernel.exception.SystemException { 2459 return getPersistence().countByG_N_D(groupId, name, description); 2460 } 2461 2462 /** 2463 * Returns the number of d d m structures that the user has permission to view where groupId = ? and name = ? and description = ?. 2464 * 2465 * @param groupId the group ID 2466 * @param name the name 2467 * @param description the description 2468 * @return the number of matching d d m structures that the user has permission to view 2469 * @throws SystemException if a system exception occurred 2470 */ 2471 public static int filterCountByG_N_D(long groupId, java.lang.String name, 2472 java.lang.String description) 2473 throws com.liferay.portal.kernel.exception.SystemException { 2474 return getPersistence().filterCountByG_N_D(groupId, name, description); 2475 } 2476 2477 /** 2478 * Caches the d d m structure in the entity cache if it is enabled. 2479 * 2480 * @param ddmStructure the d d m structure 2481 */ 2482 public static void cacheResult( 2483 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) { 2484 getPersistence().cacheResult(ddmStructure); 2485 } 2486 2487 /** 2488 * Caches the d d m structures in the entity cache if it is enabled. 2489 * 2490 * @param ddmStructures the d d m structures 2491 */ 2492 public static void cacheResult( 2493 java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) { 2494 getPersistence().cacheResult(ddmStructures); 2495 } 2496 2497 /** 2498 * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database. 2499 * 2500 * @param structureId the primary key for the new d d m structure 2501 * @return the new d d m structure 2502 */ 2503 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure create( 2504 long structureId) { 2505 return getPersistence().create(structureId); 2506 } 2507 2508 /** 2509 * Removes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners. 2510 * 2511 * @param structureId the primary key of the d d m structure 2512 * @return the d d m structure that was removed 2513 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 2514 * @throws SystemException if a system exception occurred 2515 */ 2516 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure remove( 2517 long structureId) 2518 throws com.liferay.portal.kernel.exception.SystemException, 2519 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2520 return getPersistence().remove(structureId); 2521 } 2522 2523 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateImpl( 2524 com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) 2525 throws com.liferay.portal.kernel.exception.SystemException { 2526 return getPersistence().updateImpl(ddmStructure); 2527 } 2528 2529 /** 2530 * Returns the d d m structure with the primary key or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found. 2531 * 2532 * @param structureId the primary key of the d d m structure 2533 * @return the d d m structure 2534 * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found 2535 * @throws SystemException if a system exception occurred 2536 */ 2537 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByPrimaryKey( 2538 long structureId) 2539 throws com.liferay.portal.kernel.exception.SystemException, 2540 com.liferay.portlet.dynamicdatamapping.NoSuchStructureException { 2541 return getPersistence().findByPrimaryKey(structureId); 2542 } 2543 2544 /** 2545 * Returns the d d m structure with the primary key or returns <code>null</code> if it could not be found. 2546 * 2547 * @param structureId the primary key of the d d m structure 2548 * @return the d d m structure, or <code>null</code> if a d d m structure with the primary key could not be found 2549 * @throws SystemException if a system exception occurred 2550 */ 2551 public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByPrimaryKey( 2552 long structureId) 2553 throws com.liferay.portal.kernel.exception.SystemException { 2554 return getPersistence().fetchByPrimaryKey(structureId); 2555 } 2556 2557 /** 2558 * Returns all the d d m structures. 2559 * 2560 * @return the d d m structures 2561 * @throws SystemException if a system exception occurred 2562 */ 2563 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll() 2564 throws com.liferay.portal.kernel.exception.SystemException { 2565 return getPersistence().findAll(); 2566 } 2567 2568 /** 2569 * Returns a range of all the d d m structures. 2570 * 2571 * <p> 2572 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2573 * </p> 2574 * 2575 * @param start the lower bound of the range of d d m structures 2576 * @param end the upper bound of the range of d d m structures (not inclusive) 2577 * @return the range of d d m structures 2578 * @throws SystemException if a system exception occurred 2579 */ 2580 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll( 2581 int start, int end) 2582 throws com.liferay.portal.kernel.exception.SystemException { 2583 return getPersistence().findAll(start, end); 2584 } 2585 2586 /** 2587 * Returns an ordered range of all the d d m structures. 2588 * 2589 * <p> 2590 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2591 * </p> 2592 * 2593 * @param start the lower bound of the range of d d m structures 2594 * @param end the upper bound of the range of d d m structures (not inclusive) 2595 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2596 * @return the ordered range of d d m structures 2597 * @throws SystemException if a system exception occurred 2598 */ 2599 public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll( 2600 int start, int end, 2601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2602 throws com.liferay.portal.kernel.exception.SystemException { 2603 return getPersistence().findAll(start, end, orderByComparator); 2604 } 2605 2606 /** 2607 * Removes all the d d m structures from the database. 2608 * 2609 * @throws SystemException if a system exception occurred 2610 */ 2611 public static void removeAll() 2612 throws com.liferay.portal.kernel.exception.SystemException { 2613 getPersistence().removeAll(); 2614 } 2615 2616 /** 2617 * Returns the number of d d m structures. 2618 * 2619 * @return the number of d d m structures 2620 * @throws SystemException if a system exception occurred 2621 */ 2622 public static int countAll() 2623 throws com.liferay.portal.kernel.exception.SystemException { 2624 return getPersistence().countAll(); 2625 } 2626 2627 /** 2628 * Returns all the document library file entry types associated with the d d m structure. 2629 * 2630 * @param pk the primary key of the d d m structure 2631 * @return the document library file entry types associated with the d d m structure 2632 * @throws SystemException if a system exception occurred 2633 */ 2634 public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes( 2635 long pk) throws com.liferay.portal.kernel.exception.SystemException { 2636 return getPersistence().getDLFileEntryTypes(pk); 2637 } 2638 2639 /** 2640 * Returns a range of all the document library file entry types associated with the d d m structure. 2641 * 2642 * <p> 2643 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2644 * </p> 2645 * 2646 * @param pk the primary key of the d d m structure 2647 * @param start the lower bound of the range of d d m structures 2648 * @param end the upper bound of the range of d d m structures (not inclusive) 2649 * @return the range of document library file entry types associated with the d d m structure 2650 * @throws SystemException if a system exception occurred 2651 */ 2652 public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes( 2653 long pk, int start, int end) 2654 throws com.liferay.portal.kernel.exception.SystemException { 2655 return getPersistence().getDLFileEntryTypes(pk, start, end); 2656 } 2657 2658 /** 2659 * Returns an ordered range of all the document library file entry types associated with the d d m structure. 2660 * 2661 * <p> 2662 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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. 2663 * </p> 2664 * 2665 * @param pk the primary key of the d d m structure 2666 * @param start the lower bound of the range of d d m structures 2667 * @param end the upper bound of the range of d d m structures (not inclusive) 2668 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2669 * @return the ordered range of document library file entry types associated with the d d m structure 2670 * @throws SystemException if a system exception occurred 2671 */ 2672 public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes( 2673 long pk, int start, int end, 2674 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2675 throws com.liferay.portal.kernel.exception.SystemException { 2676 return getPersistence() 2677 .getDLFileEntryTypes(pk, start, end, orderByComparator); 2678 } 2679 2680 /** 2681 * Returns the number of document library file entry types associated with the d d m structure. 2682 * 2683 * @param pk the primary key of the d d m structure 2684 * @return the number of document library file entry types associated with the d d m structure 2685 * @throws SystemException if a system exception occurred 2686 */ 2687 public static int getDLFileEntryTypesSize(long pk) 2688 throws com.liferay.portal.kernel.exception.SystemException { 2689 return getPersistence().getDLFileEntryTypesSize(pk); 2690 } 2691 2692 /** 2693 * Returns <code>true</code> if the document library file entry type is associated with the d d m structure. 2694 * 2695 * @param pk the primary key of the d d m structure 2696 * @param dlFileEntryTypePK the primary key of the document library file entry type 2697 * @return <code>true</code> if the document library file entry type is associated with the d d m structure; <code>false</code> otherwise 2698 * @throws SystemException if a system exception occurred 2699 */ 2700 public static boolean containsDLFileEntryType(long pk, 2701 long dlFileEntryTypePK) 2702 throws com.liferay.portal.kernel.exception.SystemException { 2703 return getPersistence().containsDLFileEntryType(pk, dlFileEntryTypePK); 2704 } 2705 2706 /** 2707 * Returns <code>true</code> if the d d m structure has any document library file entry types associated with it. 2708 * 2709 * @param pk the primary key of the d d m structure to check for associations with document library file entry types 2710 * @return <code>true</code> if the d d m structure has any document library file entry types associated with it; <code>false</code> otherwise 2711 * @throws SystemException if a system exception occurred 2712 */ 2713 public static boolean containsDLFileEntryTypes(long pk) 2714 throws com.liferay.portal.kernel.exception.SystemException { 2715 return getPersistence().containsDLFileEntryTypes(pk); 2716 } 2717 2718 /** 2719 * Adds an association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2720 * 2721 * @param pk the primary key of the d d m structure 2722 * @param dlFileEntryTypePK the primary key of the document library file entry type 2723 * @throws SystemException if a system exception occurred 2724 */ 2725 public static void addDLFileEntryType(long pk, long dlFileEntryTypePK) 2726 throws com.liferay.portal.kernel.exception.SystemException { 2727 getPersistence().addDLFileEntryType(pk, dlFileEntryTypePK); 2728 } 2729 2730 /** 2731 * Adds an association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2732 * 2733 * @param pk the primary key of the d d m structure 2734 * @param dlFileEntryType the document library file entry type 2735 * @throws SystemException if a system exception occurred 2736 */ 2737 public static void addDLFileEntryType(long pk, 2738 com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType) 2739 throws com.liferay.portal.kernel.exception.SystemException { 2740 getPersistence().addDLFileEntryType(pk, dlFileEntryType); 2741 } 2742 2743 /** 2744 * Adds an association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2745 * 2746 * @param pk the primary key of the d d m structure 2747 * @param dlFileEntryTypePKs the primary keys of the document library file entry types 2748 * @throws SystemException if a system exception occurred 2749 */ 2750 public static void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) 2751 throws com.liferay.portal.kernel.exception.SystemException { 2752 getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypePKs); 2753 } 2754 2755 /** 2756 * Adds an association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2757 * 2758 * @param pk the primary key of the d d m structure 2759 * @param dlFileEntryTypes the document library file entry types 2760 * @throws SystemException if a system exception occurred 2761 */ 2762 public static void addDLFileEntryTypes(long pk, 2763 java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) 2764 throws com.liferay.portal.kernel.exception.SystemException { 2765 getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypes); 2766 } 2767 2768 /** 2769 * Clears all associations between the d d m structure and its document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2770 * 2771 * @param pk the primary key of the d d m structure to clear the associated document library file entry types from 2772 * @throws SystemException if a system exception occurred 2773 */ 2774 public static void clearDLFileEntryTypes(long pk) 2775 throws com.liferay.portal.kernel.exception.SystemException { 2776 getPersistence().clearDLFileEntryTypes(pk); 2777 } 2778 2779 /** 2780 * Removes the association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2781 * 2782 * @param pk the primary key of the d d m structure 2783 * @param dlFileEntryTypePK the primary key of the document library file entry type 2784 * @throws SystemException if a system exception occurred 2785 */ 2786 public static void removeDLFileEntryType(long pk, long dlFileEntryTypePK) 2787 throws com.liferay.portal.kernel.exception.SystemException { 2788 getPersistence().removeDLFileEntryType(pk, dlFileEntryTypePK); 2789 } 2790 2791 /** 2792 * Removes the association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2793 * 2794 * @param pk the primary key of the d d m structure 2795 * @param dlFileEntryType the document library file entry type 2796 * @throws SystemException if a system exception occurred 2797 */ 2798 public static void removeDLFileEntryType(long pk, 2799 com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType) 2800 throws com.liferay.portal.kernel.exception.SystemException { 2801 getPersistence().removeDLFileEntryType(pk, dlFileEntryType); 2802 } 2803 2804 /** 2805 * Removes the association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2806 * 2807 * @param pk the primary key of the d d m structure 2808 * @param dlFileEntryTypePKs the primary keys of the document library file entry types 2809 * @throws SystemException if a system exception occurred 2810 */ 2811 public static void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) 2812 throws com.liferay.portal.kernel.exception.SystemException { 2813 getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypePKs); 2814 } 2815 2816 /** 2817 * Removes the association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2818 * 2819 * @param pk the primary key of the d d m structure 2820 * @param dlFileEntryTypes the document library file entry types 2821 * @throws SystemException if a system exception occurred 2822 */ 2823 public static void removeDLFileEntryTypes(long pk, 2824 java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) 2825 throws com.liferay.portal.kernel.exception.SystemException { 2826 getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypes); 2827 } 2828 2829 /** 2830 * Sets the document library file entry types associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2831 * 2832 * @param pk the primary key of the d d m structure 2833 * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the d d m structure 2834 * @throws SystemException if a system exception occurred 2835 */ 2836 public static void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs) 2837 throws com.liferay.portal.kernel.exception.SystemException { 2838 getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypePKs); 2839 } 2840 2841 /** 2842 * Sets the document library file entry types associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2843 * 2844 * @param pk the primary key of the d d m structure 2845 * @param dlFileEntryTypes the document library file entry types to be associated with the d d m structure 2846 * @throws SystemException if a system exception occurred 2847 */ 2848 public static void setDLFileEntryTypes(long pk, 2849 java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes) 2850 throws com.liferay.portal.kernel.exception.SystemException { 2851 getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypes); 2852 } 2853 2854 public static DDMStructurePersistence getPersistence() { 2855 if (_persistence == null) { 2856 _persistence = (DDMStructurePersistence)PortalBeanLocatorUtil.locate(DDMStructurePersistence.class.getName()); 2857 2858 ReferenceRegistry.registerReference(DDMStructureUtil.class, 2859 "_persistence"); 2860 } 2861 2862 return _persistence; 2863 } 2864 2865 /** 2866 * @deprecated As of 6.2.0 2867 */ 2868 public void setPersistence(DDMStructurePersistence persistence) { 2869 } 2870 2871 private static DDMStructurePersistence _persistence; 2872 }