public static void validate(FullCondition fullCondition)
            throws CubeNotExistsException, SchemaNotExistsException,
            InvalidConditionException {
        CubeCondition cubeCondition = fullCondition.getCubeCondition();
        SetCondition setCondition = fullCondition.getSetCondition();
        TargetCondition targetCondition = fullCondition.getTargetCondition();
        AggregationCondition aggregationCondition = fullCondition
                .getAggregationCondition();

        SchemaClientInterface schemaClient = SchemaClient.getSchemaClient();
        Schema schema = schemaClient.getSchema(cubeCondition
                .getCubeIdentifier());
        SortedSet<Dimension> dimensions = schema.getDimensions();

        // CubeCondition: cubeIdentifier and corresponding schema exists
        schemaClient.getSchema(cubeCondition.getCubeIdentifier());

        // SetCondition: dimensions exists in the schema
        List<Integer> orders = setCondition.getDimensionOrders();
        for (int order : orders) {
            getCorrespondingDimension(order, dimensions);
        }

        // SetCondition: start&end in DimesnionRange
        orders = setCondition.getDimensionOrders();
        List<Long> startPoint = setCondition.getStartPoint();
        int i = 0;
        for (int order : orders) {
            Dimension dimension = getCorrespondingDimension(order, dimensions);
            if (!(dimension.getRange().getStart() <= startPoint.get(i))) {
                throw new InvalidConditionException(
                        "the start in startPoint is not bigger than the start in the dimension range");
            }
            i += 1;
        }
        List<Long> endPoint = setCondition.getEndPoint();
        i = 0;
        for (int order : orders) {
            Dimension dimension = getCorrespondingDimension(order, dimensions);
            if (!(endPoint.get(i) <= dimension.getRange().getEnd())) {
                throw new InvalidConditionException(
                        "the end in endPoint is not smaller than the end in the dimension range");
            }
            i += 1;
        }

        // TargetCondition: dimensions exists in the schema
        SortedSet<DimensionLevelPair> pairs = targetCondition.getPairs();
        for (DimensionLevelPair pair : pairs) {
            getCorrespondingDimension(pair.getDimensionOrderNo(), dimensions);
        }

        // TargetCondition: all levels exists in corresponding dimension
        pairs = targetCondition.getPairs();
        for (DimensionLevelPair pair : pairs) {
            Dimension dimension = getCorrespondingDimension(
                    pair.getDimensionOrderNo(), dimensions);
            SortedSet<Level> levels = dimension.getLevels();
            getCorrespondingLevel(pair.getLevelOrderNo(), levels);
        }

        // AggregationCondition: type validate
        if (!(aggregationCondition.getAggregationType() instanceof AggregationCondition.Type)) {
            throw new InvalidConditionException("aggregation type is invalid");
        }
    }