Example usage for org.apache.commons.collections4 CollectionUtils isEmpty

List of usage examples for org.apache.commons.collections4 CollectionUtils isEmpty

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.collections4.*
  5. CollectionUtils
  6. isEmpty

Introduction

In this page you can find the example usage for org.apache.commons.collections4 CollectionUtils isEmpty.

Prototype

public static boolean isEmpty(final Collection<?> coll)

Source Link

Document

Null-safe check if the specified collection is empty.

Usage

From source file:org.finra.herd.dao.impl.BusinessObjectDataDaoImpl.java

@Override
public BusinessObjectDataEntity getBusinessObjectDataByAltKeyAndStatus(
        BusinessObjectDataKey businessObjectDataKey, String businessObjectDataStatus) {
    // Create the criteria builder and the criteria.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<BusinessObjectDataEntity> criteria = builder.createQuery(BusinessObjectDataEntity.class);

    // The criteria root is the business object data.
    Root<BusinessObjectDataEntity> businessObjectDataEntity = criteria.from(BusinessObjectDataEntity.class);

    // Join to other tables that we need to filter on.
    Join<BusinessObjectDataEntity, BusinessObjectFormatEntity> businessObjectFormatEntity = businessObjectDataEntity
            .join(BusinessObjectDataEntity_.businessObjectFormat);
    Join<BusinessObjectFormatEntity, FileTypeEntity> fileTypeEntity = businessObjectFormatEntity
            .join(BusinessObjectFormatEntity_.fileType);
    Join<BusinessObjectFormatEntity, BusinessObjectDefinitionEntity> businessObjectDefinitionEntity = businessObjectFormatEntity
            .join(BusinessObjectFormatEntity_.businessObjectDefinition);

    // Create the standard restrictions (i.e. the standard where clauses).
    Predicate mainQueryRestriction = getQueryRestriction(builder, businessObjectDataEntity,
            businessObjectFormatEntity, fileTypeEntity, businessObjectDefinitionEntity, businessObjectDataKey);

    // If a format version was specified, use the latest available for this partition value.
    if (businessObjectDataKey.getBusinessObjectFormatVersion() == null) {
        // Business object format version is not specified, so just use the latest available for this set of partition values.
        Subquery<Integer> subQuery = criteria.subquery(Integer.class);

        // The criteria root is the business object data.
        Root<BusinessObjectDataEntity> subBusinessObjectDataEntity = subQuery
                .from(BusinessObjectDataEntity.class);

        // Join to the other tables we can filter on.
        Join<BusinessObjectDataEntity, BusinessObjectFormatEntity> subBusinessObjectFormatEntity = subBusinessObjectDataEntity
                .join(BusinessObjectDataEntity_.businessObjectFormat);
        Join<BusinessObjectFormatEntity, BusinessObjectDefinitionEntity> subBusinessObjectDefinitionEntity = subBusinessObjectFormatEntity
                .join(BusinessObjectFormatEntity_.businessObjectDefinition);
        Join<BusinessObjectFormatEntity, FileTypeEntity> subBusinessObjectFormatFileTypeEntity = subBusinessObjectFormatEntity
                .join(BusinessObjectFormatEntity_.fileType);
        Join<BusinessObjectDataEntity, BusinessObjectDataStatusEntity> subBusinessObjectDataStatusEntity = subBusinessObjectDataEntity
                .join(BusinessObjectDataEntity_.status);

        // Create the standard restrictions (i.e. the standard where clauses).
        Predicate subQueryRestriction = builder.equal(subBusinessObjectDefinitionEntity,
                businessObjectDefinitionEntity);
        subQueryRestriction = builder.and(subQueryRestriction,
                builder.equal(subBusinessObjectFormatEntity.get(BusinessObjectFormatEntity_.usage),
                        businessObjectFormatEntity.get(BusinessObjectFormatEntity_.usage)));
        subQueryRestriction = builder.and(subQueryRestriction,
                builder.equal(subBusinessObjectFormatFileTypeEntity, fileTypeEntity));

        // Create and add standard restrictions on primary and sub-partition values.
        subQueryRestriction = builder.and(subQueryRestriction, getQueryRestrictionOnPartitionValues(builder,
                subBusinessObjectDataEntity, businessObjectDataEntity));

        // Add restrictions on business object data version and business object data status.
        Predicate subQueryRestrictionOnBusinessObjectDataVersionAndStatus = getQueryRestrictionOnBusinessObjectDataVersionAndStatus(
                builder, subBusinessObjectDataEntity, subBusinessObjectDataStatusEntity,
                businessObjectDataKey.getBusinessObjectDataVersion(), businessObjectDataStatus);
        if (subQueryRestrictionOnBusinessObjectDataVersionAndStatus != null) {
            subQueryRestriction = builder.and(subQueryRestriction,
                    subQueryRestrictionOnBusinessObjectDataVersionAndStatus);
        }/*from   w ww .j  av a 2  s.  c  om*/

        subQuery.select(builder.max(
                subBusinessObjectFormatEntity.get(BusinessObjectFormatEntity_.businessObjectFormatVersion)))
                .where(subQueryRestriction);

        mainQueryRestriction = builder.and(mainQueryRestriction,
                builder.in(
                        businessObjectFormatEntity.get(BusinessObjectFormatEntity_.businessObjectFormatVersion))
                        .value(subQuery));
    }

    // If a data version was not specified, use the latest one as per specified business object data status.
    if (businessObjectDataKey.getBusinessObjectDataVersion() == null) {
        // Since business object data version is not specified, just use the latest one as per specified business object data status.
        if (businessObjectDataStatus != null) {
            // Business object data version is not specified, so get the latest one as per specified business object data status.
            Subquery<Integer> subQuery = criteria.subquery(Integer.class);

            // The criteria root is the business object data.
            Root<BusinessObjectDataEntity> subBusinessObjectDataEntity = subQuery
                    .from(BusinessObjectDataEntity.class);

            // Join to the other tables we can filter on.
            Join<BusinessObjectDataEntity, BusinessObjectDataStatusEntity> subBusinessObjectDataStatusEntity = subBusinessObjectDataEntity
                    .join(BusinessObjectDataEntity_.status);
            Join<BusinessObjectDataEntity, BusinessObjectFormatEntity> subBusinessObjectFormatEntity = subBusinessObjectDataEntity
                    .join(BusinessObjectDataEntity_.businessObjectFormat);

            // Create the standard restrictions (i.e. the standard where clauses).
            Predicate subQueryRestriction = builder.equal(subBusinessObjectFormatEntity,
                    businessObjectFormatEntity);

            // Create and add standard restrictions on primary and sub-partition values.
            subQueryRestriction = builder.and(subQueryRestriction, getQueryRestrictionOnPartitionValues(builder,
                    subBusinessObjectDataEntity, businessObjectDataEntity));

            // Create and add standard restrictions on business object data status.
            subQueryRestriction = builder.and(subQueryRestriction, builder.equal(
                    builder.upper(subBusinessObjectDataStatusEntity.get(BusinessObjectDataStatusEntity_.code)),
                    businessObjectDataStatus.toUpperCase()));

            subQuery.select(builder.max(subBusinessObjectDataEntity.get(BusinessObjectDataEntity_.version)))
                    .where(subQueryRestriction);

            mainQueryRestriction = builder.and(mainQueryRestriction, builder
                    .in(businessObjectDataEntity.get(BusinessObjectDataEntity_.version)).value(subQuery));
        } else {
            // Both business object data version and business object data status are not specified, so just use the latest business object data version.
            mainQueryRestriction = builder.and(mainQueryRestriction,
                    builder.equal(businessObjectDataEntity.get(BusinessObjectDataEntity_.latestVersion), true));
        }
    }

    criteria.select(businessObjectDataEntity).where(mainQueryRestriction);

    return executeSingleResultQuery(criteria, String.format(
            "Found more than one business object data instance with parameters {namespace=\"%s\", businessObjectDefinitionName=\"%s\","
                    + " businessObjectFormatUsage=\"%s\", businessObjectFormatFileType=\"%s\", businessObjectFormatVersion=\"%d\","
                    + " businessObjectDataPartitionValue=\"%s\", businessObjectDataSubPartitionValues=\"%s\", businessObjectDataVersion=\"%d\","
                    + " businessObjectDataStatus=\"%s\"}.",
            businessObjectDataKey.getNamespace(), businessObjectDataKey.getBusinessObjectDefinitionName(),
            businessObjectDataKey.getBusinessObjectFormatUsage(),
            businessObjectDataKey.getBusinessObjectFormatFileType(),
            businessObjectDataKey.getBusinessObjectFormatVersion(), businessObjectDataKey.getPartitionValue(),
            CollectionUtils.isEmpty(businessObjectDataKey.getSubPartitionValues()) ? ""
                    : StringUtils.join(businessObjectDataKey.getSubPartitionValues(), ","),
            businessObjectDataKey.getBusinessObjectDataVersion(), businessObjectDataStatus));
}

