/// <summary>
        /// Initialize and start new TcpClientHandler
        /// </summary>
        /// <param name="client">TcpClient to Handle</param>
        public MemTcpClient(TcpClient client, ProtocolType protocol)
        {
            _logManager = new LogManager(client.Client.RemoteEndPoint.ToString());
            _logManager.Info("MemTcpClient", "\tNew client connected on protocol :" + protocol.ToString());
            
            _client = client;
            _stream = _client.GetStream();

            _executionManager = new SequentialExecutionManager(_logManager);

            _inputBuffer = new byte[MAX_BUFFER_SIZE];
            _inputDataStream = new DataStream();

            _protocol = protocol;
            if (protocol == ProtocolType.Text)
            {
                _parser = new TextProtocolParser(_inputDataStream, this, _logManager);
                _responseManager = new TextResponseManager(_stream, _logManager);
            }
            else
            {
                _parser = new BinaryProtocolParser(_inputDataStream, this, _logManager);
                _responseManager = new BinaryResponseManager(_stream, _logManager);
            }
            _responseManager.MemTcpClient = this;

            _parser.CommandConsumer = _executionManager;
            _executionManager.CommandConsumer = _responseManager;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="log">ログ</param>
        /// <param name="index">3D表示インデックス</param>
        public frmGraph3D(LogManager log, int index)
        {
            InitializeComponent();

            this.log = log;
            this.index = index;
        }

        static void Main(string[] args)
        {
            LogManager lm = new LogManager("TestSearch", @"C:\Users\Thibault\Documents\Logs\", 3);

            //LogManager lm2 = new LogManager("log");
            // LogManager f = new LogManager("fu");
            lm.logEvent("Programme principal", "Erreur 7");
            lm.logEvent("Programme secondaire", "Erreur 0");
            /*lm.logEvent("Programme principal", "Nlkd,qds");
            lm.logEvent("Programme principal", "kdjzalmk");
            lm.logEvent("Programme principal", "Rhaaaa");*/

            //Test de la recherche

            DateTime now = new DateTime(2011,11,27,16,36,45);
            DateTime end = now.AddDays(3);
            lm.getLogs(now, end);

            //lm.getLogs(now, end, "Programme secondaire");

            // lm.logEvent("Programme secondaire", "Erreur 7", "Test2");
              //ThreadTest tt = new ThreadTest(lm);

              /*  try
            {
                StreamReader sr = System.IO.File.OpenText("test");
            }
            catch (Exception err)
            {
                lm.logException("Programme principal", err);
            }*/
        }

        public ZLogViewer()
        {
            InitializeComponent();

            this.mLogManager = LogManager.GetInstance();
            this.openFileDialog.Multiselect = true;
            this.ListViewLog.Dock = DockStyle.Fill;
            this.textBoxLog.Dock = DockStyle.Fill;
            this.fileToolStripMenuItem.Click += this.GetAllLogPaths;
            this.mergeToolStripMenuItem.Click += this.GetAllLogPathsMerge;
            this.btnFilter.Click += this.Filter;
            this.btnNext.Click += this.SearchNext;
            this.btnPrevious.Click += this.SearchPrev;
            this.ListViewLog.ColumnClick += this.ColumnFilter;
            this.ListViewLog.MultiSelect = false;
            this.ListViewLog.SelectedIndexChanged += this.ShowLog;
            this.ListViewLog.ItemSelectionChanged += this.listview_itemselectionchanged;
            this.ListViewLog.Validated += this.listview_validated;
            this.DragDrop += DragAndDropFile;
            this.ListViewLog.DragDrop += DragAndDropFile;
            this.ListViewLog.DragEnter += listViewFolder_DragEnter;
            this.textBoxLog.MouseClick += this.aa;
            this.toolStripProgressBar.Dock = DockStyle.Bottom;
            this.HelpRequested += this.HelpPopup;
            this.checkBoxAutoReresh.CheckedChanged += AutoRefresh;
            this.decryptToolStripMenuItem.Click += DecryptText;
            LogManager.readCompleteCallBack += Refresh;
            LogManager.SetFormControl(this);
            this.ListViewLog.HideSelection = true;
            //ZLog.AddLogEventHander(this.SetTextAsLog);
        }

 internal Log(LogManager manager, string name)
 {
     this._manager = new WeakReference(manager);
     this._name = name;
     this._level = LogLevel.None;
     manager.Add(new Log.Shadow(this));
 }

        /// <summary>
        /// Constructor
        /// </summary>
        public frmMain()
        {
            InitializeComponent();

            //ボード情報取得イベント
            CommunicationMonitor.GetInstance().GotBoardInfoEvent += new EventHandler(CommunicationMonitor_GotBoardInfoEvent);

            //メッセージ要求
            CommunicationMonitor.GetInstance().ShowMessageRequestEvent += new CommunicationMonitor.ShowMessageRequestHandler(CommunicationMonitor_ShowMessageRequestEvent);

            //監視モニタコメント表示要求
            CommunicationMonitor.GetInstance().ShowCommunicationCommentEvent += new CommunicationMonitor.ShowCommunicationCommentHandler(CommunicationMonitor_ShowCommunicationCommentEvent);

            // ログ設定
            var logConfigPath = ConfigurationManager.AppSettings["LogConfigPathUi"];
            if (string.IsNullOrEmpty(System.IO.Path.GetDirectoryName(logConfigPath)))
            {
                // ファイル名だけの場合はRM-3000.exeと同じパスとしてフルパス化する
                var assemblyPath = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;
                var localPath = (new System.Uri(assemblyPath)).LocalPath;
                logConfigPath = System.IO.Path.GetDirectoryName(localPath) + @"\" + logConfigPath;
            }
            this.log = LogManager.Instance;
            this.log.SetupLog(logConfigPath);

            AppResource.SetControlsText(this);

            ContentsLoad();
        }

 public LogManager()
 {
     instance = this;
     logPath = GetLogPath();
     logStream = new FileStream(logPath, FileMode.Create, FileAccess.Write, FileShare.Read);
     writer = new StreamWriter(logStream);
 }

        public void TestGetLoggerByType()
        {
            var manager = new LogManager(new LoggingConfiguration());

            var logger = manager.GetLogger<LogManagerBaseTests>();
            Assert.NotNull(logger);
        }

        public void TestGetLogger()
        {
            var manager = new LogManager(new LoggingConfiguration());

            var logger = manager.GetLogger("Foobar");
            Assert.NotNull(logger);
        }

 public InterfaceManager(TextBox tBox)
 {
     PANGU_Manager.killPANGU();
     navigationMapManager = new NavigationMapManager();
     logManager = new LogManager(tBox);
     logManager.clearSimulationLog();
 }

        public static void Main(string[] args)
        {
            LogManager customLogManager = new LogManager(LogManager.ErrorType.OFF, LogManager.ErrorType.FATAL, "customlogfile.log", true);
            // all delegate where execute in thread
            LogManager.defaultInstance.objectExceptCatched += objLog;
            LogManager.defaultInstance.writeToConsole = LogManager.ErrorType.TRACE;

            DemoClass demoClass = new DemoClass(){ jobs = "Demo for PonyLogManager" };
            demoClass.sw.Start();

            LogManager.defaultInstance.trace("Start demo");
            try{
                int a = 0, b = 0;
                a /= b;
            } catch (Exception e) {
                e.ERROR();
                // you can also
                LogManager.defaultInstance.debug(e);
                // or
                e.DEBUG(customLogManager);
                customLogManager.debug(e);
            }
            demoClass.sw.Stop();
            LogManager.defaultInstance.debug(demoClass);
            LogManager.defaultInstance.trace("End demo");
            Console.Read();
        }

        public void Write(string category, string source, LogType logType, string logMsg, string detail)
        {
            Guid id = Guid.NewGuid();

            LogEntity log = new LogEntity();
            log.Id = id;
            log.Category = category;
            log.Source = source;
            log.Type = (short)logType;
            log.Message = logMsg;

            LogDetailEntity logDetail = new LogDetailEntity();
            logDetail.Id = id;
            logDetail.LogDetail = detail;

            try
            {
                using (ILHDBTran tran = BeginTran())
                {
                    LogManager manager = new LogManager(tran);
                    manager.AddLog(log);
                    manager.AddLogDetail(logDetail);
                    tran.Commit();
                }
            }
            catch (Exception ex)
            {
                FileLogWriter writer = new FileLogWriter();
                writer.Write(LogCategory.LogWrite, "Write log to database", ex);
                writer.Write(category, source, logType, logMsg, detail);
            }
        }

        public static void log(string information, LogManager.Level level)
        {
            /// Without this line under, if using Debug.WriteLine in multiple classes the settings will be unable to be read. They will be returned as null and the application will fall to its knees.
            /// Looking at AppDomain.CurrentDomain.SetupInformation.ConfigurationFile, it seems that the config path isn't set, trying to set it here too solves the issue. For now...
            AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", MainConsole.fullConfig);

            string logMessage = null;
            switch (level) {

                // INFO
                case Level.INFO:
                    logMessage = "[INFO] " + information;
                    break;

                // ERROR
                case Level.ERROR:
                    logMessage = "[ERROR] " + information;
                    break;

                // SETTING
                case Level.SETTING:
                    logMessage = "[SETTING] " + information;
                    break;

                default:
                    break;
            }
            Debug.WriteLine(logMessage);
        }

 /// <summary>
 /// Initialize log
 /// </summary>
 /// <param name="_logPath"></param>
 public static void Initialize(string _logPath, LogLevel logLevel = LogLevel.Information)
 {
     singleton = new LogManager();
     singleton.LogPath = _logPath;
     singleton.currentLogLevel = logLevel;
     singleton.Start();
 }

            public void OverrideDefaultLevelIfSwitchConfigured()
            {
                var logManager = new LogManager();
                var logger = logManager.CreateLogger("LogManager.Test");

                Assert.True(logger.IsDebugEnabled);
            }

        /// <summary>
        /// Initialize a new OpenVPN service.
        /// </summary>
        /// <param name="binfile">path to openvpn</param>
        /// <param name="configfile">path to openvpn config</param>
        /// <param name="dir">directory where config lies</param>
        /// <param name="logs">provider to write logs to</param>
        /// <param name="host">The host to connect to (e.g. 127.0.0.1)</param>
        /// <param name="port">The port to connect to</param>
        /// <param name="logfile">file to write OpenVPN log to</param>
        /// <param name="smartCardSupport">enable SmartCard support</param>
        public UserSpaceService(string binfile, string configfile, 
            string dir, LogManager logs, string host, int port,
            string logfile, bool smartCardSupport)
        {
            m_logs = logs;

            m_psi.FileName = binfile;
            m_psi.WorkingDirectory = dir;
            m_psi.WindowStyle = ProcessWindowStyle.Hidden;
            m_psi.UseShellExecute = true;

            /*WindowsPrincipal principal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
            principal.IsInRole(WindowsBuiltInRole.Administrator)*/
            if (Environment.OSVersion.Version.Major >= 6)
                m_psi.Verb = "runas";

            m_psi.CreateNoWindow = true;
            m_psi.Arguments =
                (logfile != null ? "--log \"" + logfile + "\"" : "") +
                " --config \"" + configfile + "\"" +
                " --management " + host + " " + port.ToString(CultureInfo.InvariantCulture) +
                " --management-query-passwords" +
                " --management-hold" +
                " --management-signal" +
                " --management-forget-disconnect" +
                " --auth-retry interact";

            if (smartCardSupport)
                m_psi.Arguments += " --pkcs11-id-management";
        }

            public void OverrideListenersIfSourceConfigured()
            {
                var logManager = new LogManager();
                var logger = (Logger)logManager.CreateLogger("LogManager.Test");

                Assert.Equal(0, logger.TraceSource.Listeners.Count);
            }

        protected void Page_Load(object sender, EventArgs e)
        {
            string UserName =Request["UserName"] ?? string.Empty;
            string UserPwd = Request["UserPwd"] ?? string.Empty;
            string LogData =Request["LogData"] ?? string.Empty;

            try
            {
                UserManager um = new UserManager();
                if (um.CheckUser(UserName, UserPwd))
                {
                    if (!string.IsNullOrEmpty(LogData))
                    {
                        List<LogEvent> logList = JsonConvert.DeserializeObject<List<LogEvent>>(LogData);

                        if (logList != null)
                        {
                            LogManager lm = new LogManager();
                            bool result = lm.AddLog(logList);
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                LogExt.SetError(ex, "");
            }
        }

            public void DefaultToStandardListenersIfSwitchNameUnknown()
            {
                var logManager = new LogManager();
                var logger = (Logger)logManager.CreateLogger("LogManager.UnknownSource");

                Assert.Equal(Trace.Listeners.Count, logger.TraceSource.Listeners.Count);
            }

 /// <summary>
 ///     Internal constructor.  This class cannot be instantiated externally.
 /// </summary>
 public LogManager()
 {
     if ( instance == null )
     {
         instance = this;
     }
 }