Example usage for org.apache.commons.lang ArrayUtils EMPTY_CHAR_ARRAY

List of usage examples for org.apache.commons.lang ArrayUtils EMPTY_CHAR_ARRAY

Introduction

In this page you can find the example usage for org.apache.commons.lang ArrayUtils EMPTY_CHAR_ARRAY.

Prototype

null EMPTY_CHAR_ARRAY

To view the source code for org.apache.commons.lang ArrayUtils EMPTY_CHAR_ARRAY.

Click Source Link

Document

An empty immutable char array.

Usage

From source file:org.apache.cocoon.generation.JXTemplateGenerator.java

private void characters(JexlContext jexlContext, JXPathContext jxpathContext, TextEvent event,
        CharHandler handler) throws SAXException {
    Iterator iter = event.substitutions.iterator();
    while (iter.hasNext()) {
        Object subst = iter.next();
        char[] chars;
        if (subst instanceof char[]) {
            chars = (char[]) subst;
        } else {/*from   ww  w  .j ava2 s  .  c o  m*/
            JXTExpression expr = (JXTExpression) subst;
            try {
                Object val = getValue(expr, jexlContext, jxpathContext);
                chars = val != null ? val.toString().toCharArray() : ArrayUtils.EMPTY_CHAR_ARRAY;
            } catch (Exception e) {
                throw new JXTException(e.getMessage(), event.location, e);
            }
        }
        handler.characters(chars, 0, chars.length);
    }
}

From source file:org.apache.cocoon.generation.JXTemplateGenerator.java