From source file:org.finra.herd.dao.impl.BusinessObjectDataDaoImpl.java

/**
 * Apply attribute value filters to the main query predicate.
 *
 * @param businessDataSearchKey the business object data search key
 * @param businessObjectDataEntityRoot the criteria root which is a business object data entity
 * @param builder the criteria builder/*from w  w  w  .  jav  a 2  s . c o  m*/
 * @param mainQueryPredicate the main query predicate to be updated
 *
 * @return the updated main query predicate
 */
private Predicate applyAttributeValueFilters(final BusinessObjectDataSearchKey businessDataSearchKey,
        final Root<BusinessObjectDataEntity> businessObjectDataEntityRoot, final CriteriaBuilder builder,
        Predicate mainQueryPredicate) {
    if (!CollectionUtils.isEmpty(businessDataSearchKey.getAttributeValueFilters())) {
        for (AttributeValueFilter attributeValueFilter : businessDataSearchKey.getAttributeValueFilters()) {
            Join<BusinessObjectDataEntity, BusinessObjectDataAttributeEntity> dataAttributeEntity = businessObjectDataEntityRoot
                    .join(BusinessObjectDataEntity_.attributes);

            if (!StringUtils.isEmpty(attributeValueFilter.getAttributeName())) {
                mainQueryPredicate = builder.and(mainQueryPredicate,
                        builder.equal(dataAttributeEntity.get(BusinessObjectDataAttributeEntity_.name),
                                attributeValueFilter.getAttributeName()));
            }

            if (!StringUtils.isEmpty(attributeValueFilter.getAttributeValue())) {
                mainQueryPredicate = builder.and(mainQueryPredicate,
                        builder.equal(dataAttributeEntity.get(BusinessObjectDataAttributeEntity_.value),
                                attributeValueFilter.getAttributeValue()));
            }
        }
    }

    return mainQueryPredicate;
}

