LayoutSetUtil

java.lang.Object
- com.liferay.portal.kernel.service.persistence.LayoutSetUtil

```
@ProviderType
public class LayoutSetUtil
extends java.lang.Object
```
The persistence utility for the layout set service. This utility wraps com.liferay.portal.service.persistence.impl.LayoutSetPersistenceImpl 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.
Caching information and settings can be found in portal.properties

Author:

Brian Wing Shun Chan

See Also:

LayoutSetPersistence

Generated:

Constructor Summary

Constructors
Constructor and Description

LayoutSetUtil()

Constructors
Constructor and Description
`LayoutSetUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`cacheResult(LayoutSet layoutSet)` Caches the layout set in the entity cache if it is enabled.
`static void`	`cacheResult(java.util.List<LayoutSet> layoutSets)` Caches the layout sets in the entity cache if it is enabled.
`static void`	`clearCache()`
`static void`	`clearCache(LayoutSet layoutSet)`
`static int`	`countAll()` Returns the number of layout sets.
`static int`	`countByG_P_Head(long groupId, boolean privateLayout, boolean head)` Returns the number of layout sets where groupId = ? and privateLayout = ? and head = ?.
`static int`	`countByG_P(long groupId, boolean privateLayout)` Returns the number of layout sets where groupId = ? and privateLayout = ?.
`static int`	`countByGroupId_Head(long groupId, boolean head)` Returns the number of layout sets where groupId = ? and head = ?.
`static int`	`countByGroupId(long groupId)` Returns the number of layout sets where groupId = ?.
`static int`	`countByHeadId(long headId)` Returns the number of layout sets where headId = ?.
`static int`	`countByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid, boolean head)` Returns the number of layout sets where layoutSetPrototypeUuid = ? and head = ?.
`static int`	`countByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)` Returns the number of layout sets where layoutSetPrototypeUuid = ?.
`static int`	`countByP_L_Head(boolean privateLayout, long logoId, boolean head)` Returns the number of layout sets where privateLayout = ? and logoId = ? and head = ?.
`static int`	`countByP_L(boolean privateLayout, long logoId)` Returns the number of layout sets where privateLayout = ? and logoId = ?.
`static long`	`countWithDynamicQuery(DynamicQuery dynamicQuery)`
`static LayoutSet`	`create(long layoutSetId)` Creates a new layout set with the primary key.
`static LayoutSet`	`fetchByG_P_First(long groupId, boolean privateLayout, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where groupId = ? and privateLayout = ?.
`static LayoutSet`	`fetchByG_P_Head(long groupId, boolean privateLayout, boolean head)` Returns the layout set where groupId = ? and privateLayout = ? and head = ? or returns `null` if it could not be found.
`static LayoutSet`	`fetchByG_P_Head(long groupId, boolean privateLayout, boolean head, boolean retrieveFromCache)` Returns the layout set where groupId = ? and privateLayout = ? and head = ? or returns `null` if it could not be found, optionally using the finder cache.
`static LayoutSet`	`fetchByG_P_Last(long groupId, boolean privateLayout, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where groupId = ? and privateLayout = ?.
`static LayoutSet`	`fetchByGroupId_First(long groupId, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where groupId = ?.
`static LayoutSet`	`fetchByGroupId_Head_First(long groupId, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where groupId = ? and head = ?.
`static LayoutSet`	`fetchByGroupId_Head_Last(long groupId, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where groupId = ? and head = ?.
`static LayoutSet`	`fetchByGroupId_Last(long groupId, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where groupId = ?.
`static LayoutSet`	`fetchByHeadId(long headId)` Returns the layout set where headId = ? or returns `null` if it could not be found.
`static LayoutSet`	`fetchByHeadId(long headId, boolean retrieveFromCache)` Returns the layout set where headId = ? or returns `null` if it could not be found, optionally using the finder cache.
`static LayoutSet`	`fetchByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSet`	`fetchByLayoutSetPrototypeUuid_Head_First(java.lang.String layoutSetPrototypeUuid, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
`static LayoutSet`	`fetchByLayoutSetPrototypeUuid_Head_Last(java.lang.String layoutSetPrototypeUuid, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
`static LayoutSet`	`fetchByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSet`	`fetchByP_L_First(boolean privateLayout, long logoId, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where privateLayout = ? and logoId = ?.
`static LayoutSet`	`fetchByP_L_Head(boolean privateLayout, long logoId, boolean head)` Returns the layout set where privateLayout = ? and logoId = ? and head = ? or returns `null` if it could not be found.
`static LayoutSet`	`fetchByP_L_Head(boolean privateLayout, long logoId, boolean head, boolean retrieveFromCache)` Returns the layout set where privateLayout = ? and logoId = ? and head = ? or returns `null` if it could not be found, optionally using the finder cache.
`static LayoutSet`	`fetchByP_L_Last(boolean privateLayout, long logoId, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where privateLayout = ? and logoId = ?.
`static LayoutSet`	`fetchByPrimaryKey(long layoutSetId)` Returns the layout set with the primary key or returns `null` if it could not be found.
`static java.util.Map<java.io.Serializable,LayoutSet>`	`fetchByPrimaryKeys(java.util.Set<java.io.Serializable> primaryKeys)`
`static java.util.List<LayoutSet>`	`findAll()` Returns all the layout sets.
`static java.util.List<LayoutSet>`	`findAll(int start, int end)` Returns a range of all the layout sets.
`static java.util.List<LayoutSet>`	`findAll(int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets.
`static java.util.List<LayoutSet>`	`findAll(int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets.
`static LayoutSet`	`findByG_P_First(long groupId, boolean privateLayout, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where groupId = ? and privateLayout = ?.
`static LayoutSet`	`findByG_P_Head(long groupId, boolean privateLayout, boolean head)` Returns the layout set where groupId = ? and privateLayout = ? and head = ? or throws a `NoSuchLayoutSetException` if it could not be found.
`static LayoutSet`	`findByG_P_Last(long groupId, boolean privateLayout, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where groupId = ? and privateLayout = ?.
`static LayoutSet[]`	`findByG_P_PrevAndNext(long layoutSetId, long groupId, boolean privateLayout, OrderByComparator<LayoutSet> orderByComparator)` Returns the layout sets before and after the current layout set in the ordered set where groupId = ? and privateLayout = ?.
`static java.util.List<LayoutSet>`	`findByG_P(long groupId, boolean privateLayout)` Returns all the layout sets where groupId = ? and privateLayout = ?.
`static java.util.List<LayoutSet>`	`findByG_P(long groupId, boolean privateLayout, int start, int end)` Returns a range of all the layout sets where groupId = ? and privateLayout = ?.
`static java.util.List<LayoutSet>`	`findByG_P(long groupId, boolean privateLayout, int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets where groupId = ? and privateLayout = ?.
`static java.util.List<LayoutSet>`	`findByG_P(long groupId, boolean privateLayout, int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets where groupId = ? and privateLayout = ?.
`static LayoutSet`	`findByGroupId_First(long groupId, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where groupId = ?.
`static LayoutSet`	`findByGroupId_Head_First(long groupId, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where groupId = ? and head = ?.
`static LayoutSet`	`findByGroupId_Head_Last(long groupId, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where groupId = ? and head = ?.
`static LayoutSet[]`	`findByGroupId_Head_PrevAndNext(long layoutSetId, long groupId, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the layout sets before and after the current layout set in the ordered set where groupId = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByGroupId_Head(long groupId, boolean head)` Returns all the layout sets where groupId = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByGroupId_Head(long groupId, boolean head, int start, int end)` Returns a range of all the layout sets where groupId = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByGroupId_Head(long groupId, boolean head, int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets where groupId = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByGroupId_Head(long groupId, boolean head, int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets where groupId = ? and head = ?.
`static LayoutSet`	`findByGroupId_Last(long groupId, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where groupId = ?.
`static LayoutSet[]`	`findByGroupId_PrevAndNext(long layoutSetId, long groupId, OrderByComparator<LayoutSet> orderByComparator)` Returns the layout sets before and after the current layout set in the ordered set where groupId = ?.
`static java.util.List<LayoutSet>`	`findByGroupId(long groupId)` Returns all the layout sets where groupId = ?.
`static java.util.List<LayoutSet>`	`findByGroupId(long groupId, int start, int end)` Returns a range of all the layout sets where groupId = ?.
`static java.util.List<LayoutSet>`	`findByGroupId(long groupId, int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets where groupId = ?.
`static java.util.List<LayoutSet>`	`findByGroupId(long groupId, int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets where groupId = ?.
`static LayoutSet`	`findByHeadId(long headId)` Returns the layout set where headId = ? or throws a `NoSuchLayoutSetException` if it could not be found.
`static LayoutSet`	`findByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSet`	`findByLayoutSetPrototypeUuid_Head_First(java.lang.String layoutSetPrototypeUuid, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
`static LayoutSet`	`findByLayoutSetPrototypeUuid_Head_Last(java.lang.String layoutSetPrototypeUuid, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
`static LayoutSet[]`	`findByLayoutSetPrototypeUuid_Head_PrevAndNext(long layoutSetId, java.lang.String layoutSetPrototypeUuid, boolean head, OrderByComparator<LayoutSet> orderByComparator)` Returns the layout sets before and after the current layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid, boolean head)` Returns all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid, boolean head, int start, int end)` Returns a range of all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid, boolean head, int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid, boolean head, int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
`static LayoutSet`	`findByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ?.
`static LayoutSet[]`	`findByLayoutSetPrototypeUuid_PrevAndNext(long layoutSetId, java.lang.String layoutSetPrototypeUuid, OrderByComparator<LayoutSet> orderByComparator)` Returns the layout sets before and after the current layout set in the ordered set where layoutSetPrototypeUuid = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)` Returns all the layout sets where layoutSetPrototypeUuid = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid, int start, int end)` Returns a range of all the layout sets where layoutSetPrototypeUuid = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ?.
`static java.util.List<LayoutSet>`	`findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid, int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ?.
`static LayoutSet`	`findByP_L_First(boolean privateLayout, long logoId, OrderByComparator<LayoutSet> orderByComparator)` Returns the first layout set in the ordered set where privateLayout = ? and logoId = ?.
`static LayoutSet`	`findByP_L_Head(boolean privateLayout, long logoId, boolean head)` Returns the layout set where privateLayout = ? and logoId = ? and head = ? or throws a `NoSuchLayoutSetException` if it could not be found.
`static LayoutSet`	`findByP_L_Last(boolean privateLayout, long logoId, OrderByComparator<LayoutSet> orderByComparator)` Returns the last layout set in the ordered set where privateLayout = ? and logoId = ?.
`static LayoutSet[]`	`findByP_L_PrevAndNext(long layoutSetId, boolean privateLayout, long logoId, OrderByComparator<LayoutSet> orderByComparator)` Returns the layout sets before and after the current layout set in the ordered set where privateLayout = ? and logoId = ?.
`static java.util.List<LayoutSet>`	`findByP_L(boolean privateLayout, long logoId)` Returns all the layout sets where privateLayout = ? and logoId = ?.
`static java.util.List<LayoutSet>`	`findByP_L(boolean privateLayout, long logoId, int start, int end)` Returns a range of all the layout sets where privateLayout = ? and logoId = ?.
`static java.util.List<LayoutSet>`	`findByP_L(boolean privateLayout, long logoId, int start, int end, OrderByComparator<LayoutSet> orderByComparator)` Returns an ordered range of all the layout sets where privateLayout = ? and logoId = ?.
`static java.util.List<LayoutSet>`	`findByP_L(boolean privateLayout, long logoId, int start, int end, OrderByComparator<LayoutSet> orderByComparator, boolean retrieveFromCache)` Returns an ordered range of all the layout sets where privateLayout = ? and logoId = ?.
`static LayoutSet`	`findByPrimaryKey(long layoutSetId)` Returns the layout set with the primary key or throws a `NoSuchLayoutSetException` if it could not be found.
`static java.util.List<LayoutSet>`	`findWithDynamicQuery(DynamicQuery dynamicQuery)`
`static java.util.List<LayoutSet>`	`findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end)`
`static java.util.List<LayoutSet>`	`findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end, OrderByComparator<LayoutSet> orderByComparator)`
`static LayoutSetPersistence`	`getPersistence()`
`static LayoutSet`	`remove(long layoutSetId)` Removes the layout set with the primary key from the database.
`static void`	`removeAll()` Removes all the layout sets from the database.
`static LayoutSet`	`removeByG_P_Head(long groupId, boolean privateLayout, boolean head)` Removes the layout set where groupId = ? and privateLayout = ? and head = ? from the database.
`static void`	`removeByG_P(long groupId, boolean privateLayout)` Removes all the layout sets where groupId = ? and privateLayout = ? from the database.
`static void`	`removeByGroupId_Head(long groupId, boolean head)` Removes all the layout sets where groupId = ? and head = ? from the database.
`static void`	`removeByGroupId(long groupId)` Removes all the layout sets where groupId = ? from the database.
`static LayoutSet`	`removeByHeadId(long headId)` Removes the layout set where headId = ? from the database.
`static void`	`removeByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid, boolean head)` Removes all the layout sets where layoutSetPrototypeUuid = ? and head = ? from the database.
`static void`	`removeByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)` Removes all the layout sets where layoutSetPrototypeUuid = ? from the database.
`static LayoutSet`	`removeByP_L_Head(boolean privateLayout, long logoId, boolean head)` Removes the layout set where privateLayout = ? and logoId = ? and head = ? from the database.
`static void`	`removeByP_L(boolean privateLayout, long logoId)` Removes all the layout sets where privateLayout = ? and logoId = ? from the database.
`static LayoutSet`	`update(LayoutSet layoutSet)`
`static LayoutSet`	`update(LayoutSet layoutSet, ServiceContext serviceContext)`
`static LayoutSet`	`updateImpl(LayoutSet layoutSet)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - LayoutSetUtil
```
public LayoutSetUtil()
```
- Method Detail
  - clearCache
```
public static void clearCache()
```
    See Also:
    
    BasePersistence.clearCache()
  - clearCache
```
public static void clearCache(LayoutSet layoutSet)
```
    See Also:
    
    BasePersistence.clearCache(com.liferay.portal.kernel.model.BaseModel)
  - countWithDynamicQuery
```
public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
```
    See Also:
    
    BasePersistence.countWithDynamicQuery(DynamicQuery)
  - fetchByPrimaryKeys
```
public static java.util.Map<java.io.Serializable,LayoutSet> fetchByPrimaryKeys(java.util.Set<java.io.Serializable> primaryKeys)
```
    See Also:
    
    BasePersistence.fetchByPrimaryKeys(Set)
  - findWithDynamicQuery
```
public static java.util.List<LayoutSet> findWithDynamicQuery(DynamicQuery dynamicQuery)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery)
  - findWithDynamicQuery
```
public static java.util.List<LayoutSet> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                                             int start,
                                                             int end)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
  - findWithDynamicQuery
```
public static java.util.List<LayoutSet> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                                             int start,
                                                             int end,
                                                             OrderByComparator<LayoutSet> orderByComparator)
```
    See Also:
    
    BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
  - update
```
public static LayoutSet update(LayoutSet layoutSet)
```
    See Also:
    
    BasePersistence.update(com.liferay.portal.kernel.model.BaseModel)
  - update
```
public static LayoutSet update(LayoutSet layoutSet,
                               ServiceContext serviceContext)
```
    See Also:
    
    BasePersistence.update(com.liferay.portal.kernel.model.BaseModel, ServiceContext)
  - findByGroupId
```
public static java.util.List<LayoutSet> findByGroupId(long groupId)
```
    Returns all the layout sets where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    Returns:
    
    the matching layout sets
  - findByGroupId
```
public static java.util.List<LayoutSet> findByGroupId(long groupId,
                                                      int start,
                                                      int end)
```
    Returns a range of all the layout sets where groupId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of matching layout sets
  - findByGroupId
```
public static java.util.List<LayoutSet> findByGroupId(long groupId,
                                                      int start,
                                                      int end,
                                                      OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets where groupId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout sets
  - findByGroupId
```
public static java.util.List<LayoutSet> findByGroupId(long groupId,
                                                      int start,
                                                      int end,
                                                      OrderByComparator<LayoutSet> orderByComparator,
                                                      boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets where groupId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout sets
  - findByGroupId_First
```
public static LayoutSet findByGroupId_First(long groupId,
                                            OrderByComparator<LayoutSet> orderByComparator)
                                     throws NoSuchLayoutSetException
```
    Returns the first layout set in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByGroupId_First
```
public static LayoutSet fetchByGroupId_First(long groupId,
                                             OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the first layout set in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set, or null if a matching layout set could not be found
  - findByGroupId_Last
```
public static LayoutSet findByGroupId_Last(long groupId,
                                           OrderByComparator<LayoutSet> orderByComparator)
                                    throws NoSuchLayoutSetException
```
    Returns the last layout set in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByGroupId_Last
```
public static LayoutSet fetchByGroupId_Last(long groupId,
                                            OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the last layout set in the ordered set where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set, or null if a matching layout set could not be found
  - findByGroupId_PrevAndNext
```
public static LayoutSet[] findByGroupId_PrevAndNext(long layoutSetId,
                                                    long groupId,
                                                    OrderByComparator<LayoutSet> orderByComparator)
                                             throws NoSuchLayoutSetException
```
    Returns the layout sets before and after the current layout set in the ordered set where groupId = ?.
    
    Parameters:
    
    layoutSetId - the primary key of the current layout set
    
    groupId - the group ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - removeByGroupId
```
public static void removeByGroupId(long groupId)
```
    Removes all the layout sets where groupId = ? from the database.
    
    Parameters:
    
    groupId - the group ID
  - countByGroupId
```
public static int countByGroupId(long groupId)
```
    Returns the number of layout sets where groupId = ?.
    
    Parameters:
    
    groupId - the group ID
    
    Returns:
    
    the number of matching layout sets
  - findByGroupId_Head
```
public static java.util.List<LayoutSet> findByGroupId_Head(long groupId,
                                                           boolean head)
```
    Returns all the layout sets where groupId = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    Returns:
    
    the matching layout sets
  - findByGroupId_Head
```
public static java.util.List<LayoutSet> findByGroupId_Head(long groupId,
                                                           boolean head,
                                                           int start,
                                                           int end)
```
    Returns a range of all the layout sets where groupId = ? and head = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of matching layout sets
  - findByGroupId_Head
```
public static java.util.List<LayoutSet> findByGroupId_Head(long groupId,
                                                           boolean head,
                                                           int start,
                                                           int end,
                                                           OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets where groupId = ? and head = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout sets
  - findByGroupId_Head
```
public static java.util.List<LayoutSet> findByGroupId_Head(long groupId,
                                                           boolean head,
                                                           int start,
                                                           int end,
                                                           OrderByComparator<LayoutSet> orderByComparator,
                                                           boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets where groupId = ? and head = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout sets
  - findByGroupId_Head_First
```
public static LayoutSet findByGroupId_Head_First(long groupId,
                                                 boolean head,
                                                 OrderByComparator<LayoutSet> orderByComparator)
                                          throws NoSuchLayoutSetException
```
    Returns the first layout set in the ordered set where groupId = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByGroupId_Head_First
```
public static LayoutSet fetchByGroupId_Head_First(long groupId,
                                                  boolean head,
                                                  OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the first layout set in the ordered set where groupId = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set, or null if a matching layout set could not be found
  - findByGroupId_Head_Last
```
public static LayoutSet findByGroupId_Head_Last(long groupId,
                                                boolean head,
                                                OrderByComparator<LayoutSet> orderByComparator)
                                         throws NoSuchLayoutSetException
```
    Returns the last layout set in the ordered set where groupId = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByGroupId_Head_Last
```
public static LayoutSet fetchByGroupId_Head_Last(long groupId,
                                                 boolean head,
                                                 OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the last layout set in the ordered set where groupId = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set, or null if a matching layout set could not be found
  - findByGroupId_Head_PrevAndNext
```
public static LayoutSet[] findByGroupId_Head_PrevAndNext(long layoutSetId,
                                                         long groupId,
                                                         boolean head,
                                                         OrderByComparator<LayoutSet> orderByComparator)
                                                  throws NoSuchLayoutSetException
```
    Returns the layout sets before and after the current layout set in the ordered set where groupId = ? and head = ?.
    
    Parameters:
    
    layoutSetId - the primary key of the current layout set
    
    groupId - the group ID
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - removeByGroupId_Head
```
public static void removeByGroupId_Head(long groupId,
                                        boolean head)
```
    Removes all the layout sets where groupId = ? and head = ? from the database.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
  - countByGroupId_Head
```
public static int countByGroupId_Head(long groupId,
                                      boolean head)
```
    Returns the number of layout sets where groupId = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    head - the head
    
    Returns:
    
    the number of matching layout sets
  - findByLayoutSetPrototypeUuid
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)
```
    Returns all the layout sets where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the matching layout sets
  - findByLayoutSetPrototypeUuid
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid,
                                                                     int start,
                                                                     int end)
```
    Returns a range of all the layout sets where layoutSetPrototypeUuid = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of matching layout sets
  - findByLayoutSetPrototypeUuid
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid,
                                                                     int start,
                                                                     int end,
                                                                     OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout sets
  - findByLayoutSetPrototypeUuid
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid,
                                                                     int start,
                                                                     int end,
                                                                     OrderByComparator<LayoutSet> orderByComparator,
                                                                     boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout sets
  - findByLayoutSetPrototypeUuid_First
```
public static LayoutSet findByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid,
                                                           OrderByComparator<LayoutSet> orderByComparator)
                                                    throws NoSuchLayoutSetException
```
    Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByLayoutSetPrototypeUuid_First
```
public static LayoutSet fetchByLayoutSetPrototypeUuid_First(java.lang.String layoutSetPrototypeUuid,
                                                            OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set, or null if a matching layout set could not be found
  - findByLayoutSetPrototypeUuid_Last
```
public static LayoutSet findByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid,
                                                          OrderByComparator<LayoutSet> orderByComparator)
                                                   throws NoSuchLayoutSetException
```
    Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByLayoutSetPrototypeUuid_Last
```
public static LayoutSet fetchByLayoutSetPrototypeUuid_Last(java.lang.String layoutSetPrototypeUuid,
                                                           OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set, or null if a matching layout set could not be found
  - findByLayoutSetPrototypeUuid_PrevAndNext
```
public static LayoutSet[] findByLayoutSetPrototypeUuid_PrevAndNext(long layoutSetId,
                                                                   java.lang.String layoutSetPrototypeUuid,
                                                                   OrderByComparator<LayoutSet> orderByComparator)
                                                            throws NoSuchLayoutSetException
```
    Returns the layout sets before and after the current layout set in the ordered set where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetId - the primary key of the current layout set
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - removeByLayoutSetPrototypeUuid
```
public static void removeByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)
```
    Removes all the layout sets where layoutSetPrototypeUuid = ? from the database.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
  - countByLayoutSetPrototypeUuid
```
public static int countByLayoutSetPrototypeUuid(java.lang.String layoutSetPrototypeUuid)
```
    Returns the number of layout sets where layoutSetPrototypeUuid = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    Returns:
    
    the number of matching layout sets
  - findByLayoutSetPrototypeUuid_Head
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid,
                                                                          boolean head)
```
    Returns all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    Returns:
    
    the matching layout sets
  - findByLayoutSetPrototypeUuid_Head
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid,
                                                                          boolean head,
                                                                          int start,
                                                                          int end)
```
    Returns a range of all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of matching layout sets
  - findByLayoutSetPrototypeUuid_Head
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid,
                                                                          boolean head,
                                                                          int start,
                                                                          int end,
                                                                          OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout sets
  - findByLayoutSetPrototypeUuid_Head
```
public static java.util.List<LayoutSet> findByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid,
                                                                          boolean head,
                                                                          int start,
                                                                          int end,
                                                                          OrderByComparator<LayoutSet> orderByComparator,
                                                                          boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ? and head = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout sets
  - findByLayoutSetPrototypeUuid_Head_First
```
public static LayoutSet findByLayoutSetPrototypeUuid_Head_First(java.lang.String layoutSetPrototypeUuid,
                                                                boolean head,
                                                                OrderByComparator<LayoutSet> orderByComparator)
                                                         throws NoSuchLayoutSetException
```
    Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByLayoutSetPrototypeUuid_Head_First
```
public static LayoutSet fetchByLayoutSetPrototypeUuid_Head_First(java.lang.String layoutSetPrototypeUuid,
                                                                 boolean head,
                                                                 OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set, or null if a matching layout set could not be found
  - findByLayoutSetPrototypeUuid_Head_Last
```
public static LayoutSet findByLayoutSetPrototypeUuid_Head_Last(java.lang.String layoutSetPrototypeUuid,
                                                               boolean head,
                                                               OrderByComparator<LayoutSet> orderByComparator)
                                                        throws NoSuchLayoutSetException
```
    Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByLayoutSetPrototypeUuid_Head_Last
```
public static LayoutSet fetchByLayoutSetPrototypeUuid_Head_Last(java.lang.String layoutSetPrototypeUuid,
                                                                boolean head,
                                                                OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set, or null if a matching layout set could not be found
  - findByLayoutSetPrototypeUuid_Head_PrevAndNext
```
public static LayoutSet[] findByLayoutSetPrototypeUuid_Head_PrevAndNext(long layoutSetId,
                                                                        java.lang.String layoutSetPrototypeUuid,
                                                                        boolean head,
                                                                        OrderByComparator<LayoutSet> orderByComparator)
                                                                 throws NoSuchLayoutSetException
```
    Returns the layout sets before and after the current layout set in the ordered set where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetId - the primary key of the current layout set
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - removeByLayoutSetPrototypeUuid_Head
```
public static void removeByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid,
                                                       boolean head)
```
    Removes all the layout sets where layoutSetPrototypeUuid = ? and head = ? from the database.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
  - countByLayoutSetPrototypeUuid_Head
```
public static int countByLayoutSetPrototypeUuid_Head(java.lang.String layoutSetPrototypeUuid,
                                                     boolean head)
```
    Returns the number of layout sets where layoutSetPrototypeUuid = ? and head = ?.
    
    Parameters:
    
    layoutSetPrototypeUuid - the layout set prototype uuid
    
    head - the head
    
    Returns:
    
    the number of matching layout sets
  - findByG_P
```
public static java.util.List<LayoutSet> findByG_P(long groupId,
                                                  boolean privateLayout)
```
    Returns all the layout sets where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    Returns:
    
    the matching layout sets
  - findByG_P
```
public static java.util.List<LayoutSet> findByG_P(long groupId,
                                                  boolean privateLayout,
                                                  int start,
                                                  int end)
```
    Returns a range of all the layout sets where groupId = ? and privateLayout = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of matching layout sets
  - findByG_P
```
public static java.util.List<LayoutSet> findByG_P(long groupId,
                                                  boolean privateLayout,
                                                  int start,
                                                  int end,
                                                  OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets where groupId = ? and privateLayout = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout sets
  - findByG_P
```
public static java.util.List<LayoutSet> findByG_P(long groupId,
                                                  boolean privateLayout,
                                                  int start,
                                                  int end,
                                                  OrderByComparator<LayoutSet> orderByComparator,
                                                  boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets where groupId = ? and privateLayout = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout sets
  - findByG_P_First
```
public static LayoutSet findByG_P_First(long groupId,
                                        boolean privateLayout,
                                        OrderByComparator<LayoutSet> orderByComparator)
                                 throws NoSuchLayoutSetException
```
    Returns the first layout set in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByG_P_First
```
public static LayoutSet fetchByG_P_First(long groupId,
                                         boolean privateLayout,
                                         OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the first layout set in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set, or null if a matching layout set could not be found
  - findByG_P_Last
```
public static LayoutSet findByG_P_Last(long groupId,
                                       boolean privateLayout,
                                       OrderByComparator<LayoutSet> orderByComparator)
                                throws NoSuchLayoutSetException
```
    Returns the last layout set in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByG_P_Last
```
public static LayoutSet fetchByG_P_Last(long groupId,
                                        boolean privateLayout,
                                        OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the last layout set in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set, or null if a matching layout set could not be found
  - findByG_P_PrevAndNext
```
public static LayoutSet[] findByG_P_PrevAndNext(long layoutSetId,
                                                long groupId,
                                                boolean privateLayout,
                                                OrderByComparator<LayoutSet> orderByComparator)
                                         throws NoSuchLayoutSetException
```
    Returns the layout sets before and after the current layout set in the ordered set where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    layoutSetId - the primary key of the current layout set
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - removeByG_P
```
public static void removeByG_P(long groupId,
                               boolean privateLayout)
```
    Removes all the layout sets where groupId = ? and privateLayout = ? from the database.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
  - countByG_P
```
public static int countByG_P(long groupId,
                             boolean privateLayout)
```
    Returns the number of layout sets where groupId = ? and privateLayout = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    Returns:
    
    the number of matching layout sets
  - findByG_P_Head
```
public static LayoutSet findByG_P_Head(long groupId,
                                       boolean privateLayout,
                                       boolean head)
                                throws NoSuchLayoutSetException
```
    Returns the layout set where groupId = ? and privateLayout = ? and head = ? or throws a NoSuchLayoutSetException if it could not be found.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    head - the head
    
    Returns:
    
    the matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByG_P_Head
```
public static LayoutSet fetchByG_P_Head(long groupId,
                                        boolean privateLayout,
                                        boolean head)
```
    Returns the layout set where groupId = ? and privateLayout = ? and head = ? or returns null if it could not be found. Uses the finder cache.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    head - the head
    
    Returns:
    
    the matching layout set, or null if a matching layout set could not be found
  - fetchByG_P_Head
```
public static LayoutSet fetchByG_P_Head(long groupId,
                                        boolean privateLayout,
                                        boolean head,
                                        boolean retrieveFromCache)
```
    Returns the layout set where groupId = ? and privateLayout = ? and head = ? or returns null if it could not be found, optionally using the finder cache.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    head - the head
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the matching layout set, or null if a matching layout set could not be found
  - removeByG_P_Head
```
public static LayoutSet removeByG_P_Head(long groupId,
                                         boolean privateLayout,
                                         boolean head)
                                  throws NoSuchLayoutSetException
```
    Removes the layout set where groupId = ? and privateLayout = ? and head = ? from the database.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    head - the head
    
    Returns:
    
    the layout set that was removed
    
    Throws:
    
    NoSuchLayoutSetException
  - countByG_P_Head
```
public static int countByG_P_Head(long groupId,
                                  boolean privateLayout,
                                  boolean head)
```
    Returns the number of layout sets where groupId = ? and privateLayout = ? and head = ?.
    
    Parameters:
    
    groupId - the group ID
    
    privateLayout - the private layout
    
    head - the head
    
    Returns:
    
    the number of matching layout sets
  - findByP_L
```
public static java.util.List<LayoutSet> findByP_L(boolean privateLayout,
                                                  long logoId)
```
    Returns all the layout sets where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    Returns:
    
    the matching layout sets
  - findByP_L
```
public static java.util.List<LayoutSet> findByP_L(boolean privateLayout,
                                                  long logoId,
                                                  int start,
                                                  int end)
```
    Returns a range of all the layout sets where privateLayout = ? and logoId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of matching layout sets
  - findByP_L
```
public static java.util.List<LayoutSet> findByP_L(boolean privateLayout,
                                                  long logoId,
                                                  int start,
                                                  int end,
                                                  OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets where privateLayout = ? and logoId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of matching layout sets
  - findByP_L
```
public static java.util.List<LayoutSet> findByP_L(boolean privateLayout,
                                                  long logoId,
                                                  int start,
                                                  int end,
                                                  OrderByComparator<LayoutSet> orderByComparator,
                                                  boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets where privateLayout = ? and logoId = ?.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of matching layout sets
  - findByP_L_First
```
public static LayoutSet findByP_L_First(boolean privateLayout,
                                        long logoId,
                                        OrderByComparator<LayoutSet> orderByComparator)
                                 throws NoSuchLayoutSetException
```
    Returns the first layout set in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByP_L_First
```
public static LayoutSet fetchByP_L_First(boolean privateLayout,
                                         long logoId,
                                         OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the first layout set in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the first matching layout set, or null if a matching layout set could not be found
  - findByP_L_Last
```
public static LayoutSet findByP_L_Last(boolean privateLayout,
                                       long logoId,
                                       OrderByComparator<LayoutSet> orderByComparator)
                                throws NoSuchLayoutSetException
```
    Returns the last layout set in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByP_L_Last
```
public static LayoutSet fetchByP_L_Last(boolean privateLayout,
                                        long logoId,
                                        OrderByComparator<LayoutSet> orderByComparator)
```
    Returns the last layout set in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the last matching layout set, or null if a matching layout set could not be found
  - findByP_L_PrevAndNext
```
public static LayoutSet[] findByP_L_PrevAndNext(long layoutSetId,
                                                boolean privateLayout,
                                                long logoId,
                                                OrderByComparator<LayoutSet> orderByComparator)
                                         throws NoSuchLayoutSetException
```
    Returns the layout sets before and after the current layout set in the ordered set where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    layoutSetId - the primary key of the current layout set
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    orderByComparator - the comparator to order the set by (optionally null)
    
    Returns:
    
    the previous, current, and next layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - removeByP_L
```
public static void removeByP_L(boolean privateLayout,
                               long logoId)
```
    Removes all the layout sets where privateLayout = ? and logoId = ? from the database.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
  - countByP_L
```
public static int countByP_L(boolean privateLayout,
                             long logoId)
```
    Returns the number of layout sets where privateLayout = ? and logoId = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    Returns:
    
    the number of matching layout sets
  - findByP_L_Head
```
public static LayoutSet findByP_L_Head(boolean privateLayout,
                                       long logoId,
                                       boolean head)
                                throws NoSuchLayoutSetException
```
    Returns the layout set where privateLayout = ? and logoId = ? and head = ? or throws a NoSuchLayoutSetException if it could not be found.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    head - the head
    
    Returns:
    
    the matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByP_L_Head
```
public static LayoutSet fetchByP_L_Head(boolean privateLayout,
                                        long logoId,
                                        boolean head)
```
    Returns the layout set where privateLayout = ? and logoId = ? and head = ? or returns null if it could not be found. Uses the finder cache.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    head - the head
    
    Returns:
    
    the matching layout set, or null if a matching layout set could not be found
  - fetchByP_L_Head
```
public static LayoutSet fetchByP_L_Head(boolean privateLayout,
                                        long logoId,
                                        boolean head,
                                        boolean retrieveFromCache)
```
    Returns the layout set where privateLayout = ? and logoId = ? and head = ? or returns null if it could not be found, optionally using the finder cache.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    head - the head
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the matching layout set, or null if a matching layout set could not be found
  - removeByP_L_Head
```
public static LayoutSet removeByP_L_Head(boolean privateLayout,
                                         long logoId,
                                         boolean head)
                                  throws NoSuchLayoutSetException
```
    Removes the layout set where privateLayout = ? and logoId = ? and head = ? from the database.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    head - the head
    
    Returns:
    
    the layout set that was removed
    
    Throws:
    
    NoSuchLayoutSetException
  - countByP_L_Head
```
public static int countByP_L_Head(boolean privateLayout,
                                  long logoId,
                                  boolean head)
```
    Returns the number of layout sets where privateLayout = ? and logoId = ? and head = ?.
    
    Parameters:
    
    privateLayout - the private layout
    
    logoId - the logo ID
    
    head - the head
    
    Returns:
    
    the number of matching layout sets
  - findByHeadId
```
public static LayoutSet findByHeadId(long headId)
                              throws NoSuchLayoutSetException
```
    Returns the layout set where headId = ? or throws a NoSuchLayoutSetException if it could not be found.
    
    Parameters:
    
    headId - the head ID
    
    Returns:
    
    the matching layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a matching layout set could not be found
  - fetchByHeadId
```
public static LayoutSet fetchByHeadId(long headId)
```
    Returns the layout set where headId = ? or returns null if it could not be found. Uses the finder cache.
    
    Parameters:
    
    headId - the head ID
    
    Returns:
    
    the matching layout set, or null if a matching layout set could not be found
  - fetchByHeadId
```
public static LayoutSet fetchByHeadId(long headId,
                                      boolean retrieveFromCache)
```
    Returns the layout set where headId = ? or returns null if it could not be found, optionally using the finder cache.
    
    Parameters:
    
    headId - the head ID
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the matching layout set, or null if a matching layout set could not be found
  - removeByHeadId
```
public static LayoutSet removeByHeadId(long headId)
                                throws NoSuchLayoutSetException
```
    Removes the layout set where headId = ? from the database.
    
    Parameters:
    
    headId - the head ID
    
    Returns:
    
    the layout set that was removed
    
    Throws:
    
    NoSuchLayoutSetException
  - countByHeadId
```
public static int countByHeadId(long headId)
```
    Returns the number of layout sets where headId = ?.
    
    Parameters:
    
    headId - the head ID
    
    Returns:
    
    the number of matching layout sets
  - cacheResult
```
public static void cacheResult(LayoutSet layoutSet)
```
    Caches the layout set in the entity cache if it is enabled.
    
    Parameters:
    
    layoutSet - the layout set
  - cacheResult
```
public static void cacheResult(java.util.List<LayoutSet> layoutSets)
```
    Caches the layout sets in the entity cache if it is enabled.
    
    Parameters:
    
    layoutSets - the layout sets
  - create
```
public static LayoutSet create(long layoutSetId)
```
    Creates a new layout set with the primary key. Does not add the layout set to the database.
    
    Parameters:
    
    layoutSetId - the primary key for the new layout set
    
    Returns:
    
    the new layout set
  - remove
```
public static LayoutSet remove(long layoutSetId)
                        throws NoSuchLayoutSetException
```
    Removes the layout set with the primary key from the database. Also notifies the appropriate model listeners.
    
    Parameters:
    
    layoutSetId - the primary key of the layout set
    
    Returns:
    
    the layout set that was removed
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - updateImpl
```
public static LayoutSet updateImpl(LayoutSet layoutSet)
```
  - findByPrimaryKey
```
public static LayoutSet findByPrimaryKey(long layoutSetId)
                                  throws NoSuchLayoutSetException
```
    Returns the layout set with the primary key or throws a NoSuchLayoutSetException if it could not be found.
    
    Parameters:
    
    layoutSetId - the primary key of the layout set
    
    Returns:
    
    the layout set
    
    Throws:
    
    NoSuchLayoutSetException - if a layout set with the primary key could not be found
  - fetchByPrimaryKey
```
public static LayoutSet fetchByPrimaryKey(long layoutSetId)
```
    Returns the layout set with the primary key or returns null if it could not be found.
    
    Parameters:
    
    layoutSetId - the primary key of the layout set
    
    Returns:
    
    the layout set, or null if a layout set with the primary key could not be found
  - findAll
```
public static java.util.List<LayoutSet> findAll()
```
    Returns all the layout sets.
    
    Returns:
    
    the layout sets
  - findAll
```
public static java.util.List<LayoutSet> findAll(int start,
                                                int end)
```
    Returns a range of all the layout sets.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    Returns:
    
    the range of layout sets
  - findAll
```
public static java.util.List<LayoutSet> findAll(int start,
                                                int end,
                                                OrderByComparator<LayoutSet> orderByComparator)
```
    Returns an ordered range of all the layout sets.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    Returns:
    
    the ordered range of layout sets
  - findAll
```
public static java.util.List<LayoutSet> findAll(int start,
                                                int end,
                                                OrderByComparator<LayoutSet> orderByComparator,
                                                boolean retrieveFromCache)
```
    Returns an ordered range of all the layout sets.
    Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from LayoutSetModelImpl. If both orderByComparator 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.
    
    Parameters:
    
    start - the lower bound of the range of layout sets
    
    end - the upper bound of the range of layout sets (not inclusive)
    
    orderByComparator - the comparator to order the results by (optionally null)
    
    retrieveFromCache - whether to retrieve from the finder cache
    
    Returns:
    
    the ordered range of layout sets
  - removeAll
```
public static void removeAll()
```
    Removes all the layout sets from the database.
  - countAll
```
public static int countAll()
```
    Returns the number of layout sets.
    
    Returns:
    
    the number of layout sets
  - getPersistence
```
public static LayoutSetPersistence getPersistence()
```

Class LayoutSetUtil

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LayoutSetUtil

Method Detail

clearCache

clearCache

countWithDynamicQuery

fetchByPrimaryKeys

findWithDynamicQuery

findWithDynamicQuery

findWithDynamicQuery

update

update

findByGroupId

findByGroupId

findByGroupId

findByGroupId

findByGroupId_First

fetchByGroupId_First

findByGroupId_Last

fetchByGroupId_Last

findByGroupId_PrevAndNext

removeByGroupId

countByGroupId

findByGroupId_Head

findByGroupId_Head

findByGroupId_Head

findByGroupId_Head

findByGroupId_Head_First

fetchByGroupId_Head_First

findByGroupId_Head_Last

fetchByGroupId_Head_Last

findByGroupId_Head_PrevAndNext

removeByGroupId_Head

countByGroupId_Head

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid_First

fetchByLayoutSetPrototypeUuid_First

findByLayoutSetPrototypeUuid_Last

fetchByLayoutSetPrototypeUuid_Last

findByLayoutSetPrototypeUuid_PrevAndNext

removeByLayoutSetPrototypeUuid

countByLayoutSetPrototypeUuid

findByLayoutSetPrototypeUuid_Head

findByLayoutSetPrototypeUuid_Head

findByLayoutSetPrototypeUuid_Head

findByLayoutSetPrototypeUuid_Head

findByLayoutSetPrototypeUuid_Head_First

fetchByLayoutSetPrototypeUuid_Head_First

findByLayoutSetPrototypeUuid_Head_Last

fetchByLayoutSetPrototypeUuid_Head_Last

findByLayoutSetPrototypeUuid_Head_PrevAndNext

removeByLayoutSetPrototypeUuid_Head

countByLayoutSetPrototypeUuid_Head

findByG_P

findByG_P

findByG_P

findByG_P

findByG_P_First

fetchByG_P_First

findByG_P_Last

fetchByG_P_Last

findByG_P_PrevAndNext

removeByG_P

countByG_P

findByG_P_Head

fetchByG_P_Head

fetchByG_P_Head

removeByG_P_Head

countByG_P_Head

findByP_L

findByP_L

findByP_L

findByP_L