private void execute(final XMLConsumer consumer, MyJexlContext jexlContext, JXPathContext jxpathContext,
        StartElement macroCall, Event startEvent, Event endEvent) throws SAXException {
    Event ev = startEvent;//from   w  ww .  jav  a  2s  . c o m
    LocationFacade loc = new LocationFacade(ev.location);
    consumer.setDocumentLocator(loc);
    while (ev != endEvent) {
        loc.setDocumentLocation(ev.location);
        if (ev instanceof Characters) {
            TextEvent text = (TextEvent) ev;
            Iterator iter = text.substitutions.iterator();
            while (iter.hasNext()) {
                Object subst = iter.next();
                char[] chars;
                if (subst instanceof char[]) {
                    chars = (char[]) subst;
                } else {
                    JXTExpression expr = (JXTExpression) subst;
                    try {
                        Object val = getNode(expr, jexlContext, jxpathContext);
                        if (val instanceof Node) {
                            executeDOM(consumer, jexlContext, jxpathContext, (Node) val);
                            continue;
                        } else if (val instanceof NodeList) {
                            NodeList nodeList = (NodeList) val;
                            int len = nodeList.getLength();
                            for (int i = 0; i < len; i++) {
                                Node n = nodeList.item(i);
                                executeDOM(consumer, jexlContext, jxpathContext, n);
                            }
                            continue;
                        } else if (val instanceof Node[]) {
                            Node[] nodeList = (Node[]) val;
                            int len = nodeList.length;
                            for (int i = 0; i < len; i++) {
                                Node n = nodeList[i];
                                executeDOM(consumer, jexlContext, jxpathContext, n);
                            }
                            continue;
                        } else if (val instanceof XMLizable) {
                            ((XMLizable) val).toSAX(new IncludeXMLConsumer(consumer));
                            continue;
                        }
                        chars = val != null ? val.toString().toCharArray() : ArrayUtils.EMPTY_CHAR_ARRAY;
                    } catch (Exception e) {
                        throw new JXTException(e.getMessage(), ev.location, e);
                    }
                }
                consumer.characters(chars, 0, chars.length);
            }
        } else if (ev instanceof EndElement) {
            EndElement endElement = (EndElement) ev;
            StartElement startElement = endElement.startElement;
            StartDefine def = (StartDefine) definitions.get(startElement.qname);
            if (def == null) {
                consumer.endElement(startElement.namespaceURI, startElement.localName, startElement.raw);
                namespaces.leaveScope(consumer);
            }
        } else if (ev instanceof EndPrefixMapping) {
            EndPrefixMapping endPrefixMapping = (EndPrefixMapping) ev;
            namespaces.removeDeclaration(endPrefixMapping.prefix);
        } else if (ev instanceof IgnorableWhitespace) {
            TextEvent text = (TextEvent) ev;
            characters(jexlContext, jxpathContext, text, new CharHandler() {
                public void characters(char[] ch, int offset, int len) throws SAXException {
                    consumer.ignorableWhitespace(ch, offset, len);
                }
            });
        } else if (ev instanceof SkippedEntity) {
            SkippedEntity skippedEntity = (SkippedEntity) ev;
            consumer.skippedEntity(skippedEntity.name);
        } else if (ev instanceof StartIf) {
            StartIf startIf = (StartIf) ev;
            Object val;
            try {
                val = getValue(startIf.test, jexlContext, jxpathContext, Boolean.TRUE);
            } catch (Exception e) {
                throw new JXTException(e.getMessage(), ev.location, e);
            }
            boolean result = false;
            if (val instanceof Boolean) {
                result = ((Boolean) val).booleanValue();
            } else {
                result = (val != null);
            }
            if (!result) {
                ev = startIf.endInstruction.next;
                continue;
            }
        } else if (ev instanceof StartForEach) {
            StartForEach startForEach = (StartForEach) ev;
            final Object items = startForEach.items;
            Iterator iter = null;
            int begin, end, step;
            String var, varStatus;
            try {
                if (items != null) {
                    JXTExpression expr = (JXTExpression) items;
                    if (expr.compiledExpression instanceof CompiledExpression) {
                        CompiledExpression compiledExpression = (CompiledExpression) expr.compiledExpression;
                        Object val = compiledExpression.getPointer(jxpathContext, expr.raw).getNode();
                        // FIXME: workaround for JXPath bug
                        iter = val instanceof NativeArray
                                ? new JSIntrospector.NativeArrayIterator((NativeArray) val)
                                : compiledExpression.iteratePointers(jxpathContext);
                    } else if (expr.compiledExpression instanceof Expression) {
                        Expression e = (Expression) expr.compiledExpression;
                        Object result = e.evaluate(jexlContext);
                        if (result != null) {
                            iter = Introspector.getUberspect().getIterator(result,
                                    new Info(ev.location.getURI(), ev.location.getLineNumber(),
                                            ev.location.getColumnNumber()));
                        }
                        if (iter == null) {
                            iter = EMPTY_ITER;
                        }
                    } else {
                        // literal value
                        iter = new Iterator() {
                            Object val = items;

                            public boolean hasNext() {
                                return val != null;
                            }

                            public Object next() {
                                Object res = val;
                                val = null;
                                return res;
                            }

                            public void remove() {
                                // EMPTY
                            }
                        };
                    }
                } else {
                    iter = NULL_ITER;
                }
                begin = startForEach.begin == null ? 0
                        : getIntValue(startForEach.begin, jexlContext, jxpathContext);
                end = startForEach.end == null ? Integer.MAX_VALUE
                        : getIntValue(startForEach.end, jexlContext, jxpathContext);
                step = startForEach.step == null ? 1
                        : getIntValue(startForEach.step, jexlContext, jxpathContext);
                var = getStringValue(startForEach.var, jexlContext, jxpathContext);
                varStatus = getStringValue(startForEach.varStatus, jexlContext, jxpathContext);
            } catch (Exception exc) {
                throw new JXTException(exc.getMessage(), ev.location, exc);
            }
            MyJexlContext localJexlContext = new MyJexlContext(jexlContext);
            MyVariables localJXPathVariables = new MyVariables((MyVariables) jxpathContext.getVariables());
            int i = 0;
            // Move to the begin row
            while (i < begin && iter.hasNext()) {
                iter.next();
                i++;
            }
            LoopTagStatus status = null;
            if (varStatus != null) {
                status = new LoopTagStatus();
                status.begin = begin;
                status.end = end;
                status.step = step;
                status.first = true;
                localJexlContext.put(varStatus, status);
                localJXPathVariables.declareVariable(varStatus, status);
            }
            int skipCounter, count = 1;
            JXPathContext localJXPathContext = null;
            while (i <= end && iter.hasNext()) {
                Object value = iter.next();
                if (value instanceof Pointer) {
                    Pointer ptr = (Pointer) value;
                    localJXPathContext = jxpathContext.getRelativeContext(ptr);
                    localJXPathContext.setNamespaceContextPointer(new NamespacesTablePointer(namespaces));
                    try {
                        value = ptr.getNode();
                    } catch (Exception exc) {
                        throw new JXTException(exc.getMessage(), ev.location, null);
                    }
                } else {
                    localJXPathContext = jxpathContextFactory.newContext(jxpathContext, value);
                    localJXPathContext.setNamespaceContextPointer(new NamespacesTablePointer(namespaces));
                }
                localJXPathContext.setVariables(localJXPathVariables);
                if (var != null) {
                    localJexlContext.put(var, value);
                }
                if (status != null) {
                    status.index = i;
                    status.count = count;
                    status.first = i == begin;
                    status.current = value;
                    status.last = (i == end || !iter.hasNext());
                }
                execute(consumer, localJexlContext, localJXPathContext, macroCall, startForEach.next,
                        startForEach.endInstruction);
                // Skip rows
                skipCounter = step;
                while (--skipCounter > 0 && iter.hasNext()) {
                    iter.next();
                }
                // Increase index
                i += step;
                count++;
            }
            ev = startForEach.endInstruction.next;
            continue;
        } else if (ev instanceof StartChoose) {
            StartChoose startChoose = (StartChoose) ev;
            StartWhen startWhen = startChoose.firstChoice;
            while (startWhen != null) {
                Object val;
                try {
                    val = getValue(startWhen.test, jexlContext, jxpathContext, Boolean.TRUE);
                } catch (Exception e) {
                    throw new JXTException(e.getMessage(), ev.location, e);
                }
                boolean result;
                if (val instanceof Boolean) {
                    result = ((Boolean) val).booleanValue();
                } else {
                    result = (val != null);
                }
                if (result) {
                    execute(consumer, jexlContext, jxpathContext, macroCall, startWhen.next,
                            startWhen.endInstruction);
                    break;
                }
                startWhen = startWhen.nextChoice;
            }
            if (startWhen == null && startChoose.otherwise != null) {
                execute(consumer, jexlContext, jxpathContext, macroCall, startChoose.otherwise.next,
                        startChoose.otherwise.endInstruction);
            }
            ev = startChoose.endInstruction.next;
            continue;
        } else if (ev instanceof StartSet) {
            StartSet startSet = (StartSet) ev;
            Object value = null;
            String var = null;
            try {
                if (startSet.var != null) {
                    var = getStringValue(startSet.var, jexlContext, jxpathContext);
                }
                if (startSet.value != null) {
                    value = getNode(startSet.value, jexlContext, jxpathContext);
                }
            } catch (Exception exc) {
                throw new JXTException(exc.getMessage(), ev.location, exc);
            }
            if (value == null) {
                NodeList nodeList = toDOMNodeList("set", startSet, jexlContext, macroCall);
                // JXPath doesn't handle NodeList, so convert it to an array
                int len = nodeList.getLength();
                Node[] nodeArr = new Node[len];
                for (int i = 0; i < len; i++) {
                    nodeArr[i] = nodeList.item(i);
                }
                value = nodeArr;
            }
            if (var != null) {
                jxpathContext.getVariables().declareVariable(var, value);
                jexlContext.put(var, value);
            }
            ev = startSet.endInstruction.next;
            continue;
        } else if (ev instanceof StartElement) {
            StartElement startElement = (StartElement) ev;
            StartDefine def = (StartDefine) definitions.get(startElement.qname);
            if (def != null) {
                Map attributeMap = new HashMap();
                Iterator i = startElement.attributeEvents.iterator();
                while (i.hasNext()) {
                    String attributeName;
                    Object attributeValue;
                    AttributeEvent attrEvent = (AttributeEvent) i.next();
                    attributeName = attrEvent.localName;
                    if (attrEvent instanceof CopyAttribute) {
                        CopyAttribute copy = (CopyAttribute) attrEvent;
                        attributeValue = copy.value;
                    } else if (attrEvent instanceof SubstituteAttribute) {
                        SubstituteAttribute substEvent = (SubstituteAttribute) attrEvent;
                        if (substEvent.substitutions.size() == 1
                                && substEvent.substitutions.get(0) instanceof JXTExpression) {
                            JXTExpression expr = (JXTExpression) substEvent.substitutions.get(0);
                            Object val;
                            try {
                                val = getNode(expr, jexlContext, jxpathContext);
                            } catch (Exception e) {
                                throw new JXTException(e.getMessage(), ev.location, e);
                            }
                            attributeValue = val != null ? val : "";
                        } else {
                            StringBuffer buf = new StringBuffer();
                            Iterator iterSubst = substEvent.substitutions.iterator();
                            while (iterSubst.hasNext()) {
                                Subst subst = (Subst) iterSubst.next();
                                if (subst instanceof Literal) {
                                    Literal lit = (Literal) subst;
                                    buf.append(lit.value);
                                } else if (subst instanceof JXTExpression) {
                                    JXTExpression expr = (JXTExpression) subst;
                                    Object val;
                                    try {
                                        val = getValue(expr, jexlContext, jxpathContext);
                                    } catch (Exception e) {
                                        throw new JXTException(e.getMessage(), ev.location, e);
                                    }
                                    buf.append(val != null ? val.toString() : "");
                                }
                            }
                            attributeValue = buf.toString();
                        }
                    } else {
                        throw new Error("this shouldn't have happened");
                    }
                    attributeMap.put(attributeName, attributeValue);
                }
                MyVariables parent = (MyVariables) jxpathContext.getVariables();
                MyVariables vars = new MyVariables(parent);
                MyJexlContext localJexlContext = new MyJexlContext(jexlContext);
                HashMap macro = new HashMap();
                macro.put("body", startElement);
                macro.put("arguments", attributeMap);
                localJexlContext.put("macro", macro);
                vars.declareVariable("macro", macro);
                Iterator iter = def.parameters.entrySet().iterator();
                while (iter.hasNext()) {
                    Map.Entry e = (Map.Entry) iter.next();
                    String key = (String) e.getKey();
                    StartParameter startParam = (StartParameter) e.getValue();
                    Object default_ = startParam.default_;
                    Object val = attributeMap.get(key);
                    if (val == null) {
                        val = default_;
                    }
                    localJexlContext.put(key, val);
                    vars.declareVariable(key, val);
                }
                JXPathContext localJXPathContext = jxpathContextFactory.newContext(null,
                        jxpathContext.getContextBean());
                localJXPathContext.setNamespaceContextPointer(new NamespacesTablePointer(namespaces));
                localJXPathContext.setVariables(vars);
                call(ev.location, startElement, consumer, localJexlContext, localJXPathContext, def.body,
                        def.endInstruction);
                ev = startElement.endElement.next;
                continue;
            }
            Iterator i = startElement.attributeEvents.iterator();
            AttributesImpl attrs = new AttributesImpl();
            while (i.hasNext()) {
                AttributeEvent attrEvent = (AttributeEvent) i.next();
                if (attrEvent instanceof CopyAttribute) {
                    CopyAttribute copy = (CopyAttribute) attrEvent;
                    attrs.addAttribute(copy.namespaceURI, copy.localName, copy.raw, copy.type, copy.value);
                } else if (attrEvent instanceof SubstituteAttribute) {
                    StringBuffer buf = new StringBuffer();
                    SubstituteAttribute substEvent = (SubstituteAttribute) attrEvent;
                    Iterator iterSubst = substEvent.substitutions.iterator();
                    while (iterSubst.hasNext()) {
                        Subst subst = (Subst) iterSubst.next();
                        if (subst instanceof Literal) {
                            Literal lit = (Literal) subst;
                            buf.append(lit.value);
                        } else if (subst instanceof JXTExpression) {
                            JXTExpression expr = (JXTExpression) subst;
                            Object val;
                            try {
                                val = getValue(expr, jexlContext, jxpathContext);
                            } catch (Exception e) {
                                throw new JXTException(e.getMessage(), ev.location, e);
                            }
                            buf.append(val != null ? val.toString() : "");
                        }
                    }
                    attrs.addAttribute(attrEvent.namespaceURI, attrEvent.localName, attrEvent.raw,
                            attrEvent.type, buf.toString());
                }
            }
            namespaces.enterScope(consumer);
            consumer.startElement(startElement.namespaceURI, startElement.localName, startElement.raw, attrs);
        } else if (ev instanceof StartFormatNumber) {
            StartFormatNumber startFormatNumber = (StartFormatNumber) ev;
            try {
                String result = startFormatNumber.format(jexlContext, jxpathContext);
                if (result != null) {
                    char[] chars = result.toCharArray();
                    consumer.characters(chars, 0, chars.length);
                }
            } catch (Exception e) {
                throw new JXTException(e.getMessage(), ev.location, e);
            }
        } else if (ev instanceof StartFormatDate) {
            StartFormatDate startFormatDate = (StartFormatDate) ev;
            try {
                String result = startFormatDate.format(jexlContext, jxpathContext);
                if (result != null) {
                    char[] chars = result.toCharArray();
                    consumer.characters(chars, 0, chars.length);
                }
            } catch (Exception e) {
                throw new JXTException(e.getMessage(), ev.location, e);
            }
        } else if (ev instanceof StartPrefixMapping) {
            StartPrefixMapping startPrefixMapping = (StartPrefixMapping) ev;
            namespaces.addDeclaration(startPrefixMapping.prefix, startPrefixMapping.uri);
        } else if (ev instanceof StartComment) {
            StartComment startJXComment = (StartComment) ev;
            // Parse the body of the comment
            NodeList nodeList = toDOMNodeList("comment", startJXComment, jexlContext, macroCall);
            // JXPath doesn't handle NodeList, so convert it to an array
            int len = nodeList.getLength();
            final StringBuffer buf = new StringBuffer();
            Properties omit = XMLUtils.createPropertiesForXML(true);
            for (int i = 0; i < len; i++) {
                try {
                    String str = XMLUtils.serializeNode(nodeList.item(i), omit);
                    buf.append(StringUtils.substringAfter(str, ">")); // cut the XML header
                } catch (Exception e) {
                    throw new JXTException(e.getMessage(), startJXComment.location, e);
                }
            }
            char[] chars = new char[buf.length()];
            buf.getChars(0, chars.length, chars, 0);
            consumer.comment(chars, 0, chars.length);
            ev = startJXComment.endInstruction.next;
            continue;
        } else if (ev instanceof EndCDATA) {
            consumer.endCDATA();
        } else if (ev instanceof EndDTD) {
            consumer.endDTD();
        } else if (ev instanceof EndEntity) {
            consumer.endEntity(((EndEntity) ev).name);
        } else if (ev instanceof StartCDATA) {
            consumer.startCDATA();
        } else if (ev instanceof StartDTD) {
            StartDTD startDTD = (StartDTD) ev;
            consumer.startDTD(startDTD.name, startDTD.publicId, startDTD.systemId);
        } else if (ev instanceof StartEntity) {
            consumer.startEntity(((StartEntity) ev).name);
        } else if (ev instanceof StartOut) {
            StartOut startOut = (StartOut) ev;
            Object val;
            try {
                val = getNode(startOut.compiledExpression, jexlContext, jxpathContext, startOut.lenient);
                if (val instanceof Node) {
                    executeDOM(consumer, jexlContext, jxpathContext, (Node) val);
                } else if (val instanceof NodeList) {
                    NodeList nodeList = (NodeList) val;
                    int len = nodeList.getLength();
                    for (int i = 0; i < len; i++) {
                        Node n = nodeList.item(i);
                        executeDOM(consumer, jexlContext, jxpathContext, n);
                    }
                } else if (val instanceof Node[]) {
                    Node[] nodeList = (Node[]) val;
                    int len = nodeList.length;
                    for (int i = 0; i < len; i++) {
                        Node n = nodeList[i];
                        executeDOM(consumer, jexlContext, jxpathContext, n);
                    }
                } else if (val instanceof XMLizable) {
                    ((XMLizable) val).toSAX(new IncludeXMLConsumer(consumer));
                } else {
                    char[] ch = val == null ? ArrayUtils.EMPTY_CHAR_ARRAY : val.toString().toCharArray();
                    consumer.characters(ch, 0, ch.length);
                }
            } catch (Exception e) {
                throw new JXTException(e.getMessage(), ev.location, e);
            }
        } else if (ev instanceof StartTemplate) {
            // EMPTY
        } else if (ev instanceof StartEval) {
            StartEval startEval = (StartEval) ev;
            JXTExpression expr = startEval.value;
            try {
                Object val = getNode(expr, jexlContext, jxpathContext);
                if (!(val instanceof StartElement)) {
                    throw new Exception("macro invocation required instead of: " + val);
                }
                StartElement call = (StartElement) val;
                execute(consumer, jexlContext, jxpathContext, call, call.next, call.endElement);
            } catch (Exception exc) {
                throw new JXTException(exc.getMessage(), ev.location, exc);
            }
            ev = startEval.endInstruction.next;
            continue;
        } else if (ev instanceof StartEvalBody) {
            StartEvalBody startEval = (StartEvalBody) ev;
            try {
                execute(consumer, jexlContext, jxpathContext, null, macroCall.next, macroCall.endElement);
            } catch (Exception exc) {
                throw new JXTException(exc.getMessage(), ev.location, exc);
            }
            ev = startEval.endInstruction.next;
            continue;
        } else if (ev instanceof StartDefine) {
            StartDefine startDefine = (StartDefine) ev;
            definitions.put(startDefine.qname, startDefine);
            ev = startDefine.endInstruction.next;
            continue;
        } else if (ev instanceof StartImport) {
            StartImport startImport = (StartImport) ev;
            String uri;
            AttributeEvent e = startImport.uri;
            if (e instanceof CopyAttribute) {
                CopyAttribute copy = (CopyAttribute) e;
                uri = copy.value;
            } else {
                StringBuffer buf = new StringBuffer();
                SubstituteAttribute substAttr = (SubstituteAttribute) e;
                Iterator i = substAttr.substitutions.iterator();
                while (i.hasNext()) {
                    Subst subst = (Subst) i.next();
                    if (subst instanceof Literal) {
                        Literal lit = (Literal) subst;
                        buf.append(lit.value);
                    } else if (subst instanceof JXTExpression) {
                        JXTExpression expr = (JXTExpression) subst;
                        Object val;
                        try {
                            val = getValue(expr, jexlContext, jxpathContext);
                        } catch (Exception exc) {
                            throw new JXTException(exc.getMessage(), ev.location, exc);
                        }
                        buf.append(val != null ? val.toString() : "");
                    }
                }
                uri = buf.toString();
            }
            Source input = null;
            StartDocument doc;
            try {
                input = resolver.resolveURI(uri);
                SourceValidity validity = null;
                synchronized (cache) {
                    doc = (StartDocument) cache.get(input.getURI());
                    if (doc != null) {
                        boolean recompile = false;
                        if (doc.compileTime == null) {
                            recompile = true;
                        } else {
                            int valid = doc.compileTime.isValid();
                            if (valid == SourceValidity.UNKNOWN) {
                                validity = input.getValidity();
                                valid = doc.compileTime.isValid(validity);
                            }
                            if (valid != SourceValidity.VALID) {
                                recompile = true;
                            }
                        }
                        if (recompile) {
                            doc = null; // recompile
                        }
                    }
                }
                if (doc == null) {
                    Parser parser = new Parser();
                    // call getValidity before using the stream is faster if the source is a SitemapSource
                    if (validity == null) {
                        validity = input.getValidity();
                    }
                    SourceUtil.parse(this.manager, input, parser);
                    doc = parser.getStartEvent();
                    doc.compileTime = validity;
                    synchronized (cache) {
                        cache.put(input.getURI(), doc);
                    }
                }
            } catch (Exception exc) {
                throw new JXTException(exc.getMessage(), ev.location, exc);
            } finally {
                resolver.release(input);
            }
            JXPathContext selectJXPath = jxpathContext;
            MyJexlContext selectJexl = jexlContext;
            if (startImport.select != null) {
                try {
                    Object obj = getValue(startImport.select, jexlContext, jxpathContext);
                    selectJXPath = jxpathContextFactory.newContext(null, obj);
                    selectJXPath.setNamespaceContextPointer(new NamespacesTablePointer(namespaces));
                    selectJXPath.setVariables(variables);
                    selectJexl = new MyJexlContext(jexlContext);
                    fillContext(obj, selectJexl);
                } catch (Exception exc) {
                    throw new JXTException(exc.getMessage(), ev.location, exc);
                }
            }
            try {
                execute(consumer, selectJexl, selectJXPath, macroCall, doc.next, doc.endDocument);
            } catch (Exception exc) {
                throw new JXTException(
                        "Exception occurred in imported template " + uri + ": " + exc.getMessage(), ev.location,
                        exc);
            }
            ev = startImport.endInstruction.next;
            continue;
        } else if (ev instanceof StartDocument) {
            if (((StartDocument) ev).endDocument != null) {
                // if this isn't a document fragment
                consumer.startDocument();
            }
        } else if (ev instanceof EndDocument) {
            consumer.endDocument();
        } else if (ev instanceof ProcessingInstruction) {
            ProcessingInstruction pi = (ProcessingInstruction) ev;
            consumer.processingInstruction(pi.target, pi.data);
        }
        ev = ev.next;
    }
}

