public CommandWrapper(CommandDelegate del)
        {
            if (del == null) {
                throw new ArgumentNullException ("del");
            }

            this.d = del;
        }

 public Command(CommandDelegate cmd, params string[] names)
 {
     if (names == null || names.Length < 1)
         throw new NotSupportedException();
     permission = null;
     Names = new List<string>(names);
     command = cmd;
 }

 public bool Register(string Cmd, CommandDelegate Func)
 {
     if (!Cmds.ContainsKey(Cmd))
         Cmds.Add(Cmd, Func);
     else
         return false;
     return true;
 }

 /// <summary>
 /// Add a command to be executed in parallel.
 /// </summary>
 /// <param name="command"> 
 /// The command to execute. Should be non-null.
 /// </param>
 /// <exception cref="System.ArgumentNullException"></exception>
 public void Add(CommandDelegate command)
 {
     if (command == null) {
     throw new System.ArgumentNullException("command");
     }
     CommandQueue queue = new CommandQueue();
     queue.Enqueue(command);
     _queues.AddLast(queue);
 }

        public void SchumixRegisterHandler(string code, CommandDelegate method, CommandPermission permission = CommandPermission.Normal)
        {
            if(sIgnoreCommand.IsIgnore(code))
               return;

            if(CommandMethodMap.ContainsKey(code.ToLower()))
                CommandMethodMap[code.ToLower()].Method += method;
            else
                CommandMethodMap.Add(code.ToLower(), new CommandMethod(method, permission));
        }

 /// <summary>
 ///   Add a command to those which can be invoked from the console.
 /// </summary>
 /// <param name = "command">The string that will make the command execute</param>
 /// <param name = "commandHelp">The message that will show the user how to use the command</param>
 /// <param name = "info">Any information about how the command works or what it does</param>
 /// <param name = "fn"></param>
 public void AddCommand(string command, string commandHelp, string infomessage, CommandDelegate fn)
 {
     CommandInfo info = new CommandInfo{
         command = command,
         commandHelp = commandHelp,
         info = infomessage,
         fn = new List<CommandDelegate> {fn}
     };
     tree.AddCommand(info);
 }

 public static void RegisterCommandHandler(string command, CommandDelegate handler)
 {
     try
     {
         handlers.Add(command, handler);
     }
     catch (ArgumentException)
     {
         Debug.Log("An element with Key = " + command + " already exists.");
     }
 }

 /// <summary>
 ///     Add a command to those which can be invoked from the console.
 /// </summary>
 /// <param name="command">The string that will make the command execute</param>
 /// <param name="commandHelp">The message that will show the user how to use the command</param>
 /// <param name="infomessage">Any information about how the command works or what it does</param>
 /// <param name="fn"></param>
 /// <param name="requiresAScene">Whether this command requires a scene to be fired</param>
 /// <param name="fireOnceForAllScenes">Whether this command will only be executed once if there is no current scene</param>
 public void AddCommand (string command, string commandHelp, string infomessage, CommandDelegate fn, bool requiresAScene, bool fireOnceForAllScenes)
 {
     CommandInfo info = new CommandInfo {
         command = command,
         commandHelp = commandHelp,
         info = infomessage,
         fireOnceForAllScenes = fireOnceForAllScenes,
         requiresAScene = requiresAScene,
         fn = new List<CommandDelegate> { fn }
     };
     tree.AddCommand (info);
 }

        public Command(CommandDelegate cmd, params string[] names)
        {
            if (cmd == null)
                throw new ArgumentNullException("cmd");
            if (names == null || names.Length < 1)
                throw new ArgumentException("names");

            AllowServer = true;
            CommandDelegate = cmd;
            DoLog = true;
            HelpText = "No help available.";
            Names = new List<string>(names);
            Permissions = new List<string>();
        }

        /// <summary>
        /// Creates instance of EJDB. 
        /// </summary>
        /// <param name="library"></param>
        public Database(Library library)
        {
            var libraryHandle = library.LibraryHandle;
            DatabaseHandle = new DatabaseHandle(libraryHandle);

            Library = library;

            _openDatabase = libraryHandle.GetUnmanagedDelegate<OpenDatabaseDelegate>();
            _closeDatabase = libraryHandle.GetUnmanagedDelegate<CloseDatabaseDelegate>();
            _isOpen = libraryHandle.GetUnmanagedDelegate<IsOpenDelegate>();

            _getErrorCode = libraryHandle.GetUnmanagedDelegate<GetErrorCodeDelegate>();
            _getMetadata = libraryHandle.GetUnmanagedDelegate<GetMetaDelegate>();

            _command = libraryHandle.GetUnmanagedDelegate<CommandDelegate>();
            _sync = libraryHandle.GetUnmanagedDelegate<SyncDelegate>();
        }

        public ProxyFrame(string[] args)
        {
            bool externalPlugin = false;
            this.args = args;

            ProxyConfig proxyConfig = new ProxyConfig("SLProxy", "Austin Jennings / Andrew Ortman", args);
            proxy = new Proxy(proxyConfig);

            // add delegates for login
            proxy.SetLoginRequestDelegate(new XmlRpcRequestDelegate(LoginRequest));
            proxy.SetLoginResponseDelegate(new XmlRpcResponseDelegate(LoginResponse));

            // add a delegate for outgoing chat
            proxy.AddDelegate(PacketType.ChatFromViewer, Direction.Outgoing, new PacketDelegate(ChatFromViewerOut));

            //  handle command line arguments
            foreach (string arg in args)
                if (arg == "--log-login")
                    logLogin = true;
                else if (arg.Substring(0, 2) == "--")
                {
                    int ipos = arg.IndexOf("=");
                    if (ipos != -1)
                    {
                        string sw = arg.Substring(0, ipos);
                        string val = arg.Substring(ipos + 1);
                        Console.WriteLine("arg '" + sw + "' val '" + val + "'");
                        if (sw == "--load")
                        {
                            externalPlugin = true;
                            LoadPlugin(val);
                        }
                    }
                }

            commandDelegates["/load"] = new CommandDelegate(CmdLoad);

            if (!externalPlugin)
            {
                ProxyPlugin analyst = new Analyst(this);
                analyst.Init();
            }
        }

 /// <summary>
 /// A Condition command allows branching behaviour. After a condition evaluates to <c>true</c>
 /// then onTrue will be evaluated until it finishes. Otherise onFalse will be evaluated, (if it 
 /// isn't null). When nested in a Repeat command, conditions will be re-evaluated once for every
 /// repeat.
 /// </summary>
 /// <param name="condition"> 
 /// The condition to evaluate. Must be non-null.
 /// </param>
 /// <param name="onTrue"> 
 /// The command to execute if condition evaluates to true. Must be non-null.
 /// </param>
 /// <param name="onFalse"> 
 /// The command to execute if condition evaluates to false.
 /// </param>
 /// <exception cref="System.ArgumentNullException"></exception>
 public static CommandDelegate Condition(CommandCondition condition, CommandDelegate onTrue, CommandDelegate onFalse = null)
 {
     CheckArgumentNonNull(condition, "condition");
     CheckArgumentNonNull(onTrue, "onTrue");
     CommandDelegate result = onFalse;
     return Sequence(
     Commands.Do( () => {
         result = onFalse;
         if (condition()) {
             result = onTrue;
         }
     }),
     (ref double deltaTime) => {
         if (result != null) {
             return result(ref deltaTime);
         }
         return true;
     }
     );
 }

 public Command(string permissionneeded, CommandDelegate cmd, params string[] names)
     : this(cmd, names)
 {
     Permission = permissionneeded;
 }

 internal InternalCommand( CommandDelegate Command, string Line )
 {
     command = Command;
     line = Line;
 }

        public void FromXml(XmlElement root, CommandDelegate fn)
        {
            CommandInfo help = (CommandInfo)((Dictionary<string, object>)tree["help"])[String.Empty];
            ((Dictionary<string, object>)tree["help"]).Remove(string.Empty);
            if (((Dictionary<string, object>)tree["help"]).Count == 0)
                tree.Remove("help");

            CommandInfo quit = (CommandInfo)((Dictionary<string, object>)tree["quit"])[String.Empty];
            ((Dictionary<string, object>)tree["quit"]).Remove(string.Empty);
            if (((Dictionary<string, object>)tree["quit"]).Count == 0)
                tree.Remove("quit");

            tree.Clear();

            ReadTreeLevel(tree, root, fn);

            if (!tree.ContainsKey("help"))
                tree["help"] = (object) new Dictionary<string, object>();
            ((Dictionary<string, object>)tree["help"])[String.Empty] = help;

            if (!tree.ContainsKey("quit"))
                tree["quit"] = (object) new Dictionary<string, object>();
            ((Dictionary<string, object>)tree["quit"])[String.Empty] = quit;
        }

        private void ReadTreeLevel(Dictionary<string, object> level, XmlNode node, CommandDelegate fn)
        {
            Dictionary<string, object> next;
            string name;

            XmlNodeList nodeL = node.ChildNodes;
            XmlNodeList cmdL;
            CommandInfo c;

            foreach (XmlNode part in nodeL)
            {
                switch (part.Name)
                {
                case "Level":
                    name = ((XmlElement)part).GetAttribute("Name");
                    next = new Dictionary<string, object>();
                    level[name] = next;
                    ReadTreeLevel(next, part, fn);
                    break;
                case "Command":
                    cmdL = part.ChildNodes;
                    c = new CommandInfo();
                    foreach (XmlNode cmdPart in cmdL)
                    {
                        switch (cmdPart.Name)
                        {
                        case "Module":
                            c.module = cmdPart.InnerText;
                            break;
                        case "Shared":
                            c.shared = Convert.ToBoolean(cmdPart.InnerText);
                            break;
                        case "HelpText":
                            c.help_text = cmdPart.InnerText;
                            break;
                        case "LongHelp":
                            c.long_help = cmdPart.InnerText;
                            break;
                        case "Description":
                            c.descriptive_help = cmdPart.InnerText;
                            break;
                        }
                    }
                    c.fn = new List<CommandDelegate>();
                    c.fn.Add(fn);
                    level[String.Empty] = c;
                    break;
                }
            }
        }

 public void AddCommand(string module, bool shared, string command, string help, string longhelp, string descriptivehelp, CommandDelegate fn) {}

        /// <summary>
        /// Add a command to those which can be invoked from the console.
        /// </summary>
        /// <param name="module"></param>
        /// <param name="command"></param>
        /// <param name="help"></param>
        /// <param name="longhelp"></param>
        /// <param name="descriptivehelp"></param>
        /// <param name="fn"></param>
        public void AddCommand(string module, bool shared, string command,
                string help, string longhelp, string descriptivehelp,
                CommandDelegate fn)
        {
            string[] parts = Parser.Parse(command);

            Dictionary<string, Object> current = tree;
            
            foreach (string part in parts)
            {
                if (current.ContainsKey(part))
                {
                    if (current[part] is Dictionary<string, Object>)
                        current = (Dictionary<string, Object>)current[part];
                    else
                        return;
                }
                else
                {
                    current[part] = new Dictionary<string, Object>();
                    current = (Dictionary<string, Object>)current[part];
                }
            }

            CommandInfo info;

            if (current.ContainsKey(String.Empty))
            {
                info = (CommandInfo)current[String.Empty];
                if (!info.shared && !info.fn.Contains(fn))
                    info.fn.Add(fn);

                return;
            }
            
            info = new CommandInfo();
            info.module = module;
            info.shared = shared;
            info.help_text = help;
            info.long_help = longhelp;
            info.descriptive_help = descriptivehelp;
            info.fn = new List<CommandDelegate>();
            info.fn.Add(fn);
            current[String.Empty] = info;

            // Now add command to modules dictionary
            lock (m_modulesCommands)
            {
                List<CommandInfo> commands;
                if (m_modulesCommands.ContainsKey(module))
                {
                    commands = m_modulesCommands[module];
                }
                else
                {
                    commands = new List<CommandInfo>();
                    m_modulesCommands[module] = commands;
                }

//                m_log.DebugFormat("[COMMAND CONSOLE]: Adding to category {0} command {1}", module, command);
                commands.Add(info);
            }
        }

 public void FromXml(XmlElement root, CommandDelegate fn) {}

 public Command(string cmdname, string permissionneeded, CommandDelegate cmd)
 {
     Name = cmdname;
     permission = permissionneeded;
     command = cmd;
 }