From source file:org.finra.herd.dao.impl.BusinessObjectDataDaoImpl.java

@Override
public List<BusinessObjectDataKey> getBusinessObjectDataByBusinessObjectDefinition(
        BusinessObjectDefinitionEntity businessObjectDefinitionEntity, Integer maxResults) {
    // Get ids for all business object formats registered with the specified business object definition.
    List<Integer> businessObjectFormatIds = businessObjectFormatDao
            .getBusinessObjectFormatIdsByBusinessObjectDefinition(businessObjectDefinitionEntity);

    // Return no results if the business object definition has no business object formats registered with it.
    if (CollectionUtils.isEmpty(businessObjectFormatIds)) {
        return new ArrayList<>();
    }/* ww  w.j a  v a2  s  .  c o m*/

    // Create the criteria builder and the criteria.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<BusinessObjectDataEntity> criteria = builder.createQuery(BusinessObjectDataEntity.class);

    // The criteria root is the business object data.
    Root<BusinessObjectDataEntity> businessObjectDataEntityRoot = criteria.from(BusinessObjectDataEntity.class);

    // Create the standard restrictions (i.e. the standard where clauses).
    Predicate predicate = getPredicateForInClause(builder,
            businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.businessObjectFormatId),
            businessObjectFormatIds);

    // Build an order by clause.
    List<Order> orderBy = new ArrayList<>();
    for (SingularAttribute<BusinessObjectDataEntity, String> businessObjectDataPartition : BUSINESS_OBJECT_DATA_PARTITIONS) {
        orderBy.add(builder.desc(businessObjectDataEntityRoot.get(businessObjectDataPartition)));
    }
    orderBy.add(builder.desc(businessObjectDataEntityRoot.get(BusinessObjectDataEntity_.version)));

    // Add the clauses for the query.
    criteria.select(businessObjectDataEntityRoot).where(predicate).orderBy(orderBy);

    // Create a query.
    TypedQuery<BusinessObjectDataEntity> query = entityManager.createQuery(criteria);

    // If specified, set the maximum number of results for query to return.
    if (maxResults != null) {
        query.setMaxResults(maxResults);
    }

    // Run the query to get a list of entities back.
    List<BusinessObjectDataEntity> businessObjectDataEntities = query.getResultList();

    // Populate the "keys" objects from the returned entities.
    List<BusinessObjectDataKey> businessObjectDataKeys = new ArrayList<>();
    for (BusinessObjectDataEntity businessObjectDataEntity : businessObjectDataEntities) {
        BusinessObjectDataKey businessObjectDataKey = new BusinessObjectDataKey();
        businessObjectDataKeys.add(businessObjectDataKey);
        businessObjectDataKey.setNamespace(businessObjectDataEntity.getBusinessObjectFormat()
                .getBusinessObjectDefinition().getNamespace().getCode());
        businessObjectDataKey.setBusinessObjectDefinitionName(
                businessObjectDataEntity.getBusinessObjectFormat().getBusinessObjectDefinition().getName());
        businessObjectDataKey
                .setBusinessObjectFormatUsage(businessObjectDataEntity.getBusinessObjectFormat().getUsage());
        businessObjectDataKey.setBusinessObjectFormatFileType(
                businessObjectDataEntity.getBusinessObjectFormat().getFileType().getCode());
        businessObjectDataKey.setBusinessObjectFormatVersion(
                businessObjectDataEntity.getBusinessObjectFormat().getBusinessObjectFormatVersion());
        businessObjectDataKey.setPartitionValue(businessObjectDataEntity.getPartitionValue());
        businessObjectDataKey.setSubPartitionValues(getSubPartitionValues(businessObjectDataEntity));
        businessObjectDataKey.setBusinessObjectDataVersion(businessObjectDataEntity.getVersion());
    }

    return businessObjectDataKeys;
}

