1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 //! Item types.
12
13 use std::fmt;
14 use clean;
15
16 /// Item type. Corresponds to `clean::ItemEnum` variants.
17 ///
18 /// The search index uses item types encoded as smaller numbers which equal to
19 /// discriminants. JavaScript then is used to decode them into the original value.
20 /// Consequently, every change to this type should be synchronized to
21 /// the `itemTypes` mapping table in `static/main.js`.
22 #[deriving(Eq, Clone)]
23 pub enum ItemType {
24 Module = 0,
25 Struct = 1,
26 Enum = 2,
27 Function = 3,
28 Typedef = 4,
29 Static = 5,
30 Trait = 6,
31 Impl = 7,
32 ViewItem = 8,
33 TyMethod = 9,
34 Method = 10,
35 StructField = 11,
36 Variant = 12,
37 ForeignFunction = 13,
38 ForeignStatic = 14,
39 Macro = 15,
40 }
41
42 impl ItemType {
43 pub fn to_static_str(&self) -> &'static str {
44 match *self {
45 Module => "mod",
46 Struct => "struct",
47 Enum => "enum",
48 Function => "fn",
49 Typedef => "typedef",
50 Static => "static",
51 Trait => "trait",
52 Impl => "impl",
53 ViewItem => "viewitem",
54 TyMethod => "tymethod",
55 Method => "method",
56 StructField => "structfield",
57 Variant => "variant",
58 ForeignFunction => "ffi",
59 ForeignStatic => "ffs",
60 Macro => "macro",
61 }
62 }
63 }
64
65 impl fmt::Show for ItemType {
66 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
67 self.to_static_str().fmt(f)
68 }
69 }
70
71 impl fmt::Unsigned for ItemType {
72 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
73 (*self as uint).fmt(f)
74 }
75 }
76
77 pub fn shortty(item: &clean::Item) -> ItemType {
78 match item.inner {
79 clean::ModuleItem(..) => Module,
80 clean::StructItem(..) => Struct,
81 clean::EnumItem(..) => Enum,
82 clean::FunctionItem(..) => Function,
83 clean::TypedefItem(..) => Typedef,
84 clean::StaticItem(..) => Static,
85 clean::TraitItem(..) => Trait,
86 clean::ImplItem(..) => Impl,
87 clean::ViewItemItem(..) => ViewItem,
88 clean::TyMethodItem(..) => TyMethod,
89 clean::MethodItem(..) => Method,
90 clean::StructFieldItem(..) => StructField,
91 clean::VariantItem(..) => Variant,
92 clean::ForeignFunctionItem(..) => ForeignFunction,
93 clean::ForeignStaticItem(..) => ForeignStatic,
94 clean::MacroItem(..) => Macro,
95 }
96 }
97
librustdoc/html/item_type.rs:22:23-22:23 -enum- definition:
pub enum ItemType {
Module = 0,
Struct = 1,
references:- 1242: impl ItemType {
43: pub fn to_static_str(&self) -> &'static str {
--
77: pub fn shortty(item: &clean::Item) -> ItemType {
78: match item.inner {
librustdoc/html/format.rs:
185: root: |&render::Cache, &[~str]| -> Option<~str>,
186: info: |&render::Cache| -> Option<(Vec<~str> , ItemType)>)
187: -> fmt::Result
librustdoc/html/render.rs:
195: struct IndexItem {
196: ty: ItemType,
197: name: ~str,
librustdoc/html/item_type.rs:76:1-76:1 -fn- definition:
pub fn shortty(item: &clean::Item) -> ItemType {
match item.inner {
clean::ModuleItem(..) => Module,
references:- 14librustdoc/html/render.rs:
976: try!(write!(fmt.buf, "<a class='{}' href=''>{}</a>",
977: shortty(self.item), self.item.name.get_ref().as_slice()));
--
1063: fn cmp(i1: &clean::Item, i2: &clean::Item, idx1: uint, idx2: uint) -> Ordering {
1064: if shortty(i1) == shortty(i2) {
1065: return i1.name.cmp(&i2.name);
--
1333: },
1334: ty = shortty(it),
1335: name = it.name.get_ref().as_slice(),
--
1729: for item in m.items.iter() {
1730: let short = shortty(item).to_static_str();
1731: let myname = match item.name {