Java Code Examples for org.apache.commons.collections.CollectionUtils#collect()

final public boolean isCurricularCourseApproved(CurricularCourse curricularCourse) {
    List studentApprovedEnrollments = getStudentEnrollmentsWithApprovedState();

    List<CurricularCourse> result =
            (List<CurricularCourse>) CollectionUtils.collect(studentApprovedEnrollments, new Transformer() {
                @Override
                final public Object transform(Object obj) {
                    Enrolment enrollment = (Enrolment) obj;

                    return enrollment.getCurricularCourse();

                }
            });

    return isApproved(curricularCourse, result);
}
 

@Atomic
public static Object run(InfoClass infoClass) {
    check(RolePredicates.RESOURCE_ALLOCATION_MANAGER_PREDICATE);
    SchoolClass schoolClass = FenixFramework.getDomainObject(infoClass.getExternalId());

    Collection<Shift> shifts = schoolClass.getAssociatedShiftsSet();

    return CollectionUtils.collect(shifts, new Transformer() {
        @Override
        public Object transform(Object arg0) {
            Shift shift = (Shift) arg0;
            InfoShift infoShift = InfoShift.newInfoFromDomain(shift);
            return infoShift;
        }
    });
}
 

private static Collection<InfoDegreeCurricularPlan> getActiveDegreeCurricularPlansByDegreeType(
        Predicate<DegreeType> degreeType, AccessControlPredicate<Object> permission) {
    List<DegreeCurricularPlan> degreeCurricularPlans = new ArrayList<DegreeCurricularPlan>();
    for (DegreeCurricularPlan dcp : DegreeCurricularPlan.readByDegreeTypeAndState(degreeType,
            DegreeCurricularPlanState.ACTIVE)) {
        if (permission != null) {
            if (!permission.evaluate(dcp.getDegree())) {
                continue;
            }
        }
        degreeCurricularPlans.add(dcp);
    }

    return CollectionUtils.collect(degreeCurricularPlans, new Transformer() {

        @Override
        public Object transform(Object arg0) {
            DegreeCurricularPlan degreeCurricularPlan = (DegreeCurricularPlan) arg0;
            return InfoDegreeCurricularPlan.newInfoFromDomain(degreeCurricularPlan);
        }

    });
}
 

protected List run(String degreeCurricularPlanID) throws FenixServiceException {
    // Read the Students
    DegreeCurricularPlan degreeCurricularPlan = FenixFramework.getDomainObject(degreeCurricularPlanID);

    Collection students = degreeCurricularPlan.getStudentCurricularPlansSet();

    if ((students == null) || (students.isEmpty())) {
        throw new NonExistingServiceException();
    }

    return (List) CollectionUtils.collect(students, new Transformer() {
        @Override
        public Object transform(Object arg0) {
            StudentCurricularPlan studentCurricularPlan = (StudentCurricularPlan) arg0;
            return InfoStudentCurricularPlan.newInfoFromDomain(studentCurricularPlan);
        }

    });
}
 

public <T extends MDRResource> List<T> createList(ExtendedIterator<? extends RDFNode> it,
		Class<T> cls) throws MDRException {

	List<T> newList = new ArrayList<T>();
	try {
		Transformer transformer = transformerMap.get(cls);
		CollectionUtils.collect(it, transformer, newList);
	} catch (Exception e) {
		throw new MDRException(e);
	}
	return newList;
}
 

private Object toShortNameOfList(final Object value)
{
  if (value instanceof Collection< ? >) {
    return CollectionUtils.collect((Collection< ? >) value, new Transformer() {
      public Object transform(final Object input)
      {
        return toShortName(input);
      }
    });
  }
  return value;
}
 

private List<CurricularCourse> getStudentNotNeedToEnrollCurricularCourses() {
    return (List<CurricularCourse>) CollectionUtils.collect(getNotNeedToEnrollCurricularCoursesSet(), new Transformer() {
        @Override
        final public Object transform(Object obj) {
            NotNeedToEnrollInCurricularCourse notNeedToEnrollInCurricularCourse = (NotNeedToEnrollInCurricularCourse) obj;
            return notNeedToEnrollInCurricularCourse.getCurricularCourse();
        }
    });
}
 