From source file:org.finra.herd.dao.impl.BusinessObjectDefinitionDaoImpl.java

@Override
public List<BusinessObjectDefinitionEntity> getBusinessObjectDefinitions(List<TagEntity> tagEntities) {
    // Create the criteria builder and a tuple style criteria query.
    CriteriaBuilder builder = entityManager.getCriteriaBuilder();
    CriteriaQuery<BusinessObjectDefinitionEntity> criteria = builder
            .createQuery(BusinessObjectDefinitionEntity.class);

    // The criteria root is the business object definition.
    Root<BusinessObjectDefinitionEntity> businessObjectDefinitionEntityRoot = criteria
            .from(BusinessObjectDefinitionEntity.class);

    // Join to the other tables we can filter on.
    Join<BusinessObjectDefinitionEntity, NamespaceEntity> namespaceEntity = businessObjectDefinitionEntityRoot
            .join(BusinessObjectDefinitionEntity_.namespace);

    // Get the columns.
    Path<String> namespaceCodeColumn = namespaceEntity.get(NamespaceEntity_.code);
    Path<String> businessObjectDefinitionNameColumn = businessObjectDefinitionEntityRoot
            .get(BusinessObjectDefinitionEntity_.name);

    Predicate predicate;/*from   w  w  w .  j a  va2  s  .  c o m*/

    if (!CollectionUtils.isEmpty(tagEntities)) {
        //join the business object definition tags
        Join<BusinessObjectDefinitionEntity, BusinessObjectDefinitionTagEntity> businessObjectDefinitionTagEntityJoin = businessObjectDefinitionEntityRoot
                .join(BusinessObjectDefinitionEntity_.businessObjectDefinitionTags);

        // Create the standard restrictions (i.e. the standard where clauses).
        predicate = getPredicateForInClause(builder,
                businessObjectDefinitionTagEntityJoin.get(BusinessObjectDefinitionTagEntity_.tag), tagEntities);

        // Add all clauses to the query.
        criteria.select(businessObjectDefinitionEntityRoot).where(predicate)
                .orderBy(builder.asc(businessObjectDefinitionNameColumn), builder.asc(namespaceCodeColumn));
    } else {
        criteria.select(businessObjectDefinitionEntityRoot)
                .orderBy(builder.asc(businessObjectDefinitionNameColumn), builder.asc(namespaceCodeColumn));
    }

    //Returns duplicate business object definition. When a bdef is associated with multiple tags.
    return entityManager.createQuery(criteria).getResultList();
}

