public TThreadPoolServer(TProcessor processor, TServerTransport serverTransport, LogDelegate logDelegate)
     : this(new TSingletonProcessorFactory(processor), serverTransport,
      new TTransportFactory(), new TTransportFactory(),
      new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
      DEFAULT_MIN_THREADS, DEFAULT_MAX_THREADS, logDelegate)
 {
 }

 public TThreadPoolServer(Processor processor, ServerTransport serverTransport, LogDelegate logDelegate)
     : this(processor, serverTransport,
          new TransportFactory(), new TransportFactory(),
          new BinaryProtocol.Factory(), new BinaryProtocol.Factory(),
          DEFAULT_MIN_THREADS, DEFAULT_MAX_THREADS, logDelegate)
 {
 }

        public TThreadedServer(TProcessor processor, TServerTransport serverTransport, LogDelegate logDelegate)
            : this(processor, serverTransport,
				 new TTransportFactory(), new TTransportFactory(),
				 new TBinaryProtocol.Factory(), new TBinaryProtocol.Factory(),
				 DEFAULT_MAX_THREADS, logDelegate)
        {
        }

        public void ReceiveCallback(IAsyncResult ar)
        {
            LogDelegate log = new LogDelegate(this.Bench.Log);

            try
            {
                UdpClient u = (UdpClient)((UdpState)(ar.AsyncState)).u;
                IPEndPoint e = (IPEndPoint)((UdpState)(ar.AsyncState)).e;

                Byte[] receiveBytes = u.EndReceive(ar, ref e);
                string receiveString = Encoding.ASCII.GetString(receiveBytes);

                UDPResponse = Encoding.ASCII.GetString(receiveBytes, 0, receiveBytes.Length);
                string verboseLog = "Received broadcast from " + e.ToString() + ":\n" + UDPResponse + "\n";
                log(verboseLog);

                Console.WriteLine("Received: {0}", receiveString);
                messageReceived = true;
            }
            catch (Exception e)
            {
                UDPResponse = "";
                log(e.ToString());
            }
        }

		public TServer(TProcessor processor,
		               TServerTransport serverTransport,
		               LogDelegate logDelegate)
			: this(
				processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(),
				new TBinaryProtocol.Factory(), DefaultLogDelegate)
		{
		}

        public MultiConverterModel(Part part, Vessel vessel, LogDelegate logDelegate)
        {
            this.part = part;
            this.vessel = vessel;
            this.logDelegate = logDelegate;

            this.converters = new List<ModuleResourceConverter>();
        }

        internal Logger(string name, ILogger logger, ConfigSource config)
        {
            this.name = name;
            this.logger = logger;
            this.config = config;

            logDelegate = new LogDelegate(Log);
        }

		public TSimpleServer(TProcessor processor,
		                     TServerTransport serverTransport,
		                     LogDelegate logDel)
			: base(
				processor, serverTransport, new TTransportFactory(), new TTransportFactory(), new TBinaryProtocol.Factory(),
				new TBinaryProtocol.Factory(), logDel)
		{
		}

 public FormServers()
 {
     //
     // Required for Windows Form Designer support
     //
     InitializeComponent();
     logDelegate=new LogDelegate(m_Log);
     m_Globalize();
 }

 public void Log( string message ) {
     if( this.textBox1.InvokeRequired ) {
         LogDelegate d = new LogDelegate( LogInternal );
         this.Invoke
             ( d, new object[] { message } );
     } else {
         LogInternal( message );
     }
 }

        public PacketSniffer(LogDelegate logDelegate)
        {
            Log = logDelegate;

            aborting = false;
            device = null;
            packetLock = new object();
            packetAvailiable = new AutoResetEvent(false);
            disposed = false;
        }

        public LoggerSql(SqlConnection connection, LogDelegate logCommand)
        {
            if (connection == null)
                throw new ArgumentNullException("The SQL connection was null when passed into LoggerSql");
            if (logCommand == null)
                throw new ArgumentNullException("No LogDelegate was specified on the constructor to LoggerSql");

            this.connection = connection;
            this.logCommand = logCommand;
            this.Count = 0;
        }

 public TServerAsync(TProcessorAsync processor,
         TServerTransportAsync serverTransport,
         LogDelegate logDelegate)
     : this(processor,
      serverTransport,
      new TTransportFactoryAsync(),
      new TTransportFactoryAsync(),
      new TCompactProtocolAsync.Factory(),
      new TCompactProtocolAsync.Factory(),
      logDelegate)
 {
 }

 public void newCommand(string p)
 {
     if (txtCommandsUsed.InvokeRequired)
     {
         LogDelegate d = new LogDelegate(newCommand);
         this.Invoke(d, new object[] { p });
     }
     else
     {
         txtCommandsUsed.AppendTextAndScroll(p);
     }
 }

        public void log(string message)
        {
            if (this.InvokeRequired)
            {
                LogDelegate d = new LogDelegate(log);
                this.Invoke(d, new object[] { message });
            }
            else
            {
                txtLog.AppendText(Environment.NewLine + message);

            }
        }

        //!!logDelegate cannot block!
        public static void CreateColumn(String header, LogDelegate logDelegate)
        {
            lock (loggingLock)
            {
                if (loggingStarted)
                    return;

                headerList.Add(header);
                delegateList.Add(logDelegate);
            }

            return;
        }

        public Main()
        {
            InitializeComponent();

            LogDelegateInstance = new LogDelegate(_Log);
            ErrorDelegateInstance = new ErrorDelegate(_Error);

            StartServer sserver = new StartServer(_StartServer);
            Thread serverConnection = new Thread(new ThreadStart(sserver));
            serverConnection.Start();

            //Thread.Sleep(5000);
        }

        public SilentForm()
            : base()
        {
            InitializeComponent();
            Alert = new AlertDelegate(AlertMethod);
            Exit = new ExitDelegate(ExitMethod);
            FatalExit = new FatalExitDelegate(FatalExitMethod);
            Log = new LogDelegate(LogMethod);
            ReportProgress = new ReportProgressDelegate(ReportProgressMethod);
            Info = new InfoDelegate(InfoMethod);

            logfile=File.OpenWrite(Path.GetDirectoryName(Application.ExecutablePath)+"\\cuetoogg.log.txt");
        }

 public void log(string msg)
 {
     if (this.InvokeRequired == false)
     {
         statusTextBox.Text += msg + Environment.NewLine;
     }
     else
     {
         LogDelegate logDelegate = new LogDelegate(log);
         this.BeginInvoke(logDelegate,
                         new object[] { msg });
     }
     logInfo(msg);
 }

        public TThreadPoolServer(TProcessor processor,
								 TServerTransport serverTransport,
								 TTransportFactory inputTransportFactory,
								 TTransportFactory outputTransportFactory,
								 TProtocolFactory inputProtocolFactory,
								 TProtocolFactory outputProtocolFactory,
								 int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
            : base(processor, serverTransport, inputTransportFactory, outputTransportFactory,
				  inputProtocolFactory, outputProtocolFactory, logDel)
        {
            if (!ThreadPool.SetMaxThreads(maxThreadPoolThreads, maxThreadPoolThreads))
            {
                throw new Exception("Error: could not SetMaxThreads in ThreadPool");
            }
        }