public DropCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
     : base(console, factory, queries, formatters)
 {
     AddCommandName("drop");
     AddCommandName("putdown");
     AddCommandName("release");
 }

 private static string BuildFormatTimePart(IFormatter cultureFormatter, TimeUnit timeUnitType, int amountOfTimeUnits)
 {
     // Always use positive units to account for negative timespans
     return amountOfTimeUnits != 0
         ? cultureFormatter.TimeSpanHumanize(timeUnitType, Math.Abs(amountOfTimeUnits))
         : null;
 }

        private static void Print(IFormatter formatter)
        {
            List<Publication> documents = new List<Publication>();

            var newspaper = new Newspaper(formatter);
            newspaper.Title = "The Publicist";
            newspaper.Articles.Add("Sugar linked to bad eyesight", "Rod Sugar");
            newspaper.Articles.Add("Sweden bans chocolate", "Willy Wonka");
            newspaper.Articles.Add("Opera house to be painted orange", "Orange Arup");
            documents.Add(newspaper);

            var book = new Book(formatter)
            {
                Title = "Price of Silence",
                Author = "Jay and Silent Bob",
                Text = "Blah-de-blah-de-blah..."
            };

            documents.Add(book);

            var magazine = new Magazine(formatter)
            {
                Name = "MixMag",
                PrintDate = "30/08/1993",
                CoverHeadline = "Downloads outstrip CD sales"
            };

            documents.Add(magazine);

            foreach (var doc in documents)
            {
                doc.Print();
            }
        }

 public InventoryCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
     : base(console, factory, queries, formatters)
 {
     AddCommandName("inventory");
     AddCommandName("inv");
     AddCommandName("i");
 }

 public FileModel(FileAndType ft, object content, FileAndType original = null, IFormatter serializer = null)
 {
     OriginalFileAndType = original ?? ft;
     FileAndType = ft;
     _content = content;
     _serializer = serializer;
 }

        public SimpleIterativeRouter2(Key self, ushort tcpPort, IMessagingSocket sock, IKeyBasedRoutingAlgorithm algo, IFormatter formatter, bool isStrictMode)
        {
            _selfId = self;
            _tcpPort = tcpPort;
            _sock = sock;
            _algo = algo;
            _strict_mode = isStrictMode;

            // メッセージに含むことの出来る大体の最大NodeHandle数を計算
            int overhead, nodeHandleBytes;
            {
                using (MemoryStream ms = new MemoryStream ()) {
                    formatter.Serialize (ms, new NextHopResponse (self, _tcpPort, true, new NodeHandle[0]));
                    overhead = (int)ms.Length;
                }
                using (MemoryStream ms = new MemoryStream ()) {
                    formatter.Serialize (ms, new NodeHandle (self, new IPEndPoint (IPAddress.Loopback, 0), tcpPort));
                    nodeHandleBytes = (int)ms.Length;
                }
            }
            _maxNodeHandlesPerResponse = (dgramMaxSize - overhead) / nodeHandleBytes;

            algo.Setup (self, this);
            sock.AddInquiredHandler (typeof (NextHopQuery), MessagingSocket_Inquired_NextHopQuery);
            sock.AddInquiredHandler (typeof (CloseNodeQuery), MessagingSocket_Inquired_CloseNodeQuery);
        }

 public TakeCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
     : base(console, factory, queries, formatters)
 {
     AddCommandName("take");
     AddCommandName("pickup");
     AddCommandName("get");
 }

        public void Run(string dll, string filter, IFormatter outputFormatter, Action<string, string, IFormatter> action)
        {
            this.dll = dll;

            var setup = new AppDomainSetup();

            setup.ConfigurationFile = Path.GetFullPath(config);

            setup.ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

            domain = AppDomain.CreateDomain("NSpecDomain.Run", null, setup);

            var type = typeof(Wrapper);

            var assemblyName = type.Assembly.GetName().Name;

            var typeName = type.FullName;

            domain.AssemblyResolve += Resolve;

            var wrapper = (Wrapper)domain.CreateInstanceAndUnwrap(assemblyName, typeName);

            wrapper.Execute(dll, filter, outputFormatter, action);

            AppDomain.Unload(domain);
        }

 public IPort Bind(int portNumber, IFormatter formatter)
 {
     TcpPort port = new TcpPort(portNumber, formatter);
     port.Open();
     ports.Add(port);
     return port;
 }

 public LogConfig(IFormatter formatter, LogCategoryRegistrar categoryRegistry = null)
 {
     Formatter = formatter;
     CategoryRegistrar = categoryRegistry ?? new LogCategoryRegistrar();
     TargetConfigs = new List<TargetConfig>();
     Levels = new bool[LogLevels.Levels.Length];
 }

 HelpPrinter(IFormatter formatter)
 {
     this.formatter = formatter;
     var parser = new Parser();
     parser.LoadPlugin(typeof(UnitValue).Assembly);
     doc = Documentation.Create(parser.Context);
 }

 public PickUpCommand(IConsoleFacade console, IRepositoryFactoryFactory factory, IGameObjectQueries goQueries, IFormatter[] formatters)
     : base(console, factory, goQueries, formatters)
 {
     AddCommandName("pickup");
     AddCommandName("get");
     AddCommandName("grab");
 }

 public Message(byte[] chunk, int chunkSize, int offset, IFormatter formatter)
 {
     this.chunk = chunk;
     this.chunkSize = chunkSize;
     this.offset = offset;
     this.formatter = formatter;
 }

 public MessageReceiver(TcpClient client, IFormatter formatter, IHandler handler)
 {
     this.client = client;
     this.handler = handler;
     this.assembler = new MessageAssembler(formatter);
     this.chunk = new byte[4096];
 }

        public ConsoleTarget(IFormatter formatter)
        {
			if (formatter == null)
				throw new ArgumentNullException("formatter");

            Formatter = formatter;
        }

        public override void Write(Entry entry, IFormatter formatter)
        {
            lock (typeof (ColoredConsoleTarget))
            {
                var oldColor = Console.ForegroundColor;

                switch (entry.Level)
                {
                    case LogLevel.Warn:
                        Console.ForegroundColor = ConsoleColor.DarkYellow;
                        break;

                    case LogLevel.Error:
                        Console.ForegroundColor = ConsoleColor.Red;
                        break;

                    case LogLevel.Fatal:
                        Console.ForegroundColor = ConsoleColor.Magenta;
                        break;
                }

                var content = (Formatter ?? formatter).Format(entry);

                Console.Write(content);

                Console.ForegroundColor = oldColor;
            }
        }

 /// <inheritdoc />
 public virtual string Format(object obj, IFormatter formatter)
 {
     var value = (Type) obj;
     var result = new StringBuilder();
     AppendType(result, value);
     return result.ToString();
 }

        /// <inheritdoc />
        public string Format(object obj, IFormatter formatter)
        {
            if (state == null)
                state = new ReentranceState();

            string result = null;
            state.Enter(reentranceCount =>
            {
                if (reentranceCount >= 3 || state.Visited.Contains(obj))
                {
                    result = "{...}";
                }
                else
                {
                    try
                    {
                        state.Visited.Add(obj);
                        result = FormatRecursive(obj, formatter);
                    }
                    finally
                    {
                        state.Visited.Remove(obj);
                    }
                }
            });

            return result;
        }

 public LookCommand(IConsoleFacade console,  IRepository<GameObject> repository, IFormatter format, IPlayer player)
 {
     this.console = console;
     this.repository = repository;
     this.format = format;
     this.player = player;
 }

 public RunnerInvocation(string dll, string tags, IFormatter formatter, bool failFast)
 {
     this.dll = dll;
     this.failFast = failFast;
     Tags = tags;
     Formatter = formatter;
 }