From source file:org.finra.herd.dao.impl.BusinessObjectDefinitionIndexSearchDaoImpl.java

@Override
public ElasticsearchResponseDto searchBusinessObjectDefinitionsByTags(String indexName, String documentType,
        List<Map<SearchFilterType, List<TagEntity>>> nestedTagEntityMaps, Set<String> facetFieldsList) {
    ElasticsearchResponseDto elasticsearchResponseDto = new ElasticsearchResponseDto();

    List<List<TagEntity>> nestedInclusionTagEntityLists = new ArrayList<>();
    List<List<TagEntity>> nestedExclusionTagEntityLists = new ArrayList<>();

    for (Map<SearchFilterType, List<TagEntity>> tagEntityMap : nestedTagEntityMaps) {
        if (tagEntityMap.containsKey(SearchFilterType.INCLUSION_SEARCH_FILTER)) {
            nestedInclusionTagEntityLists.add(tagEntityMap.get(SearchFilterType.INCLUSION_SEARCH_FILTER));
        } else if (tagEntityMap.containsKey(SearchFilterType.EXCLUSION_SEARCH_FILTER)) {
            nestedExclusionTagEntityLists.add(tagEntityMap.get(SearchFilterType.EXCLUSION_SEARCH_FILTER));
        }/*  w ww.  ja  v a 2 s  .  co  m*/
    }

    LOGGER.info(
            "Searching Elasticsearch business object definition documents from index, indexName={} and documentType={}, by tagEntityList={}",
            indexName, documentType,
            tagEntityListToString(flattenTagEntitiesList(nestedInclusionTagEntityLists)));

    LOGGER.info("Excluding the following tagEntityList={}", indexName, documentType,
            tagEntityListToString(flattenTagEntitiesList(nestedExclusionTagEntityLists)));

    BoolQueryBuilder compoundSearchFiltersQueryBuilder = new BoolQueryBuilder();

    // If there are only exclusion tag entities then, get everything else, but the exclusion tags.
    if (CollectionUtils.isEmpty(flattenTagEntitiesList(nestedInclusionTagEntityLists))) {
        WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery(NAME_FIELD, "*");
        compoundSearchFiltersQueryBuilder.must(wildcardQueryBuilder);
    }

    // Inclusion
    for (List<TagEntity> tagEntities : nestedInclusionTagEntityLists) {
        BoolQueryBuilder searchFilterQueryBuilder = new BoolQueryBuilder();

        for (TagEntity tagEntity : tagEntities) {
            // Add constant-score term queries for tagType-code and tag-code from the tag-key.
            ConstantScoreQueryBuilder searchKeyQueryBuilder = QueryBuilders
                    .constantScoreQuery(QueryBuilders.boolQuery()
                            .must(QueryBuilders.termQuery(TAGTYPE_CODE_FIELD, tagEntity.getTagType().getCode()))
                            .must(QueryBuilders.termQuery(TAG_CODE_FIELD, tagEntity.getTagCode())));

            // Individual tag-keys are OR-ed
            searchFilterQueryBuilder.should(searchKeyQueryBuilder);
        }

        // Individual search-filters are AND-ed
        compoundSearchFiltersQueryBuilder.must(searchFilterQueryBuilder);
    }

    // Exclusion
    for (List<TagEntity> tagEntities : nestedExclusionTagEntityLists) {
        for (TagEntity tagEntity : tagEntities) {
            // Add constant-score term queries for tagType-code and tag-code from the tag-key.
            QueryBuilder searchKeyQueryBuilder = QueryBuilders.boolQuery()
                    .must(QueryBuilders.termQuery(TAGTYPE_CODE_FIELD, tagEntity.getTagType().getCode()))
                    .must(QueryBuilders.termQuery(TAG_CODE_FIELD, tagEntity.getTagCode()));

            // Exclusion: individual tag-keys are added as a must not query
            compoundSearchFiltersQueryBuilder.mustNot(searchKeyQueryBuilder);
        }
    }

    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

    // Fetch only the required fields
    searchSourceBuilder.fetchSource(new String[] { DATA_PROVIDER_NAME_SOURCE, DESCRIPTION_SOURCE,
            DISPLAY_NAME_SOURCE, NAME_SOURCE, NAMESPACE_CODE_SOURCE }, null);
    searchSourceBuilder.query(compoundSearchFiltersQueryBuilder);

    // Create a search request and set the scroll time and scroll size
    SearchRequestBuilder searchRequestBuilder = new SearchRequestBuilder(new ElasticsearchClientImpl(),
            SearchAction.INSTANCE);
    searchRequestBuilder.setIndices(indexName);

    // Construct scroll query
    searchRequestBuilder.setTypes(documentType).setScroll(new TimeValue(ELASTIC_SEARCH_SCROLL_KEEP_ALIVE_TIME))
            .setSize(ELASTIC_SEARCH_SCROLL_PAGE_SIZE).setSource(searchSourceBuilder)

            // Add sorting criteria.
            // First, sort in ascending order on business object definition name
            // then sort in ascending order on namespace code
            .addSort(SortBuilders.fieldSort(BUSINESS_OBJECT_DEFINITION_SORT_FIELD).order(SortOrder.ASC))
            .addSort(SortBuilders.fieldSort(NAMESPACE_CODE_SORT_FIELD).order(SortOrder.ASC));

    //Add aggregation builder if facet fields are present
    if (CollectionUtils.isNotEmpty(facetFieldsList)) {
        addFacetFieldAggregations(facetFieldsList, elasticsearchResponseDto, searchRequestBuilder, indexName);
    }

    // Log the actual search query
    LOGGER.info("bdefIndexSearchQuery={}", searchRequestBuilder.toString());

    elasticsearchResponseDto.setBusinessObjectDefinitionIndexSearchResponseDtos(
            scrollSearchResultsIntoBusinessObjectDefinitionDto(searchRequestBuilder, indexName));

    return elasticsearchResponseDto;
}