final public boolean isCurricularCourseEnrolled(CurricularCourse curricularCourse) {
    List result = (List) CollectionUtils.collect(getStudentEnrollmentsWithEnrolledState(), new Transformer() {
        @Override
        final public Object transform(Object obj) {
            Enrolment enrollment = (Enrolment) obj;
            return enrollment.getCurricularCourse();
        }
    });

    return result.contains(curricularCourse);
}
 

final public boolean isEquivalentAproved(CurricularCourse curricularCourse) {
    List studentApprovedEnrollments = getStudentEnrollmentsWithApprovedState();

    List<CurricularCourse> result = (List) CollectionUtils.collect(studentApprovedEnrollments, new Transformer() {
        @Override
        final public Object transform(Object obj) {
            Enrolment enrollment = (Enrolment) obj;

            return enrollment.getCurricularCourse();

        }
    });

    return isThisCurricularCoursesInTheList(curricularCourse, result) || hasEquivalenceInNotNeedToEnroll(curricularCourse);
}
 

public List<Degree> getDegreesAssociatedToTeacherAsCoordinator(final Teacher teacher) {
    List<MobilityCoordinator> coordinators = getErasmusCoordinatorForTeacher(teacher);

    return new ArrayList<Degree>(CollectionUtils.collect(coordinators, new Transformer() {

        @Override
        public Object transform(Object arg0) {
            return ((MobilityCoordinator) arg0).getDegree();
        }
    }));
}
 

private static Set<String> getExecutionCourseCodes(ExecutionSemester executionSemester) {
    Collection<ExecutionCourse> executionCourses = executionSemester.getAssociatedExecutionCoursesSet();
    return new HashSet<String>(CollectionUtils.collect(executionCourses, new Transformer() {
        @Override
        public Object transform(Object arg0) {
            ExecutionCourse executionCourse = (ExecutionCourse) arg0;
            return executionCourse.getSigla().toUpperCase();
        }
    }));
}
 

public List getAssociatedRooms() {
    return (List) CollectionUtils.collect(super.getWrittenEvaluationSpaceOccupations(), new Transformer() {

        @Override
        public Object transform(Object arg0) {
            InfoRoomOccupation roomOccupation = (InfoRoomOccupation) arg0;
            return roomOccupation.getInfoRoom();
        }
    });
}
 

/**
 * Converts list of RouteNodeInstance objects to a list of the route node names
 * @param routeNodeInstances the list RouteNodeInstance objects, may be null
 * @return non-null, possibly empty, Collection of routenode names
 */
protected Collection<String> toRouteNodeNames(Collection<RouteNodeInstance> routeNodeInstances) {
    if (routeNodeInstances != null) {
        return CollectionUtils.collect(routeNodeInstances, new Transformer() {
            @Override
            public Object transform(Object input) {
                return ((RouteNodeInstance) input).getName();
            }
        });
    } else {
        return Collections.EMPTY_LIST;
    }
}
 