From source file:org.apache.cocoon.template.script.event.TextEvent.java

protected static void characters(ExpressionContext expressionContext, ExecutionContext executionContext,
        TextEvent event, CharHandler handler) throws SAXException {
    Iterator iter = event.getSubstitutions().iterator();
    while (iter.hasNext()) {
        Object subst = iter.next();
        char[] chars;
        if (subst instanceof Literal) {
            chars = ((Literal) subst).getCharArray();
        } else {/* w w w. j av  a 2  s .  com*/
            JXTExpression expr = (JXTExpression) subst;
            try {
                Object val = expr.getValue(expressionContext);
                chars = val != null ? val.toString().toCharArray() : ArrayUtils.EMPTY_CHAR_ARRAY;
            } catch (Exception e) {
                throw new SAXParseException(e.getMessage(), event.getLocation(), e);
            } catch (Error err) {
                throw new SAXParseException(err.getMessage(), event.getLocation(), new ErrorHolder(err));
            }
        }
        handler.characters(chars, 0, chars.length);
    }
}

From source file:org.apache.cocoon.template.script.Invoker.java

public static void executeNode(final XMLConsumer consumer, Object val, boolean stripRoot) throws SAXException {
    if (val instanceof Node) {
        executeDOM(consumer, (Node) val, stripRoot);
    } else if (val instanceof NodeList) {
        NodeList nodeList = (NodeList) val;
        int len = nodeList.getLength();
        for (int i = 0; i < len; i++) {
            Node n = nodeList.item(i);
            //TODO: should this take stripRoot into account?
            executeDOM(consumer, n);//from  ww  w.j a va2s.  co  m
        }
    } else if (val instanceof Node[]) {
        Node[] nodeList = (Node[]) val;
        int len = nodeList.length;
        for (int i = 0; i < len; i++) {
            Node n = nodeList[i];
            //TODO: should this take stripRoot into account?
            executeDOM(consumer, n);
        }
    } else if (val instanceof XMLizable) {
        IncludeXMLConsumer includer = new IncludeXMLConsumer(consumer);
        includer.setIgnoreRootElement(stripRoot);
        ((XMLizable) val).toSAX(includer);
    } else {
        char[] ch = val == null ? ArrayUtils.EMPTY_CHAR_ARRAY : val.toString().toCharArray();
        consumer.characters(ch, 0, ch.length);
    }
}