From source file:org.finra.herd.dao.impl.BusinessObjectDefinitionIndexSearchDaoImpl.java

private void addFacetFieldAggregations(Set<String> facetFieldsList,
        ElasticsearchResponseDto elasticsearchResponseDto, SearchRequestBuilder searchRequestBuilder,
        String indexName) {//from ww  w.  ja  v a2 s  .  c om
    if (!CollectionUtils.isEmpty(facetFieldsList) && (facetFieldsList.contains(TAG_FACET))) {

        searchRequestBuilder
                .addAggregation(AggregationBuilders.nested(TAG_FACET_AGGS, NESTED_BDEFTAGS_PATH)
                        .subAggregation(AggregationBuilders.terms(TAGTYPE_CODE_AGGREGATION)
                                .field(TAGTYPE_CODE_FIELD)
                                .subAggregation(AggregationBuilders.terms(TAGTYPE_NAME_AGGREGATION)
                                        .field(TAGTYPE_NAME_FIELD)
                                        .subAggregation(AggregationBuilders.terms(TAG_CODE_AGGREGATION)
                                                .field(TAG_CODE_FIELD).subAggregation(AggregationBuilders
                                                        .terms(TAG_NAME_AGGREGATION).field(TAG_NAME_FIELD))))));

        searchRequestBuilder.addAggregation(AggregationBuilders.terms(TAG_TYPE_FACET_AGGS)
                .field(TAGTYPE_CODE_FIELD)
                .subAggregation(AggregationBuilders.terms(NAMESPACE_CODE_AGGS).field(NAMESPACE_FIELD)
                        .subAggregation(AggregationBuilders.terms(BDEF_NAME_AGGS).field(BDEF_NAME_FIELD))));

        elasticsearchResponseDto.setTagTypeIndexSearchResponseDtos(
                searchResponseIntoFacetInformation(searchRequestBuilder, indexName));
    }
}