@Test(dependsOnMethods = "testCreate")
public void associateSameTagToMultipleEntities() throws AtlasBaseException {
    final String TAG_NAME            = "tagx";
    final String TAG_ATTRIBUTE_NAME  = "testAttribute";
    final String TAG_ATTRIBUTE_VALUE = "test-string";

    createTag(TAG_NAME, "string");
    List<AtlasClassification> addedClassifications = new ArrayList<>();
    addedClassifications.add(new AtlasClassification(TAG_NAME, TAG_ATTRIBUTE_NAME, TAG_ATTRIBUTE_VALUE));

    entityStore.addClassifications(dbEntityGuid, addedClassifications);
    entityStore.addClassifications(tblEntityGuid, addedClassifications);

    AtlasEntity dbEntityFromDb  = getEntityFromStore(dbEntityGuid);
    AtlasEntity tblEntityFromDb = getEntityFromStore(tblEntityGuid);

    Set<String> actualDBClassifications  = new HashSet<>(CollectionUtils.collect(dbEntityFromDb.getClassifications(), o -> ((AtlasClassification) o).getTypeName()));
    Set<String> actualTblClassifications = new HashSet<>(CollectionUtils.collect(tblEntityFromDb.getClassifications(), o -> ((AtlasClassification) o).getTypeName()));

    assertTrue(actualDBClassifications.contains(TAG_NAME));
    assertTrue(actualTblClassifications.contains(TAG_NAME));

    Set<String> actualDBAssociatedEntityGuid  = new HashSet<>(CollectionUtils.collect(dbEntityFromDb.getClassifications(), o -> ((AtlasClassification) o).getEntityGuid()));
    Set<String> actualTblAssociatedEntityGuid = new HashSet<>(CollectionUtils.collect(tblEntityFromDb.getClassifications(), o -> ((AtlasClassification) o).getEntityGuid()));

    assertTrue(actualDBAssociatedEntityGuid.contains(dbEntityGuid));
    assertTrue(actualTblAssociatedEntityGuid.contains(tblEntityGuid));

    entityStore.deleteClassification(dbEntityGuid, TAG_NAME);
    entityStore.deleteClassification(tblEntityGuid, TAG_NAME);
}
 

@Test(dependsOnMethods = "testCreate")
public void associateMultipleTagsToOneEntity() throws AtlasBaseException {
    final String TAG_NAME              = "tag_xy";
    final String TAG_NAME_2            = TAG_NAME + "_2";
    final String TAG_ATTRIBUTE_NAME    = "testAttribute";
    final String TAG_ATTRIBUTE_VALUE   = "test-string";
    final String TAG_ATTRIBUTE_VALUE_2 = TAG_ATTRIBUTE_VALUE + "-2";

    createTag(TAG_NAME, "string");
    createTag(TAG_NAME_2, "string");

    List<AtlasClassification> addedClassifications = new ArrayList<>();
    addedClassifications.add(new AtlasClassification(TAG_NAME, TAG_ATTRIBUTE_NAME, TAG_ATTRIBUTE_VALUE));
    addedClassifications.add(new AtlasClassification(TAG_NAME_2, TAG_ATTRIBUTE_NAME, TAG_ATTRIBUTE_VALUE_2));
    entityStore.addClassifications(dbEntityGuid, addedClassifications);

    AtlasEntity dbEntityFromDb = getEntityFromStore(dbEntityGuid);

    List<String> actualClassifications = (List<String>) CollectionUtils.collect(dbEntityFromDb.getClassifications(), o -> ((AtlasClassification) o).getTypeName());
    Set<String> classificationSet = new HashSet<>(actualClassifications);
    assertTrue(classificationSet.contains(TAG_NAME));
    assertTrue(classificationSet.contains(TAG_NAME_2));

    for (String actualClassificationName : actualClassifications) {
        entityStore.deleteClassification(dbEntityGuid, actualClassificationName);
    }
}
 

@Override
public String[] getPropertyNames() {
    ArrayList<String> keys = new ArrayList<>();
    CollectionUtils.collect(this.source.getKeys(), NOPTransformer.getInstance(), keys);
    return keys.toArray(new String[keys.size()]);
}
 

@Override
public String[] getPropertyNames() {
    ArrayList<String> keys = new ArrayList<>();
    CollectionUtils.collect(this.source.getKeys(), NOPTransformer.getInstance(), keys);
    return keys.toArray(new String[keys.size()]);
}
 

@Override
public String[] getPropertyNames() {
    ArrayList<String> keys = new ArrayList<>();
    CollectionUtils.collect(this.source.getKeys(), NOPTransformer.getInstance(), keys);
    return keys.toArray(new String[keys.size()]);
}
 

@Override
public String[] getPropertyNames() {
    ArrayList<String> keys = new ArrayList<>();
    CollectionUtils.collect(this.source.getKeys(), NOPTransformer.getInstance(), keys);
    return keys.toArray(new String[keys.size()]);
}