From source file:org.apache.jackrabbit.server.JahiaBasicCredentialsProvider.java

/**
 * Creates the {@link SimpleCredentials} object for the provided username and password considering the impersonation case.
 * /*w  w  w.  j  av  a 2 s  . c o  m*/
 * @param user
 *            the received username
 * @param password
 *            the user password
 * @return the {@link SimpleCredentials} object for the provided username and password considering the impersonation case
 */
protected Credentials createCredentials(String user, char[] password) {
    SimpleCredentials credentials = null;
    if (user != null && user.contains(IMPERSONATOR)) {
        credentials = new SimpleCredentials(StringUtils.substringBefore(user, IMPERSONATOR),
                ArrayUtils.EMPTY_CHAR_ARRAY);

        credentials.setAttribute(SecurityConstants.IMPERSONATOR_ATTRIBUTE,
                new SimpleCredentials(StringUtils.substringAfter(user, IMPERSONATOR), password));
    } else {
        credentials = new SimpleCredentials(user, password);
    }

    return credentials;
}

From source file:org.marketcetera.util.auth.HolderCharArrayTest.java

private static void clear(HolderCharArray holder) {
    char[] valueCopy = TEST_VALUE.clone();
    holder.setValue(valueCopy);/*from  w  w w . ja va 2 s. com*/
    holder.clear();
    assertNull(holder.getValue());
    assertNull(holder.getValueAsString());
    assertArrayEquals(NUL_VALUE, valueCopy);
    holder.clear();
    assertNull(holder.getValue());
    assertNull(holder.getValueAsString());

    valueCopy = TEST_VALUE.clone();
    holder.setValue(valueCopy);
    holder.setValue(null);
    assertArrayEquals(NUL_VALUE, valueCopy);
    holder.clear();
    assertNull(holder.getValue());
    assertNull(holder.getValueAsString());

    valueCopy = TEST_VALUE.clone();
    holder.setValue(valueCopy);
    holder.setValue(ArrayUtils.EMPTY_CHAR_ARRAY);
    assertArrayEquals(NUL_VALUE, valueCopy);
    holder.clear();
    assertNull(holder.getValue());
    assertNull(holder.getValueAsString());
}

From source file:org.onehippo.forge.hst.pdf.renderer.servlet.ContentCapturingHttpServletResponse.java

public char[] toCharArray() {
    if (charOutputBuffer != null) {
        return charOutputBuffer.toCharArray();
    }//w  ww . ja v  a2  s. co  m

    return ArrayUtils.EMPTY_CHAR_ARRAY;
}