From source file:org.finra.herd.dao.impl.EmrDaoImpl.java

/**
 * Converts the given list of {@link EmrClusterDefinitionApplication} into a list of {@link Application}
 *
 * @param emrClusterDefinitionApplications list of {@link EmrClusterDefinitionApplication}
 *
 * @return list {@link Application}//from  w  w w  .  j  a  v a 2  s. c  om
 */
public List<Application> getApplications(
        List<EmrClusterDefinitionApplication> emrClusterDefinitionApplications) {
    List<Application> applications = new ArrayList<>();
    for (EmrClusterDefinitionApplication emrClusterDefinitionApplication : emrClusterDefinitionApplications) {
        Application application = new Application();
        application.setName(emrClusterDefinitionApplication.getName());
        application.setVersion(emrClusterDefinitionApplication.getVersion());
        application.setArgs(emrClusterDefinitionApplication.getArgs());

        List<Parameter> additionalInfoList = emrClusterDefinitionApplication.getAdditionalInfoList();
        if (!CollectionUtils.isEmpty(additionalInfoList)) {
            application.setAdditionalInfo(getMap(additionalInfoList));
        }

        applications.add(application);
    }
    return applications;
}

From source file:org.finra.herd.dao.impl.EmrDaoImpl.java

/**
 * Converts the given list of {@link EmrClusterDefinitionConfiguration} into a list of {@link Configuration}.
 *
 * @param emrClusterDefinitionConfigurations list of {@link EmrClusterDefinitionConfiguration}
 *
 * @return list of {@link Configuration}
 */// w w  w  .j  ava2 s. c  o m
protected List<Configuration> getConfigurations(
        List<EmrClusterDefinitionConfiguration> emrClusterDefinitionConfigurations) {
    List<Configuration> configurations = null;

    if (!CollectionUtils.isEmpty(emrClusterDefinitionConfigurations)) {
        configurations = new ArrayList<>();

        for (EmrClusterDefinitionConfiguration emrClusterDefinitionConfiguration : emrClusterDefinitionConfigurations) {
            if (emrClusterDefinitionConfiguration != null) {
                Configuration configuration = new Configuration();
                configuration.setClassification(emrClusterDefinitionConfiguration.getClassification());
                configuration.setConfigurations(
                        getConfigurations(emrClusterDefinitionConfiguration.getConfigurations()));
                configuration.setProperties(getMap(emrClusterDefinitionConfiguration.getProperties()));

                configurations.add(configuration);
            }
        }
    }

    return configurations;
}

