//! The main crate for Iron.
//!
//! ## Overview
//!
//! Iron is a high level web framework built in and for Rust, built on
//! [hyper](https://github.com/hyperium/hyper). Iron is designed to take advantage
//! of Rust's greatest features - its excellent type system and principled
//! approach to ownership in both single threaded and multi threaded contexts.
//!
//! Iron is highly concurrent and can scale horizontally on more machines behind a
//! load balancer or by running more threads on a more powerful machine. Iron
//! avoids the bottlenecks encountered in highly concurrent code by avoiding shared
//! writes and locking in the core framework.
//!
//! ## Hello World
//!
//! ```no_run
//! extern crate iron;
//!
//! use iron::prelude::*;
//! use iron::status;
//!
//! fn main() {
//! Iron::new(|_: &mut Request| {
//! Ok(Response::with((status::Ok, "Hello World!")))
//! }).http("localhost:3000").unwrap();
//! }
//! ```
//!
//! ## Design Philosophy
//!
//! Iron is meant to be as extensible and pluggable as possible; Iron's core is
//! concentrated and avoids unnecessary features by leaving them to middleware,
//! plugins, and modifiers.
//!
//! Middleware, Plugins, and Modifiers are the main ways to extend Iron with new
//! functionality. Most extensions that would be provided by middleware in other
//! web frameworks are instead addressed by the much simpler Modifier and Plugin
//! systems.
//!
//! Modifiers allow external code to manipulate Requests and Response in an ergonomic
//! fashion, allowing third-party extensions to get the same treatment as modifiers
//! defined in Iron itself. Plugins allow for lazily-evaluated, automatically cached
//! extensions to Requests and Responses, perfect for parsing, accessing, and
//! otherwise lazily manipulating an http connection.
//!
//! Middleware are only used when it is necessary to modify the control flow of a
//! Request flow, hijack the entire handling of a Request, check an incoming
//! Request, or to do final post-processing. This covers areas such as routing,
//! mounting, static asset serving, final template rendering, authentication, and
//! logging.
//!
//! Iron comes with only basic modifiers for setting the status, body, and various
//! headers, and the infrastructure for creating modifiers, plugins, and
//! middleware. No plugins or middleware are bundled with Iron.
//!
// Stdlib dependencies
extern crate log;
// Third party packages
extern crate hyper;
extern crate typemap as tmap;
extern crate plugin;
extern crate url as url_ext;
extern crate num_cpus;
extern crate mime_guess;
// Request + Response
pub use ;
pub use Response;
// Middleware system
pub use ;
// Server
pub use *;
// Extensions
pub use TypeMap;
// Headers
pub use header as headers;
pub use Headers;
// Expose `Pluggable` as `Plugin` so users can do `use iron::Plugin`.
pub use Pluggable as Plugin;
// Expose modifiers.
pub use Set;
// Errors
pub use Error;
pub use IronError;
// Mime types
pub use mime;
/// Iron's error type and associated utilities.
/// The Result alias used throughout Iron and in clients of Iron.
pub type IronResult<T> = ;
/// A module meant to be glob imported when using Iron.
///
/// For instance:
///
/// ```
/// use iron::prelude::*;
/// ```
///
/// This module contains several important traits that provide many
/// of the convenience methods in Iron, as well as `Request`, `Response`
/// `IronResult`, `IronError` and `Iron`.
/// Re-exports from the `TypeMap` crate.
/// Re-exports from the Modifier crate.
/// Re-exports from the url crate.
/// Status Codes
/// HTTP Methods
// Publicized to show the documentation
// Response utilities
// Request utilities
// Request and Response Modifiers
// Helper macros for error handling