text:
define(function(require, exports, module) {
    main.consumes = [
        "immediate", "debugger", "Evaluator", "callstack", "ui"
    ];
    main.provides = ["immediate.debugnode"];
    return main;

    function main(options, imports, register) {
        var Evaluator = imports.Evaluator;
        var debug = imports.debugger;
        var immediate = imports.immediate;
        var callstack = imports.callstack;
        var ui = imports.ui;

        var escapeHTML = require("ace/lib/lang").escapeHTML;

        /***** Initialization *****/

        var plugin = new Evaluator("Ajax.org", main.consumes, {
            caption: "Debugger",
            id: "debugger",
            mode: "ace/mode/javascript", // @todo make this variable: repl.session.setMode
            message: "Welcome to the debugger inspector. You can inspect "
                + "any process that the debugger is attached to. Code \nwill be "
                + "executed in the global context unless on "
                + "a breakpoint, then code is executed in the current frame."
        });
        // var emit = plugin.getEmitter();

        var dbg, log, lastCell;

        var loaded;
        function load() {
            if (loaded) return;
            loaded = true;

            // Set and clear the dbg variable
            debug.on("attach", function(e) {
                dbg = e.implementation;
                if (dbg.attachLog)
                    initLog(dbg.attachLog());

                immediate.defaultEvaluator = "debugger";
            });
            debug.on("detach", function(e) {
                dbg = null;
                immediate.defaultEvaluator = null;
            });
            debug.on("stateChange", function(e) {
                plugin[e.action]();
            });
        }

        /***** Log *****/

        function writeLog() {
            var cell;
            var dist = 1;
            var type = arguments[arguments.length - dist];
            if (type && type.addWidget) {
                dist++;
                cell = type;
                type = arguments[arguments.length - dist];
            }
            if (!cell)
                cell = lastCell;
            if (!cell.html)
                createWidget(cell);

            var html = cell.html.appendChild(document.createElement("div"));
            html.className = type;

            for (var i = 0; i < arguments.length - dist; i++) {
                renderType(arguments[i], html, type != "return");
            }
            insert(html, "
");

            html.updateWidget = updateWidget.bind(cell);
            html.updateWidget();
            scrollIntoView(cell);
        }

        function updateWidget() {
            this.session.repl.onWidgetChanged(this);
        }

        function scrollIntoView(cell) {
            if (!cell.session.repl.editor)
                return;

            // TODO add a better way to scroll ace cursor into view when rendered
            var renderer = cell.session.repl.editor.renderer;
            setTimeout(function() {
                renderer.scrollCursorIntoView();
            });
        }

        function initLog(proxy) {
            log = proxy;
            log.on("log", function(e) {
                var args = Array.prototype.slice.apply(arguments);
                args.push(e.type);
                writeLog.apply(log, args);
            }, plugin);
        }

        function createWidget(cell) {
            cell.html = document.createElement("div");
            cell.addWidget({ el: cell.html, coverLine: true, fixedWidth: true });
        }

        /***** Analyzer *****/

        function insert(div, markup, name) {
            if (name !== undefined)
                insert(div, "" + escapeHTML(name) + ": ");

            markup = markup.replace(/([a-z]\w{1,4}:\/\/[\w:_\-\?&\/\.\#]*)/gi, "$1");
            div.insertAdjacentHTML("beforeend", markup);

            if (div.lastChild && div.lastChild.nodeType == 1) {
                var nodes = div.lastChild.querySelectorAll("a");
                for (var i = 0; i < nodes.length; i++) {
                    nodes[i].addEventListener("click", function(e) {
                        //@todo
                        alert(this.firstChild.nodeValue);
                        e.stopPropagation();
                    });
                }
            }
        }

        function insertTree(div, caption, object, drawChildren) {
            // caption can be a string or an html element
            var treeitem = div.appendChild(document.createElement("span"));
            var arrow = treeitem.appendChild(document.createElement("span"));
            treeitem.className = "treeitem";
            arrow.className = "arrow";
            treeitem.appendChild(caption);

            var container;
            treeitem.addEventListener("click", function(e) {
                if (container && ui.isChildOf(container, e.target, true))
                    return;

                e.stopPropagation();

                if (!container) {
                    container = treeitem.appendChild(document.createElement("div"));
                    container.className = "treecontainer";
                    container.style.display = "none";
                    drawChildren(object, container, function() {
                        findWidgetAndUpdate(target);
                    });
                }

                var collapsed = container.style.display == "none";
                arrow.className = "arrow " + (collapsed ? "expanded" : "");
                container.style.display = collapsed ? "block" : "none";

                // hack!
                var target = e.currentTarget;
                findWidgetAndUpdate(target);
            });
        }

        function findWidgetAndUpdate(target) {
            while (target) {
                if (target.updateWidget) {
                    target.updateWidget();
                    break;
                }
                target = target.parentNode;
            }
        }

        function parseChildren(object, html, callback) {
            if (object.value == "[Array]") {
                if (object.length < 101) {
                    object.forEach(function(item, i) {
                        renderType(item, html, 2, false, i);
                        insert(html, "
");
                    });
                }
                else {

                }
            }
            else if (object.$arrayWalker) {

            }
            else if (object instanceof Error) {
                var stack = (object.stack || "").split("\n");
                stack.shift();
                stack = stack.join("
");
                insert(html, "
" + stack + "
");
            }
            // else if (object instanceof win.Element) {
            //     if (!html.parentNode.textContent.match(/HTML\w*Element/)) {
            //         var children = object.childNodes;
            //         for (var i = 0; i < children.length; i++) {
            //             renderType(children[i], html, false, 2);
            //             insert(html, "
");
            //         }
            //         insert(html, "</" + object.tagName.toLowerCase() + ">");
            //         return;
            //     }
            // }

            if (!object.properties && dbg) {
                dbg.getProperties(object, function(err, properties) {
                    // if (properties && properties.length)
                    parseChildren(object, html, callback);
                });
                return;
            }

            (object.properties || []).forEach(function(prop) {
                renderType(prop, html, 2, 2, prop.name);
                insert(html, "
");
            });

            callback();
        }

        function getOwnProperties(object) {
            var result = [];
            (object.properties || []).forEach(function(o) {
                if (typeof o.name != "number")
                    result.push(o);
            });
        }

        function renderType(object, html, log, short, name) {
            var type = object.type;
            var value = object.value;
            var caption;

            if (object.name && typeof object.name == "string"
              && object.name.indexOf("function") === 0)
                type = "function";

            if (type == "undefined" || type == "null") {
                insert(html, "" + type + "", name);
            }
            else if (type == "string") {
                if (!log || log == 2) {
                    value = JSON.parse(value)
                        .replace(/</g, "<")
                        .replace(/\t/g, "    ")
                        .replace(/ /g, " ")
                        .replace(/\n/g, "
");
                    var str = "\"" + value + "\"";
                    if (name && object.length > 100) {
                        var event = "this.style.display = \"none\";\
                            this.nextSibling.style.display = \"inline\";\
                            event.stopPropagation()";
                        str = "(...)" + str
                            + "";
                    }
                    insert(html, str, name);
                }
                else {
                    insert(html, object, name);
                }
            }
            else if (type == "number" || type == "int" || type == "float") {
                insert(html, "" + value + "", name);
            }
            else if (type == "function") {
                insert(html, ""
                    + (object.name + "")
                        .replace(/ /g, " ")
                        .replace(/\n/g, "
")
                    + "", name);
            }
            else if (type == "boolean" || type == "bool") {
                insert(html, "" + value + "", name);
            }
            else if (!log && type == "regexp") {
                insert(html, ""
                    + object.value + "", name);
            }
            else if (value == "[Array]") {
                if (short) {
                    insert(html, "Array [" + object.name + "]", name);
                    return;
                }
                else {
                    // Detect Sparse Array via every
                    if (false) {

                    }

                    var j = 0;
                    if (log) {
                        caption = document.createElement("span");
                        insert(caption, "", name);
                        var preview = caption.appendChild(document.createElement("span"));
                        preview.className = "preview";

                        insert(preview, "[", name);

                        (object.properties || []).every(function(item, i) {
                            if (typeof item.name != "number") {
                                j++;
                                return true;
                            }

                            renderType(item, preview, false, true);
                            if (i < object.properties.length - 2 - j)
                                insert(preview, ", ");

                            return (i - j) < 100;
                        });

                        var props = getOwnProperties(object);
                        var count = Math.min(Math.min(props.length, 5),
                            Math.max(0, 100 - object.length));
                        for (var i = 0; i < count; i++) {
                            insert(preview, (i !== 0 ? ", " : "") + escapeHTML(props[i]) + ": ");
                            renderType(props[i], preview, false, 2);
                        }
                        if (props.length > count)
                            insert(preview, "…");

                        insert(preview, "]");
                    }
                    else if ((object.properties || "").length > 100) {
                        caption = document.createElement("span");
                        insert(caption, "Array [" + object.properties.length + "]", name);
                    }
                    else {
                        insert(html, "[", name);
                        (object.properties || []).every(function(item, i) {
                            if (typeof item.name != "number") {
                                j++;
                                return true;
                            }

                            renderType(item, html, false, 2);
                            if (i < object.properties.length - 1)
                                insert(html, ", ");

                            return true;
                        });
                        insert(html, "]");
                        return;
                    }
                }

                insertTree(html, caption, object, parseChildren);
            }
            // // HTML/XML Element
            // else if (object instanceof win.Node && log === false) {
            //     // Text Node
            //     if (object.nodeType == 3) {
            //         insert(html, ""
            //             + object.nodeValue.replace(/</g, "<") + "");
            //     }
            //     // CDATA Section
            //     else if (object.nodeType == 4) {
            //         insert(html, "<![CDATA["
            //             + object.nodeValue.replace(/</g, "<")
            //             + "]]>");
            //     }
            //     // Comment
            //     else if (object.nodeType == 11) {
            //         insert(html, "<!--"
            //             + object.nodeValue.replace(/</g, "<")
            //             + "-->");
            //     }
            //     // Element Node
            //     else if (object.nodeType == 1) {
            //         var node = ["<" + object.tagName.toLowerCase()];
            //         for (var attr, i = 0, l = object.attributes.length; i < l; i++) {
            //             attr = object.attributes.item(i);
            //             node.push(attr.nodeName + "=\"" + attr.nodeValue.replace(/"/g, """) + "\"");
            //         }
            //         node = node.join(" ");
            //         node += object.childNodes.length ? ">" : "></"
            //             + object.tagName.toLowerCase() + ">";

            //         caption = document.createElement("span");
            //         insert(caption, node, name);

            //         if (object.childNodes.length)
            //             insertTree(html, caption, object, parseChildren);
            //         else {
            //             caption.className = "emptynode";
            //             html.appendChild(caption);
            //         }
            //     }
            // }
            // Object
            else {
                var heading;
                if (object["$$error"]) {
                    object = object["$$error"];
                    heading = (object.stack || "").split(":")[0];
                    heading = ""
                        + object.message
                        + "";

                    caption = document.createElement("span");
                    insert(caption, heading, name);
                    insertTree(html, caption, object, parseChildren);
                }
                else {
                    if (type === "object" || object.children || (object.properties && object.properties.length > 0)) {
                        // An object, or a value of unknown type which has properties, so should be displayed as an object.

                        heading = (object.value || "[(anonymous function)]")
                            .replace(/^\[(.*)\]$/, "$1");
                        if (short === true)
                            return insert(html, heading, name);

                        caption = document.createElement("span");
                        insert(caption, heading, name);
                        preview = caption.appendChild(document.createElement("span"));
                        preview.className = "preview";

                        if (short !== 2) {
                            insert(preview, " {");

                            props = object.properties || [];
                            count = 0;
                            for (var i = 0; count < 5 && i < props.length; i++) {
                                var propName = props[i].name;
                                // for buffers propName is a number
                                if (typeof propName == "string" && propName.indexOf("function") === 0)
                                    continue;

                                insert(preview, (i !== 0 ? ", " : ""));
                                insert(preview, "", propName);
                                renderType(props[i], preview, 2, true);
                                count++;
                            }
                            if (props.length > count)
                                insert(preview, "…");

                            insert(preview, "}");
                        }
                        else {
                            insert(preview, "");
                        }

                        insertTree(html, caption, object, parseChildren);
                    }
                    else {
                        // A value of unknown type which does not have any properties - assume it is a language-specific
                        // primitive type.
                        insert(html, escapeHTML(value), name);
                    }
                }
            }
        }

        function canEvaluate(str) {
            return str.trim() ? true : false;
        }

        function evaluate(expression, cell, cb) {
            lastCell = cell;

            if (cell.html)
                cell.html.textContent = "";

            evaluateHeadless(expression, function(result) {
                if (cell.setError && result["$$error"])
                    return cell.setError(result["$$error"]);

                writeLog(result, "return", cell);
                cell.setWaiting(false);
            });

            //cb("Done");
        }

        function evaluateHeadless(expression, callback) {
            if (!callback) return;

            if (!dbg || !dbg.features.executeCode) {
                var err = new Error(
                    dbg && !dbg.features.executeCode
                        ? "Code execution is not supported by this debugger"
                        : "Debug Session is not running");
                return callback({ "$$error": err, type: err });
            }

            dbg.evaluate(expression, callstack.activeFrame,
              !callstack.activeFrame, false, function(err, variable) {
                if (err)
                    return callback({ "$$error": err, type: err });

                if (variable.type == "function") {
                    dbg.serializeVariable(variable, function(value) {
                        variable.name = value;
                        callback(variable);
                    });
                    return;
                }

                callback(variable);
            });
        }

        function addVariables(list, node) {
            node.variables.forEach(function(n) {
                list.push(n.name);
            });
        }

        function getAllProperties(context, callback) {
            // Return all properties of the current context
            if (context == -1) {
                var frame = callstack.activeFrame;
                var vars = [];
                var count = 0;
                if (frame) {
                    addVariables(vars, frame);

                    frame.scopes.forEach(function(scope) {
                        if (scope.status == "loaded")
                            addVariables(vars, scope);
                        else {
                            count++;
                            dbg.getScope(frame, scope, function(err) {
                                if (!err)
                                    addVariables(vars, scope);

                                if (--count === 0)
                                    callback(null, vars);
                            });
                        }
                    });

                    return;
                }
                else {
                    context = "global";
                }
            }

            console.warn("DEBUG: (properties)", context);
            evaluateHeadless(context, function(variable) {
                console.warn("DEBUG: (properties-received)", variable);

                if (variable["$$error"])
                    return callback(variable["$$error"]);
                if (!variable.properties)
                    return callback(null, []);

                var results = variable.properties.map(function(m) {
                    return m.name;
                });

                function check(variable) {
                    if (variable.prototype) {
                        if (!dbg) return callback(new Error("disconnected"));

                        console.warn("DEBUG: (properties-properties)", variable);
                        dbg.getProperties(variable.prototype, function(err, props) {
                        console.warn("DEBUG: (properties-properties-received)", variable, err);
                            if (err) return callback(err);

                            props.forEach(function(prop) {
                                if (results.indexOf(prop.name) === -1)
                                    results.push(prop.name);
                            });

                            check(variable.prototype);
                        });
                    }
                    else {
                        callback(null, results);
                    }
                }
                check(variable);
            });
        }

        /***** Lifecycle *****/

        plugin.on("load", function() {
            load();
        });
        plugin.on("canEvaluate", function(e) {
            return canEvaluate(e.expression);
        });
        plugin.on("evaluate", function(e) {
            return evaluate(e.expression, e.cell, e.callback);
        });
        plugin.on("enable", function() {

        });
        plugin.on("disable", function() {

        });
        plugin.on("unload", function() {
            loaded = false;
        });

        /***** Register and define API *****/

        /**
         *
         **/
        plugin.freezePublicAPI({
            /** @ignore */
            evaluateHeadless: evaluateHeadless,

            /** @ignore */
            getAllProperties: getAllProperties
        });

        register(null, {
            "immediate.debugnode": plugin
        });
    }
});


text:
#include <aws/macie2/model/GetUsageStatisticsResult.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/AmazonWebServiceResult.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/UnreferencedParam.h>

#include <utility>

using namespace Aws::Macie2::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
using namespace Aws;

GetUsageStatisticsResult::GetUsageStatisticsResult()
{
}

GetUsageStatisticsResult::GetUsageStatisticsResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
  *this = result;
}

GetUsageStatisticsResult& GetUsageStatisticsResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
  JsonView jsonValue = result.GetPayload().View();
  if(jsonValue.ValueExists("nextToken"))
  {
    m_nextToken = jsonValue.GetString("nextToken");

  }

  if(jsonValue.ValueExists("records"))
  {
    Array<JsonView> recordsJsonList = jsonValue.GetArray("records");
    for(unsigned recordsIndex = 0; recordsIndex < recordsJsonList.GetLength(); ++recordsIndex)
    {
      m_records.push_back(recordsJsonList[recordsIndex].AsObject());
    }
  }

  return *this;
}

redpajama_set_name: RedPajamaGithub


text:
class GURL;

namespace net {

class CanonicalCookie;

// The publicly relevant reasons a cookie might be changed.
enum class CookieChangeCause {
  // The cookie was inserted.
  INSERTED,
  // The cookie was changed directly by a consumer's action.
  EXPLICIT,
  // The cookie was deleted, but no more details are known.
  UNKNOWN_DELETION,
  // The cookie was automatically removed due to an insert operation that
  // overwrote it.
  OVERWRITE,
  // The cookie was automatically removed as it expired.
  EXPIRED,
  // The cookie was automatically evicted during garbage collection.
  EVICTED,
  // The cookie was overwritten with an already-expired expiration date.
  EXPIRED_OVERWRITE
};

struct NET_EXPORT CookieChangeInfo {
  CookieChangeInfo();
  CookieChangeInfo(const CanonicalCookie& cookie,
                   CookieAccessResult access_result,
                   CookieChangeCause cause);
  ~CookieChangeInfo();

  // The cookie that changed.
  CanonicalCookie cookie;

  // The access result of the cookie at the time of the change.
  CookieAccessResult access_result;

  // The reason for the change.
  CookieChangeCause cause = CookieChangeCause::EXPLICIT;
};

// Return a string corresponding to the change cause.  For debugging/logging.
NET_EXPORT const char* CookieChangeCauseToString(CookieChangeCause cause);

// Returns whether |cause| is one that could be a reason for deleting a cookie.
// This function assumes that ChangeCause::EXPLICIT is a reason for deletion.
NET_EXPORT bool CookieChangeCauseIsDeletion(CookieChangeCause cause);

// Called when a cookie is changed in a CookieStore.
//
// Receives the CanonicalCookie which was added to or removed from the store,
// the CookieAccessSemantics of the cookie at the time of the change event,
// and a CookieStore::ChangeCause indicating if the cookie was added, updated,
// or removed.
//
// Note that the callback is called twice when a cookie is updated: the first
// call communicates the removal of the existing cookie, and the second call
// expresses the addition of the new cookie.
//
// The callback must not synchronously modify any cookie in the CookieStore
// whose change it is observing.
using CookieChangeCallback =
    base::RepeatingCallback<void(const CookieChangeInfo&)>;

// Records a listener's interest in CookieStore changes.
//
// Each call to CookieChangeDispatcher::Add*() is a listener expressing an
// interest in observing CookieStore changes. Each call creates a
// CookieChangeSubscription instance whose ownership is passed to the listener.
//
// When the listener's interest disappears (usually at destruction time), the
// listener must communicate this by destroying the CookieChangeSubscription
// instance. The callback passed to the Add*() method will not to be called
// after the returned handle is destroyed.
//
// CookieChangeSubscription instances do not keep the observed CookieStores
// alive.
//
// Instances of this class are not thread-safe, and must be destroyed on the
// same thread that they were obtained on.
class CookieChangeSubscription {
 public:
  CookieChangeSubscription() = default;

  CookieChangeSubscription(const CookieChangeSubscription&) = delete;
  CookieChangeSubscription& operator=(const CookieChangeSubscription&) = delete;

  virtual ~CookieChangeSubscription() = default;
};

// Exposes changes to a CookieStore's contents.
//
// A component that wishes to react to changes in a CookieStore (the listener)
// must register its interest (subscribe) by calling one of the Add*() methods
// exposed by this interface.
//
// CookieChangeDispatch instances are intended to be embedded in CookieStore
// implementations, so they are not intended to be created as standalone objects
// on the heap.
//
// At the time of this writing (Q1 2018), using this interface has non-trivial
// performance implications on all implementations. This issue should be fixed
// by the end of 2018, at which point this warning should go away. Until then,
// please understand and reason about the performance impact of your change if
// you're adding uses of this to the codebase.
class CookieChangeDispatcher {
 public:
  CookieChangeDispatcher() = default;

  CookieChangeDispatcher(const CookieChangeDispatcher&) = delete;
  CookieChangeDispatcher& operator=(const CookieChangeDispatcher&) = delete;

  virtual ~CookieChangeDispatcher() = default;

  // Observe changes to all cookies named `name` that would be sent in a
  // request to `url`.
  //
  // If `cookie_partition_key` is nullopt, then we ignore all change events for
  // partitioned cookies. Otherwise it only subscribes to change events for
  // partitioned cookies with the same provided key.
  // Unpartitioned cookies are not affected by the `cookie_partition_key`
  // parameter.
  [[nodiscard]] virtual std::unique_ptr<CookieChangeSubscription>
  AddCallbackForCookie(
      const GURL& url,
      const std::string& name,
      const absl::optional<CookiePartitionKey>& cookie_partition_key,
      CookieChangeCallback callback) = 0;

  // Observe changes to the cookies that would be sent for a request to `url`.
  //
  // If `cookie_partition_key` is nullopt, then we ignore all change events for
  // partitioned cookies. Otherwise it only subscribes to change events for
  // partitioned cookies with the same provided key.
  // Unpartitioned cookies are not affected by the `cookie_partition_key`
  // parameter.
  [[nodiscard]] virtual std::unique_ptr<CookieChangeSubscription>
  AddCallbackForUrl(
      const GURL& url,
      const absl::optional<CookiePartitionKey>& cookie_partition_key,
      CookieChangeCallback callback) = 0;

  // Observe all the CookieStore's changes.
  //
  // The callback will not observe a few bookkeeping changes.
  // See kChangeCauseMapping in cookie_monster.cc for details.
  // TODO(crbug.com/1225444): Add support for Partitioned cookies.
  [[nodiscard]] virtual std::unique_ptr<CookieChangeSubscription>
  AddCallbackForAllChanges(CookieChangeCallback callback) = 0;
};

}  // namespace net

#endif  // NET_COOKIES_COOKIE_CHANGE_DISPATCHER_H_


text:
package com.trigonic.utils.test.junit;

import static org.junit.Assert.assertTrue;

import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(Parameterized.class)
public class ArrayWithLabelMakerFactoryTest {
    @Parameters
    public static Object[][] getParameters() {
        return new Object[][] {
                { "a", 1 }, {"b", 2}, {"c", 3}
        };
    }

    @LabelMakerFactory
    public static LabelMaker getLabelMaker() {
        return new FirstParameterLabel();
    }

    private String string;
    private int number;

    public ArrayWithLabelMakerFactoryTest(String string, int number) {
        this.string = string;
        this.number = number;
    }

    @Test
    public void test() {
        assertTrue(string.matches("[a-c]"));
        assertTrue(number >= 1 && number <= 3);
    }
}


text:
declare namespace javax {
  namespace xml {
    namespace stream {
      namespace util {

        interface XMLEventConsumer$$lambda {
          (arg0: javax.xml.stream.events.XMLEvent): void
        }

        interface XMLEventConsumer {
          add(arg0: javax.xml.stream.events.XMLEvent): void
        }

      }
    }
  }
}


text:
layout: page
title: Bryan 50th Anniversary
date: 2016-05-24
author: Jeremy Dickson
tags: weekly links, java
status: published
summary: Donec dictum, ante a maximus imperdiet, risus.
banner: images/banner/office-01.jpg
booking:
  startDate: 07/23/2016
  endDate: 07/24/2016
  ctyhocn: MHTEXHX
  groupCode: B5A
published: true
---
Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec libero justo, tempus ut gravida ut, fringilla at metus. Nunc nec pretium lectus. In hac habitasse platea dictumst. In elementum sit amet dui eu congue. Nullam elementum risus et velit iaculis, vitae consectetur turpis elementum. Suspendisse potenti. Fusce vitae sem diam. Sed iaculis metus ut enim pharetra sodales. Aenean ac libero lorem.

* Morbi ac elit lacinia, ornare sem a, tincidunt neque
* Nunc eu tortor cursus, maximus lacus sed, convallis turpis
* Nullam vitae sapien ullamcorper, feugiat odio quis, congue arcu
* Nulla eu diam vel diam sollicitudin rhoncus.

Donec sit amet sollicitudin neque. In nec ante commodo, iaculis purus nec, placerat mauris. Nulla euismod tellus id est molestie pellentesque. Maecenas id enim vel diam hendrerit convallis. Nunc ac lacus a quam luctus laoreet. Nam volutpat nisl justo, vitae gravida lacus ultrices quis. Proin et eros lacinia, vestibulum libero sed, fermentum metus. Nulla placerat massa non dui hendrerit, ut ullamcorper lectus tristique. Sed lorem risus, commodo sed nunc id, gravida suscipit diam. Curabitur quis tristique massa. Mauris ultricies libero sed tempus imperdiet. Donec at erat blandit, efficitur est vitae, egestas erat.


text:
package org.apache.slide.common;

import org.apache.slide.util.Messages;

/**
 * Invalid Namespace configuration.
 *
 * @version $Revision: 1.2 $
 */
public class InvalidNamespaceConfigurationException extends SlideException {

    // ------------------------------------------------------------ Constructor

    /**
     * Constructor.
     *
     * @param namespace Namespace whose configuration is invalid
     * @param cause Cause
     */
    public InvalidNamespaceConfigurationException(Namespace namespace,
                                                  String cause) {
        super(Messages.format(InvalidNamespaceConfigurationException
                              .class.getName(), namespace, cause));
    }

}