sequencebuiltins.java

freemaker安装软件

                            } else {
                                throw e;
                            }
                        }
                    }
                } else if (keyType == KEY_TYPE_DATE) {
                    for (i = 0; i < ln; i++) {
                        item = seq.get(i);
                        try {
                            res.add(new KVP(
                                    ((TemplateDateModel) item).getAsDate(),
                                    item));
                        } catch (ClassCastException e) {
                            if (!(item instanceof TemplateNumberModel)) {
                                throw new TemplateModelException(
                                        startErrorMessage(keys)
                                        + "All values in the sequence must be "
                                        + "date/time values, because the first "
                                        + "value was a date/time. "
                                        + "The value at index " + i
                                        + " is not date/time.");
                            } else {
                                throw e;
                            }
                        }
                    }
                } else {
                    throw new RuntimeException("FreeMarker bug: Bad key type");
                }
            } else {
                for (i = 0; i < ln; i++) {
                    item = seq.get(i);
                    Object key = item;
                    for (int j = 0; j < keyCnt; j++) {
                        try {
                            key = ((TemplateHashModel) key).get(keys[j]);
                        } catch (ClassCastException e) {
                            if (!(key instanceof TemplateHashModel)) {
                                throw new TemplateModelException(
                                        startErrorMessage(keys)
                                        + "Problem with the sequence item at index " + i + ": "
                                        + "Can't get the " + StringUtil.jQuote(keys[j])
                                        + " subvariable, because the value is not a hash.");
                            } else {
                                throw e;
                            }
                        }
                        if (key == null) {
                            throw new TemplateModelException(
                                    startErrorMessage(keys)
                                    + "Problem with the sequence item at index " + i + ": "
                                    + "The " + StringUtil.jQuote(keys[j])
                                    + " subvariable was not found.");
                        }
                    }
                    if (keyType == KEY_TYPE_STRING) {
                        try {
                            res.add(new KVP(
                                    ((TemplateScalarModel) key).getAsString(),
                                    item));
                        } catch (ClassCastException e) {
                            if (!(key instanceof TemplateScalarModel)) {
                                throw new TemplateModelException(
                                        startErrorMessage(keys)
                                        + "All key values in the sequence must be "
                                        + "date/time values, because the first key "
                                        + "value was a date/time. The key value at "
                                        + "index " + i + " is not a date/time.");
                            } else {
                                throw e;
                            }
                        }
                    } else if (keyType == KEY_TYPE_NUMBER) {
                        try {
                            res.add(new KVP(
                                    ((TemplateNumberModel) key).getAsNumber(),
                                    item));
                        } catch (ClassCastException e) {
                            if (!(key instanceof TemplateNumberModel)) {
                                throw new TemplateModelException(
                                        startErrorMessage(keys)
                                        + "All key values in the sequence must be "
                                        + "numbers, because the first key "
                                        + "value was a number. The key value at "
                                        + "index " + i + " is not a number.");
                            }
                        }
                    } else if (keyType == KEY_TYPE_DATE) {
                        try {
                            res.add(new KVP(
                                    ((TemplateDateModel) key).getAsDate(),
                                    item));
                        } catch (ClassCastException e) {
                            if (!(key instanceof TemplateDateModel)) {
                                throw new TemplateModelException(
                                        startErrorMessage(keys)
                                        + "All key values in the sequence must be "
                                        + "dates, because the first key "
                                        + "value was a date. The key value at "
                                        + "index " + i + " is not a date.");
                            }
                        }
                    } else {
                        throw new RuntimeException("FreeMarker bug: Bad key type");
                    }
                }
            }

            Comparator cmprtr;
            if (keyType == KEY_TYPE_STRING) {
                cmprtr = new LexicalKVPComparator(
                        Environment.getCurrentEnvironment().getCollator());
            } else if (keyType == KEY_TYPE_NUMBER) {
                cmprtr = new NumericalKVPComparator(
                        Environment.getCurrentEnvironment()
                                .getArithmeticEngine());
            } else if (keyType == KEY_TYPE_DATE) {
                cmprtr = new DateKVPComparator();
            } else {
                throw new RuntimeException("FreeMarker bug: Bad key type");
            }

            try {
                Collections.sort(res, cmprtr);
            } catch (ClassCastException exc) {
                throw new TemplateModelException(
                        startErrorMessage(keys)
                        + "Unexpected error while sorting:" + exc, exc);
            }

            for (i = 0; i < ln; i++) {
                res.set(i, ((KVP) res.get(i)).value);
            }

            return new TemplateModelListSequence(res);
        }

        private static class KVP {
            private KVP(Object key, Object value) {
                this.key = key;
                this.value = value;
            }

            private Object key;
            private Object value;
        }

        private static class NumericalKVPComparator implements Comparator {
            private ArithmeticEngine ae;

            private NumericalKVPComparator(ArithmeticEngine ae) {
                this.ae = ae;
            }

            public int compare(Object arg0, Object arg1) {
                try {
                    return ae.compareNumbers(
                            (Number) ((KVP) arg0).key,
                            (Number) ((KVP) arg1).key);
                } catch (TemplateException e) {
                    throw new ClassCastException(
                        "Failed to compare numbers: " + e);
                }
            }
        }

        private static class LexicalKVPComparator implements Comparator {
            private Collator collator;

            LexicalKVPComparator(Collator collator) {
                this.collator = collator;
            }

            public int compare(Object arg0, Object arg1) {
                return collator.compare(
                        ((KVP) arg0).key, ((KVP) arg1).key);
            }
        }
        
        private static class DateKVPComparator implements Comparator {

            public int compare(Object arg0, Object arg1) {
                return ((Date) ((KVP) arg0).key).compareTo(
                        (Date) ((KVP) arg1).key);
            }
        }
        
    }
    
    static class sort_byBI extends sortBI {
        TemplateModel calculateResult(TemplateSequenceModel seq)
        {
            return new BIMethod(seq);
        }
        
        static class BIMethod implements TemplateMethodModelEx {
            TemplateSequenceModel seq;
            
            BIMethod(TemplateSequenceModel seq) {
                this.seq = seq;
            }
            
            public Object exec(List params)
                    throws TemplateModelException {
                if (params.size() == 0) {
                    throw new TemplateModelException(
                            "?sort_by(key) needs exactly 1 argument.");
                }
                String[] subvars;
                Object obj = params.get(0);
                if (obj instanceof TemplateScalarModel) {
                    subvars = new String[]{((TemplateScalarModel) obj).getAsString()};
                } else if (obj instanceof TemplateSequenceModel) {
                    TemplateSequenceModel seq = (TemplateSequenceModel) obj;
                    int ln = seq.size();
                    subvars = new String[ln];
                    for (int i = 0; i < ln; i++) {
                        Object item = seq.get(i);
                        try {
                            subvars[i] = ((TemplateScalarModel) item)
                                    .getAsString();
                        } catch (ClassCastException e) {
                            if (!(item instanceof TemplateScalarModel)) {
                                throw new TemplateModelException(
                                        "The argument to ?sort_by(key), when it "
                                        + "is a sequence, must be a sequence of "
                                        + "strings, but the item at index " + i
                                        + " is not a string." );
                            }
                        }
                    }
                } else {
                    throw new TemplateModelException(
                            "The argument to ?sort_by(key) must be a string "
                            + "(the name of the subvariable), or a sequence of "
                            + "strings (the \"path\" to the subvariable).");
                }
                return sort(seq, subvars); 
            }
        }
    }

    static class seq_containsBI extends BuiltIn {
        TemplateModel _getAsTemplateModel(Environment env)
                throws TemplateException {
            TemplateModel model = target.getAsTemplateModel(env);
            if (model instanceof TemplateSequenceModel) {
                return new BIMethodForSequence((TemplateSequenceModel) model, env);
            } else if (model instanceof TemplateCollectionModel) {
                return new BIMethodForCollection((TemplateCollectionModel) model, env);
            } else {
                throw invalidTypeException(model, target, env, "sequence or collection");
            }
        }

        private class BIMethodForSequence implements TemplateMethodModelEx {
            private TemplateSequenceModel m_seq;
            private Environment m_env;

            private BIMethodForSequence(TemplateSequenceModel seq, Environment env) {
                m_seq = seq;
                m_env = env;
            }

            public Object exec(List args)
                    throws TemplateModelException {
                if (args.size() != 1)
                    throw new TemplateModelException("?seq_contains(...) expects one argument.");
                TemplateModel arg = (TemplateModel) args.get(0);
                int size = m_seq.size();
                for (int i = 0; i < size; i++) {
                    if (modelsEqual(m_seq.get(i), arg, m_env))
                        return TemplateBooleanModel.TRUE;
                }
                return TemplateBooleanModel.FALSE;
            }

        }
    
        private class BIMethodForCollection implements TemplateMethodModelEx {
            private TemplateCollectionModel m_coll;