From source file:org.finra.herd.dao.impl.EmrDaoImpl.java

/**
 * Creates a list of {@link EbsBlockDeviceConfig} from a given list of {@link EmrClusterDefinitionEbsBlockDeviceConfig}.
 *
 * @param emrClusterDefinitionEbsBlockDeviceConfigs the list of {@link EmrClusterDefinitionEbsBlockDeviceConfig}
 *
 * @return the list of {@link EbsBlockDeviceConfig}
 *///w  w w .j ava2s  .co  m
protected List<EbsBlockDeviceConfig> getEbsBlockDeviceConfigs(
        List<EmrClusterDefinitionEbsBlockDeviceConfig> emrClusterDefinitionEbsBlockDeviceConfigs) {
    List<EbsBlockDeviceConfig> ebsBlockDeviceConfigs = null;

    if (!CollectionUtils.isEmpty(emrClusterDefinitionEbsBlockDeviceConfigs)) {
        ebsBlockDeviceConfigs = new ArrayList<>();

        for (EmrClusterDefinitionEbsBlockDeviceConfig emrClusterDefinitionEbsBlockDeviceConfig : emrClusterDefinitionEbsBlockDeviceConfigs) {
            if (emrClusterDefinitionEbsBlockDeviceConfig != null) {
                EbsBlockDeviceConfig ebsBlockDeviceConfig = new EbsBlockDeviceConfig();
                ebsBlockDeviceConfig.setVolumeSpecification(getVolumeSpecification(
                        emrClusterDefinitionEbsBlockDeviceConfig.getVolumeSpecification()));
                ebsBlockDeviceConfig.setVolumesPerInstance(
                        emrClusterDefinitionEbsBlockDeviceConfig.getVolumesPerInstance());

                ebsBlockDeviceConfigs.add(ebsBlockDeviceConfig);
            }
        }
    }

    return ebsBlockDeviceConfigs;
}

From source file:org.finra.herd.dao.impl.EmrDaoImpl.java

/**
 * Creates an instance fleet configuration that describes the EC2 instances and instance configurations for clusters that use this feature.
 *
 * @param emrClusterDefinitionInstanceFleets the list of instance fleet configurations from the EMR cluster definition
 *
 * @return the instance fleet configuration
 *//*from   w w  w.j  a v  a2 s. com*/
protected List<InstanceFleetConfig> getInstanceFleets(
        List<EmrClusterDefinitionInstanceFleet> emrClusterDefinitionInstanceFleets) {
    List<InstanceFleetConfig> instanceFleets = null;

    if (!CollectionUtils.isEmpty(emrClusterDefinitionInstanceFleets)) {
        instanceFleets = new ArrayList<>();

        for (EmrClusterDefinitionInstanceFleet emrClusterDefinitionInstanceFleet : emrClusterDefinitionInstanceFleets) {
            if (emrClusterDefinitionInstanceFleet != null) {
                InstanceFleetConfig instanceFleetConfig = new InstanceFleetConfig();
                instanceFleetConfig.setName(emrClusterDefinitionInstanceFleet.getName());
                instanceFleetConfig
                        .setInstanceFleetType(emrClusterDefinitionInstanceFleet.getInstanceFleetType());
                instanceFleetConfig.setTargetOnDemandCapacity(
                        emrClusterDefinitionInstanceFleet.getTargetOnDemandCapacity());
                instanceFleetConfig
                        .setTargetSpotCapacity(emrClusterDefinitionInstanceFleet.getTargetSpotCapacity());
                instanceFleetConfig.setInstanceTypeConfigs(
                        getInstanceTypeConfigs(emrClusterDefinitionInstanceFleet.getInstanceTypeConfigs()));
                instanceFleetConfig.setLaunchSpecifications(
                        getLaunchSpecifications(emrClusterDefinitionInstanceFleet.getLaunchSpecifications()));

                instanceFleets.add(instanceFleetConfig);
            }
        }
    }

    return instanceFleets;
}