Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "yaml_emitter_emit_flow_mapping_key", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ",", "first", "bool", ")", "bool", "{", "if", "first", "{", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "'{'", "}", ",", "true", ",", "true", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_increase_indent", "(", "emitter", ",", "true", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "flow_level", "++", "\n", "}", "\n\n", "if", "event", ".", "typ", "==", "yaml_MAPPING_END_EVENT", "{", "emitter", ".", "flow_level", "--", "\n", "emitter", ".", "indent", "=", "emitter", ".", "indents", "[", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "indents", "=", "emitter", ".", "indents", "[", ":", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "if", "emitter", ".", "canonical", "&&", "!", "first", "{", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "','", "}", ",", "false", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indent", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "'}'", "}", ",", "false", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "state", "=", "emitter", ".", "states", "[", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "emitter", ".", "states", "=", "emitter", ".", "states", "[", ":", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "return", "true", "\n", "}", "\n\n", "if", "!", "first", "{", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "','", "}", ",", "false", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "emitter", ".", "canonical", "||", "emitter", ".", "column", ">", "emitter", ".", "best_width", "{", "if", "!", "yaml_emitter_write_indent", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "if", "!", "emitter", ".", "canonical", "&&", "yaml_emitter_check_simple_key", "(", "emitter", ")", "{", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "false", ",", "true", ",", "true", ")", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "'?'", "}", ",", "true", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_FLOW_MAPPING_VALUE_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "false", ",", "true", ",", "false", ")", "\n", "}" ]

[ "Expect", "a", "flow", "key", "node", "." ]

[ "func", "yaml_emitter_emit_flow_mapping_value", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ",", "simple", "bool", ")", "bool", "{", "if", "simple", "{", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "':'", "}", ",", "false", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "else", "{", "if", "emitter", ".", "canonical", "||", "emitter", ".", "column", ">", "emitter", ".", "best_width", "{", "if", "!", "yaml_emitter_write_indent", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "':'", "}", ",", "true", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_FLOW_MAPPING_KEY_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "false", ",", "true", ",", "false", ")", "\n", "}" ]

[ "Expect", "a", "flow", "value", "node", "." ]

[ "func", "yaml_emitter_emit_block_sequence_item", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ",", "first", "bool", ")", "bool", "{", "if", "first", "{", "if", "!", "yaml_emitter_increase_indent", "(", "emitter", ",", "false", ",", "emitter", ".", "mapping_context", "&&", "!", "emitter", ".", "indention", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "event", ".", "typ", "==", "yaml_SEQUENCE_END_EVENT", "{", "emitter", ".", "indent", "=", "emitter", ".", "indents", "[", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "indents", "=", "emitter", ".", "indents", "[", ":", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "state", "=", "emitter", ".", "states", "[", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "emitter", ".", "states", "=", "emitter", ".", "states", "[", ":", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "return", "true", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indent", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "'-'", "}", ",", "true", ",", "false", ",", "true", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "true", ",", "false", ",", "false", ")", "\n", "}" ]

[ "Expect", "a", "block", "item", "node", "." ]

[ "func", "yaml_emitter_emit_block_mapping_key", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ",", "first", "bool", ")", "bool", "{", "if", "first", "{", "if", "!", "yaml_emitter_increase_indent", "(", "emitter", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "event", ".", "typ", "==", "yaml_MAPPING_END_EVENT", "{", "emitter", ".", "indent", "=", "emitter", ".", "indents", "[", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "indents", "=", "emitter", ".", "indents", "[", ":", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "state", "=", "emitter", ".", "states", "[", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "emitter", ".", "states", "=", "emitter", ".", "states", "[", ":", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "return", "true", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indent", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "yaml_emitter_check_simple_key", "(", "emitter", ")", "{", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "false", ",", "true", ",", "true", ")", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "'?'", "}", ",", "true", ",", "false", ",", "true", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_BLOCK_MAPPING_VALUE_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "false", ",", "true", ",", "false", ")", "\n", "}" ]

[ "Expect", "a", "block", "key", "node", "." ]

[ "func", "yaml_emitter_emit_block_mapping_value", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ",", "simple", "bool", ")", "bool", "{", "if", "simple", "{", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "':'", "}", ",", "false", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "else", "{", "if", "!", "yaml_emitter_write_indent", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "':'", "}", ",", "true", ",", "false", ",", "true", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "emitter", ".", "states", "=", "append", "(", "emitter", ".", "states", ",", "yaml_EMIT_BLOCK_MAPPING_KEY_STATE", ")", "\n", "return", "yaml_emitter_emit_node", "(", "emitter", ",", "event", ",", "false", ",", "false", ",", "true", ",", "false", ")", "\n", "}" ]

[ "Expect", "a", "block", "value", "node", "." ]

[ "func", "yaml_emitter_emit_alias", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ")", "bool", "{", "if", "!", "yaml_emitter_process_anchor", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "state", "=", "emitter", ".", "states", "[", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "emitter", ".", "states", "=", "emitter", ".", "states", "[", ":", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "return", "true", "\n", "}" ]

[ "Expect", "ALIAS", "." ]

[ "func", "yaml_emitter_emit_scalar", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ")", "bool", "{", "if", "!", "yaml_emitter_select_scalar_style", "(", "emitter", ",", "event", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_process_anchor", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_process_tag", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_increase_indent", "(", "emitter", ",", "true", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_process_scalar", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "emitter", ".", "indent", "=", "emitter", ".", "indents", "[", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "indents", "=", "emitter", ".", "indents", "[", ":", "len", "(", "emitter", ".", "indents", ")", "-", "1", "]", "\n", "emitter", ".", "state", "=", "emitter", ".", "states", "[", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "emitter", ".", "states", "=", "emitter", ".", "states", "[", ":", "len", "(", "emitter", ".", "states", ")", "-", "1", "]", "\n", "return", "true", "\n", "}" ]

[ "Expect", "SCALAR", "." ]

[ "func", "yaml_emitter_emit_sequence_start", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ")", "bool", "{", "if", "!", "yaml_emitter_process_anchor", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_process_tag", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "emitter", ".", "flow_level", ">", "0", "||", "emitter", ".", "canonical", "||", "event", ".", "sequence_style", "(", ")", "==", "yaml_FLOW_SEQUENCE_STYLE", "||", "yaml_emitter_check_empty_sequence", "(", "emitter", ")", "{", "emitter", ".", "state", "=", "yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE", "\n", "}", "else", "{", "emitter", ".", "state", "=", "yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Expect", "SEQUENCE", "-", "START", "." ]

[ "func", "yaml_emitter_emit_mapping_start", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ")", "bool", "{", "if", "!", "yaml_emitter_process_anchor", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_process_tag", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "if", "emitter", ".", "flow_level", ">", "0", "||", "emitter", ".", "canonical", "||", "event", ".", "mapping_style", "(", ")", "==", "yaml_FLOW_MAPPING_STYLE", "||", "yaml_emitter_check_empty_mapping", "(", "emitter", ")", "{", "emitter", ".", "state", "=", "yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE", "\n", "}", "else", "{", "emitter", ".", "state", "=", "yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Expect", "MAPPING", "-", "START", "." ]

[ "func", "yaml_emitter_check_empty_sequence", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "if", "len", "(", "emitter", ".", "events", ")", "-", "emitter", ".", "events_head", "<", "2", "{", "return", "false", "\n", "}", "\n", "return", "emitter", ".", "events", "[", "emitter", ".", "events_head", "]", ".", "typ", "==", "yaml_SEQUENCE_START_EVENT", "&&", "emitter", ".", "events", "[", "emitter", ".", "events_head", "+", "1", "]", ".", "typ", "==", "yaml_SEQUENCE_END_EVENT", "\n", "}" ]

[ "Check", "if", "the", "next", "events", "represent", "an", "empty", "sequence", "." ]

[ "func", "yaml_emitter_check_empty_mapping", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "if", "len", "(", "emitter", ".", "events", ")", "-", "emitter", ".", "events_head", "<", "2", "{", "return", "false", "\n", "}", "\n", "return", "emitter", ".", "events", "[", "emitter", ".", "events_head", "]", ".", "typ", "==", "yaml_MAPPING_START_EVENT", "&&", "emitter", ".", "events", "[", "emitter", ".", "events_head", "+", "1", "]", ".", "typ", "==", "yaml_MAPPING_END_EVENT", "\n", "}" ]

[ "Check", "if", "the", "next", "events", "represent", "an", "empty", "mapping", "." ]

[ "func", "yaml_emitter_check_simple_key", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "length", ":=", "0", "\n", "switch", "emitter", ".", "events", "[", "emitter", ".", "events_head", "]", ".", "typ", "{", "case", "yaml_ALIAS_EVENT", ":", "length", "+=", "len", "(", "emitter", ".", "anchor_data", ".", "anchor", ")", "\n", "case", "yaml_SCALAR_EVENT", ":", "if", "emitter", ".", "scalar_data", ".", "multiline", "{", "return", "false", "\n", "}", "\n", "length", "+=", "len", "(", "emitter", ".", "anchor_data", ".", "anchor", ")", "+", "len", "(", "emitter", ".", "tag_data", ".", "handle", ")", "+", "len", "(", "emitter", ".", "tag_data", ".", "suffix", ")", "+", "len", "(", "emitter", ".", "scalar_data", ".", "value", ")", "\n", "case", "yaml_SEQUENCE_START_EVENT", ":", "if", "!", "yaml_emitter_check_empty_sequence", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "length", "+=", "len", "(", "emitter", ".", "anchor_data", ".", "anchor", ")", "+", "len", "(", "emitter", ".", "tag_data", ".", "handle", ")", "+", "len", "(", "emitter", ".", "tag_data", ".", "suffix", ")", "\n", "case", "yaml_MAPPING_START_EVENT", ":", "if", "!", "yaml_emitter_check_empty_mapping", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "length", "+=", "len", "(", "emitter", ".", "anchor_data", ".", "anchor", ")", "+", "len", "(", "emitter", ".", "tag_data", ".", "handle", ")", "+", "len", "(", "emitter", ".", "tag_data", ".", "suffix", ")", "\n", "default", ":", "return", "false", "\n", "}", "\n", "return", "length", "<=", "128", "\n", "}" ]

[ "Check", "if", "the", "next", "node", "can", "be", "expressed", "as", "a", "simple", "key", "." ]

[ "func", "yaml_emitter_select_scalar_style", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ")", "bool", "{", "no_tag", ":=", "len", "(", "emitter", ".", "tag_data", ".", "handle", ")", "==", "0", "&&", "len", "(", "emitter", ".", "tag_data", ".", "suffix", ")", "==", "0", "\n", "if", "no_tag", "&&", "!", "event", ".", "implicit", "&&", "!", "event", ".", "quoted_implicit", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n\n", "style", ":=", "event", ".", "scalar_style", "(", ")", "\n", "if", "style", "==", "yaml_ANY_SCALAR_STYLE", "{", "style", "=", "yaml_PLAIN_SCALAR_STYLE", "\n", "}", "\n", "if", "emitter", ".", "canonical", "{", "style", "=", "yaml_DOUBLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n", "if", "emitter", ".", "simple_key_context", "&&", "emitter", ".", "scalar_data", ".", "multiline", "{", "style", "=", "yaml_DOUBLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n\n", "if", "style", "==", "yaml_PLAIN_SCALAR_STYLE", "{", "if", "emitter", ".", "flow_level", ">", "0", "&&", "!", "emitter", ".", "scalar_data", ".", "flow_plain_allowed", "||", "emitter", ".", "flow_level", "==", "0", "&&", "!", "emitter", ".", "scalar_data", ".", "block_plain_allowed", "{", "style", "=", "yaml_SINGLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n", "if", "len", "(", "emitter", ".", "scalar_data", ".", "value", ")", "==", "0", "&&", "(", "emitter", ".", "flow_level", ">", "0", "||", "emitter", ".", "simple_key_context", ")", "{", "style", "=", "yaml_SINGLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n", "if", "no_tag", "&&", "!", "event", ".", "implicit", "{", "style", "=", "yaml_SINGLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n", "}", "\n", "if", "style", "==", "yaml_SINGLE_QUOTED_SCALAR_STYLE", "{", "if", "!", "emitter", ".", "scalar_data", ".", "single_quoted_allowed", "{", "style", "=", "yaml_DOUBLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n", "}", "\n", "if", "style", "==", "yaml_LITERAL_SCALAR_STYLE", "||", "style", "==", "yaml_FOLDED_SCALAR_STYLE", "{", "if", "!", "emitter", ".", "scalar_data", ".", "block_allowed", "||", "emitter", ".", "flow_level", ">", "0", "||", "emitter", ".", "simple_key_context", "{", "style", "=", "yaml_DOUBLE_QUOTED_SCALAR_STYLE", "\n", "}", "\n", "}", "\n\n", "if", "no_tag", "&&", "!", "event", ".", "quoted_implicit", "&&", "style", "!=", "yaml_PLAIN_SCALAR_STYLE", "{", "emitter", ".", "tag_data", ".", "handle", "=", "[", "]", "byte", "{", "'!'", "}", "\n", "}", "\n", "emitter", ".", "scalar_data", ".", "style", "=", "style", "\n", "return", "true", "\n", "}" ]

[ "Determine", "an", "acceptable", "scalar", "style", "." ]

[ "func", "yaml_emitter_process_anchor", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "if", "emitter", ".", "anchor_data", ".", "anchor", "==", "nil", "{", "return", "true", "\n", "}", "\n", "c", ":=", "[", "]", "byte", "{", "'&'", "}", "\n", "if", "emitter", ".", "anchor_data", ".", "alias", "{", "c", "[", "0", "]", "=", "'*'", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "c", ",", "true", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "return", "yaml_emitter_write_anchor", "(", "emitter", ",", "emitter", ".", "anchor_data", ".", "anchor", ")", "\n", "}" ]

[ "Write", "an", "achor", "." ]

[ "func", "yaml_emitter_process_tag", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "if", "len", "(", "emitter", ".", "tag_data", ".", "handle", ")", "==", "0", "&&", "len", "(", "emitter", ".", "tag_data", ".", "suffix", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "if", "len", "(", "emitter", ".", "tag_data", ".", "handle", ")", ">", "0", "{", "if", "!", "yaml_emitter_write_tag_handle", "(", "emitter", ",", "emitter", ".", "tag_data", ".", "handle", ")", "{", "return", "false", "\n", "}", "\n", "if", "len", "(", "emitter", ".", "tag_data", ".", "suffix", ")", ">", "0", "{", "if", "!", "yaml_emitter_write_tag_content", "(", "emitter", ",", "emitter", ".", "tag_data", ".", "suffix", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "else", "{", "// [Go] Allocate these slices elsewhere.", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "(", "\"", "\"", ")", ",", "true", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_write_tag_content", "(", "emitter", ",", "emitter", ".", "tag_data", ".", "suffix", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "if", "!", "yaml_emitter_write_indicator", "(", "emitter", ",", "[", "]", "byte", "{", "'>'", "}", ",", "false", ",", "false", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Write", "a", "tag", "." ]

[ "func", "yaml_emitter_process_scalar", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "switch", "emitter", ".", "scalar_data", ".", "style", "{", "case", "yaml_PLAIN_SCALAR_STYLE", ":", "return", "yaml_emitter_write_plain_scalar", "(", "emitter", ",", "emitter", ".", "scalar_data", ".", "value", ",", "!", "emitter", ".", "simple_key_context", ")", "\n\n", "case", "yaml_SINGLE_QUOTED_SCALAR_STYLE", ":", "return", "yaml_emitter_write_single_quoted_scalar", "(", "emitter", ",", "emitter", ".", "scalar_data", ".", "value", ",", "!", "emitter", ".", "simple_key_context", ")", "\n\n", "case", "yaml_DOUBLE_QUOTED_SCALAR_STYLE", ":", "return", "yaml_emitter_write_double_quoted_scalar", "(", "emitter", ",", "emitter", ".", "scalar_data", ".", "value", ",", "!", "emitter", ".", "simple_key_context", ")", "\n\n", "case", "yaml_LITERAL_SCALAR_STYLE", ":", "return", "yaml_emitter_write_literal_scalar", "(", "emitter", ",", "emitter", ".", "scalar_data", ".", "value", ")", "\n\n", "case", "yaml_FOLDED_SCALAR_STYLE", ":", "return", "yaml_emitter_write_folded_scalar", "(", "emitter", ",", "emitter", ".", "scalar_data", ".", "value", ")", "\n", "}", "\n", "panic", "(", "\"", "\"", ")", "\n", "}" ]

[ "Write", "a", "scalar", "." ]

[ "func", "yaml_emitter_analyze_version_directive", "(", "emitter", "*", "yaml_emitter_t", ",", "version_directive", "*", "yaml_version_directive_t", ")", "bool", "{", "if", "version_directive", ".", "major", "!=", "1", "||", "version_directive", ".", "minor", "!=", "1", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Check", "if", "a", "%YAML", "directive", "is", "valid", "." ]

[ "func", "yaml_emitter_analyze_tag_directive", "(", "emitter", "*", "yaml_emitter_t", ",", "tag_directive", "*", "yaml_tag_directive_t", ")", "bool", "{", "handle", ":=", "tag_directive", ".", "handle", "\n", "prefix", ":=", "tag_directive", ".", "prefix", "\n", "if", "len", "(", "handle", ")", "==", "0", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "handle", "[", "0", "]", "!=", "'!'", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "handle", "[", "len", "(", "handle", ")", "-", "1", "]", "!=", "'!'", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n", "for", "i", ":=", "1", ";", "i", "<", "len", "(", "handle", ")", "-", "1", ";", "i", "+=", "width", "(", "handle", "[", "i", "]", ")", "{", "if", "!", "is_alpha", "(", "handle", ",", "i", ")", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "prefix", ")", "==", "0", "{", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Check", "if", "a", "%TAG", "directive", "is", "valid", "." ]

[ "func", "yaml_emitter_analyze_anchor", "(", "emitter", "*", "yaml_emitter_t", ",", "anchor", "[", "]", "byte", ",", "alias", "bool", ")", "bool", "{", "if", "len", "(", "anchor", ")", "==", "0", "{", "problem", ":=", "\"", "\"", "\n", "if", "alias", "{", "problem", "=", "\"", "\"", "\n", "}", "\n", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "problem", ")", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "anchor", ")", ";", "i", "+=", "width", "(", "anchor", "[", "i", "]", ")", "{", "if", "!", "is_alpha", "(", "anchor", ",", "i", ")", "{", "problem", ":=", "\"", "\"", "\n", "if", "alias", "{", "problem", "=", "\"", "\"", "\n", "}", "\n", "return", "yaml_emitter_set_emitter_error", "(", "emitter", ",", "problem", ")", "\n", "}", "\n", "}", "\n", "emitter", ".", "anchor_data", ".", "anchor", "=", "anchor", "\n", "emitter", ".", "anchor_data", ".", "alias", "=", "alias", "\n", "return", "true", "\n", "}" ]

[ "Check", "if", "an", "anchor", "is", "valid", "." ]

[ "func", "yaml_emitter_analyze_event", "(", "emitter", "*", "yaml_emitter_t", ",", "event", "*", "yaml_event_t", ")", "bool", "{", "emitter", ".", "anchor_data", ".", "anchor", "=", "nil", "\n", "emitter", ".", "tag_data", ".", "handle", "=", "nil", "\n", "emitter", ".", "tag_data", ".", "suffix", "=", "nil", "\n", "emitter", ".", "scalar_data", ".", "value", "=", "nil", "\n\n", "switch", "event", ".", "typ", "{", "case", "yaml_ALIAS_EVENT", ":", "if", "!", "yaml_emitter_analyze_anchor", "(", "emitter", ",", "event", ".", "anchor", ",", "true", ")", "{", "return", "false", "\n", "}", "\n\n", "case", "yaml_SCALAR_EVENT", ":", "if", "len", "(", "event", ".", "anchor", ")", ">", "0", "{", "if", "!", "yaml_emitter_analyze_anchor", "(", "emitter", ",", "event", ".", "anchor", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "len", "(", "event", ".", "tag", ")", ">", "0", "&&", "(", "emitter", ".", "canonical", "||", "(", "!", "event", ".", "implicit", "&&", "!", "event", ".", "quoted_implicit", ")", ")", "{", "if", "!", "yaml_emitter_analyze_tag", "(", "emitter", ",", "event", ".", "tag", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "!", "yaml_emitter_analyze_scalar", "(", "emitter", ",", "event", ".", "value", ")", "{", "return", "false", "\n", "}", "\n\n", "case", "yaml_SEQUENCE_START_EVENT", ":", "if", "len", "(", "event", ".", "anchor", ")", ">", "0", "{", "if", "!", "yaml_emitter_analyze_anchor", "(", "emitter", ",", "event", ".", "anchor", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "len", "(", "event", ".", "tag", ")", ">", "0", "&&", "(", "emitter", ".", "canonical", "||", "!", "event", ".", "implicit", ")", "{", "if", "!", "yaml_emitter_analyze_tag", "(", "emitter", ",", "event", ".", "tag", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "case", "yaml_MAPPING_START_EVENT", ":", "if", "len", "(", "event", ".", "anchor", ")", ">", "0", "{", "if", "!", "yaml_emitter_analyze_anchor", "(", "emitter", ",", "event", ".", "anchor", ",", "false", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "if", "len", "(", "event", ".", "tag", ")", ">", "0", "&&", "(", "emitter", ".", "canonical", "||", "!", "event", ".", "implicit", ")", "{", "if", "!", "yaml_emitter_analyze_tag", "(", "emitter", ",", "event", ".", "tag", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Check", "if", "the", "event", "data", "is", "valid", "." ]

[ "func", "yaml_emitter_write_bom", "(", "emitter", "*", "yaml_emitter_t", ")", "bool", "{", "if", "!", "flush", "(", "emitter", ")", "{", "return", "false", "\n", "}", "\n", "pos", ":=", "emitter", ".", "buffer_pos", "\n", "emitter", ".", "buffer", "[", "pos", "+", "0", "]", "=", "'\\xEF'", "\n", "emitter", ".", "buffer", "[", "pos", "+", "1", "]", "=", "'\\xBB'", "\n", "emitter", ".", "buffer", "[", "pos", "+", "2", "]", "=", "'\\xBF'", "\n", "emitter", ".", "buffer_pos", "+=", "3", "\n", "return", "true", "\n", "}" ]

[ "Write", "the", "BOM", "character", "." ]

[ "func", "(", "j", "*", "JSONPath", ")", "evalIdentifier", "(", "input", "[", "]", "reflect", ".", "Value", ",", "node", "*", "IdentifierNode", ")", "(", "[", "]", "reflect", ".", "Value", ",", "error", ")", "{", "results", ":=", "[", "]", "reflect", ".", "Value", "{", "}", "\n", "switch", "node", ".", "Name", "{", "case", "\"", "\"", ":", "j", ".", "stack", "=", "append", "(", "j", ".", "stack", ",", "j", ".", "cur", ")", "\n", "j", ".", "beginRange", "+=", "1", "\n", "results", "=", "input", "\n", "case", "\"", "\"", ":", "if", "j", ".", "endRange", "<", "j", ".", "inRange", "{", "//inside a loop, break the current block", "j", ".", "endRange", "+=", "1", "\n", "break", "\n", "}", "\n", "// the loop is about to end, pop value and continue the following execution", "if", "len", "(", "j", ".", "stack", ")", ">", "0", "{", "j", ".", "cur", ",", "j", ".", "stack", "=", "j", ".", "stack", "[", "len", "(", "j", ".", "stack", ")", "-", "1", "]", ",", "j", ".", "stack", "[", ":", "len", "(", "j", ".", "stack", ")", "-", "1", "]", "\n", "}", "else", "{", "return", "results", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "default", ":", "return", "input", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "node", ".", "Name", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "evalIdentifier", "evaluates", "IdentifierNode" ]

[ "func", "(", "j", "*", "JSONPath", ")", "evalArray", "(", "input", "[", "]", "reflect", ".", "Value", ",", "node", "*", "ArrayNode", ")", "(", "[", "]", "reflect", ".", "Value", ",", "error", ")", "{", "result", ":=", "[", "]", "reflect", ".", "Value", "{", "}", "\n", "for", "_", ",", "value", ":=", "range", "input", "{", "value", ",", "isNil", ":=", "template", ".", "Indirect", "(", "value", ")", "\n", "if", "isNil", "||", "(", "value", ".", "Kind", "(", ")", "!=", "reflect", ".", "Array", "&&", "value", ".", "Kind", "(", ")", "!=", "reflect", ".", "Slice", ")", "{", "return", "input", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "value", ".", "Type", "(", ")", ")", "\n", "}", "\n", "params", ":=", "node", ".", "Params", "\n", "if", "!", "params", "[", "0", "]", ".", "Known", "{", "params", "[", "0", "]", ".", "Value", "=", "0", "\n", "}", "\n", "if", "params", "[", "0", "]", ".", "Value", "<", "0", "{", "params", "[", "0", "]", ".", "Value", "+=", "value", ".", "Len", "(", ")", "\n", "}", "\n", "if", "!", "params", "[", "1", "]", ".", "Known", "{", "params", "[", "1", "]", ".", "Value", "=", "value", ".", "Len", "(", ")", "\n", "}", "\n\n", "if", "params", "[", "1", "]", ".", "Value", "<", "0", "{", "params", "[", "1", "]", ".", "Value", "+=", "value", ".", "Len", "(", ")", "\n", "}", "\n\n", "sliceLength", ":=", "value", ".", "Len", "(", ")", "\n", "if", "params", "[", "1", "]", ".", "Value", "!=", "params", "[", "0", "]", ".", "Value", "{", "// if you're requesting zero elements, allow it through.", "if", "params", "[", "0", "]", ".", "Value", ">=", "sliceLength", "{", "return", "input", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "params", "[", "0", "]", ".", "Value", ",", "sliceLength", ")", "\n", "}", "\n", "if", "params", "[", "1", "]", ".", "Value", ">", "sliceLength", "{", "return", "input", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "params", "[", "1", "]", ".", "Value", "-", "1", ",", "sliceLength", ")", "\n", "}", "\n", "}", "\n\n", "if", "!", "params", "[", "2", "]", ".", "Known", "{", "value", "=", "value", ".", "Slice", "(", "params", "[", "0", "]", ".", "Value", ",", "params", "[", "1", "]", ".", "Value", ")", "\n", "}", "else", "{", "value", "=", "value", ".", "Slice3", "(", "params", "[", "0", "]", ".", "Value", ",", "params", "[", "1", "]", ".", "Value", ",", "params", "[", "2", "]", ".", "Value", ")", "\n", "}", "\n", "for", "i", ":=", "0", ";", "i", "<", "value", ".", "Len", "(", ")", ";", "i", "++", "{", "result", "=", "append", "(", "result", ",", "value", ".", "Index", "(", "i", ")", ")", "\n", "}", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "evalArray", "evaluates", "ArrayNode" ]

[ "func", "(", "j", "*", "JSONPath", ")", "evalField", "(", "input", "[", "]", "reflect", ".", "Value", ",", "node", "*", "FieldNode", ")", "(", "[", "]", "reflect", ".", "Value", ",", "error", ")", "{", "results", ":=", "[", "]", "reflect", ".", "Value", "{", "}", "\n", "// If there's no input, there's no output", "if", "len", "(", "input", ")", "==", "0", "{", "return", "results", ",", "nil", "\n", "}", "\n", "for", "_", ",", "value", ":=", "range", "input", "{", "var", "result", "reflect", ".", "Value", "\n", "value", ",", "isNil", ":=", "template", ".", "Indirect", "(", "value", ")", "\n", "if", "isNil", "{", "continue", "\n", "}", "\n\n", "if", "value", ".", "Kind", "(", ")", "==", "reflect", ".", "Struct", "{", "var", "err", "error", "\n", "if", "result", ",", "err", "=", "j", ".", "findFieldInValue", "(", "&", "value", ",", "node", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "if", "value", ".", "Kind", "(", ")", "==", "reflect", ".", "Map", "{", "result", "=", "value", ".", "MapIndex", "(", "reflect", ".", "ValueOf", "(", "node", ".", "Value", ")", ")", "\n", "}", "\n", "if", "result", ".", "IsValid", "(", ")", "{", "results", "=", "append", "(", "results", ",", "result", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "results", ")", "==", "0", "{", "return", "results", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "node", ".", "Value", ")", "\n", "}", "\n", "return", "results", ",", "nil", "\n", "}" ]

[ "evalField", "evaluates", "filed", "of", "struct", "or", "key", "of", "map", "." ]

[ "func", "NewStreamExecutor", "(", "upgrader", "httpstream", ".", "UpgradeRoundTripper", ",", "fn", "func", "(", "http", ".", "RoundTripper", ")", "http", ".", "RoundTripper", ",", "method", "string", ",", "url", "*", "url", ".", "URL", ")", "(", "StreamExecutor", ",", "error", ")", "{", "var", "rt", "http", ".", "RoundTripper", "=", "upgrader", "\n", "if", "fn", "!=", "nil", "{", "rt", "=", "fn", "(", "rt", ")", "\n", "}", "\n", "return", "&", "streamExecutor", "{", "upgrader", ":", "upgrader", ",", "transport", ":", "rt", ",", "method", ":", "method", ",", "url", ":", "url", ",", "}", ",", "nil", "\n", "}" ]

[ "NewStreamExecutor", "upgrades", "the", "request", "so", "that", "it", "supports", "multiplexed", "bidirectional", "streams", ".", "This", "method", "takes", "a", "stream", "upgrader", "and", "an", "optional", "function", "that", "is", "invoked", "to", "wrap", "the", "round", "tripper", ".", "This", "method", "may", "be", "used", "by", "clients", "that", "are", "lower", "level", "than", "Kubernetes", "clients", "or", "need", "to", "provide", "their", "own", "upgrade", "round", "tripper", "." ]

[ "func", "(", "e", "*", "streamExecutor", ")", "Dial", "(", "protocols", "...", "string", ")", "(", "httpstream", ".", "Connection", ",", "string", ",", "error", ")", "{", "rt", ":=", "transport", ".", "DebugWrappers", "(", "e", ".", "transport", ")", "\n\n", "// TODO the client probably shouldn't be created here, as it doesn't allow", "// flexibility to allow callers to configure it.", "client", ":=", "&", "http", ".", "Client", "{", "Transport", ":", "rt", "}", "\n\n", "req", ",", "err", ":=", "http", ".", "NewRequest", "(", "e", ".", "method", ",", "e", ".", "url", ".", "String", "(", ")", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "for", "i", ":=", "range", "protocols", "{", "req", ".", "Header", ".", "Add", "(", "httpstream", ".", "HeaderProtocolVersion", ",", "protocols", "[", "i", "]", ")", "\n", "}", "\n\n", "resp", ",", "err", ":=", "client", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n\n", "conn", ",", "err", ":=", "e", ".", "upgrader", ".", "NewConnection", "(", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "\"", "\"", ",", "err", "\n", "}", "\n\n", "return", "conn", ",", "resp", ".", "Header", ".", "Get", "(", "httpstream", ".", "HeaderProtocolVersion", ")", ",", "nil", "\n", "}" ]

[ "Dial", "opens", "a", "connection", "to", "a", "remote", "server", "and", "attempts", "to", "negotiate", "a", "SPDY", "connection", ".", "Upon", "success", "it", "returns", "the", "connection", "and", "the", "protocol", "selected", "by", "the", "server", "." ]

[ "func", "(", "t", "*", "transport", ")", "getSessionID", "(", ")", "[", "]", "byte", "{", "if", "t", ".", "sessionID", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "t", ".", "sessionID", "\n", "}" ]

[ "getSessionID", "returns", "the", "ID", "of", "the", "SSH", "connection", ".", "The", "return", "value", "should", "not", "be", "modified", "." ]

[ "func", "(", "t", "*", "transport", ")", "prepareKeyChange", "(", "algs", "*", "algorithms", ",", "kexResult", "*", "kexResult", ")", "error", "{", "if", "t", ".", "sessionID", "==", "nil", "{", "t", ".", "sessionID", "=", "kexResult", ".", "H", "\n", "}", "\n\n", "kexResult", ".", "SessionID", "=", "t", ".", "sessionID", "\n\n", "if", "ciph", ",", "err", ":=", "newPacketCipher", "(", "t", ".", "reader", ".", "dir", ",", "algs", ".", "r", ",", "kexResult", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "t", ".", "reader", ".", "pendingKeyChange", "<-", "ciph", "\n", "}", "\n\n", "if", "ciph", ",", "err", ":=", "newPacketCipher", "(", "t", ".", "writer", ".", "dir", ",", "algs", ".", "w", ",", "kexResult", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "else", "{", "t", ".", "writer", ".", "pendingKeyChange", "<-", "ciph", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "prepareKeyChange", "sets", "up", "key", "material", "for", "a", "keychange", ".", "The", "key", "changes", "in", "both", "directions", "are", "triggered", "by", "reading", "and", "writing", "a", "msgNewKey", "packet", "respectively", "." ]

[ "func", "(", "t", "*", "transport", ")", "readPacket", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "return", "t", ".", "reader", ".", "readPacket", "(", "t", ".", "bufReader", ")", "\n", "}" ]

[ "Read", "and", "decrypt", "next", "packet", "." ]

[ "func", "generateKeys", "(", "d", "direction", ",", "algs", "directionAlgorithms", ",", "kex", "*", "kexResult", ")", "(", "iv", ",", "key", ",", "macKey", "[", "]", "byte", ")", "{", "cipherMode", ":=", "cipherModes", "[", "algs", ".", "Cipher", "]", "\n", "macMode", ":=", "macModes", "[", "algs", ".", "MAC", "]", "\n\n", "iv", "=", "make", "(", "[", "]", "byte", ",", "cipherMode", ".", "ivSize", ")", "\n", "key", "=", "make", "(", "[", "]", "byte", ",", "cipherMode", ".", "keySize", ")", "\n", "macKey", "=", "make", "(", "[", "]", "byte", ",", "macMode", ".", "keySize", ")", "\n\n", "generateKeyMaterial", "(", "iv", ",", "d", ".", "ivTag", ",", "kex", ")", "\n", "generateKeyMaterial", "(", "key", ",", "d", ".", "keyTag", ",", "kex", ")", "\n", "generateKeyMaterial", "(", "macKey", ",", "d", ".", "macKeyTag", ",", "kex", ")", "\n", "return", "\n", "}" ]

[ "generateKeys", "generates", "key", "material", "for", "IV", "MAC", "and", "encryption", "." ]

[ "func", "generateKeyMaterial", "(", "out", ",", "tag", "[", "]", "byte", ",", "r", "*", "kexResult", ")", "{", "var", "digestsSoFar", "[", "]", "byte", "\n\n", "h", ":=", "r", ".", "Hash", ".", "New", "(", ")", "\n", "for", "len", "(", "out", ")", ">", "0", "{", "h", ".", "Reset", "(", ")", "\n", "h", ".", "Write", "(", "r", ".", "K", ")", "\n", "h", ".", "Write", "(", "r", ".", "H", ")", "\n\n", "if", "len", "(", "digestsSoFar", ")", "==", "0", "{", "h", ".", "Write", "(", "tag", ")", "\n", "h", ".", "Write", "(", "r", ".", "SessionID", ")", "\n", "}", "else", "{", "h", ".", "Write", "(", "digestsSoFar", ")", "\n", "}", "\n\n", "digest", ":=", "h", ".", "Sum", "(", "nil", ")", "\n", "n", ":=", "copy", "(", "out", ",", "digest", ")", "\n", "out", "=", "out", "[", "n", ":", "]", "\n", "if", "len", "(", "out", ")", ">", "0", "{", "digestsSoFar", "=", "append", "(", "digestsSoFar", ",", "digest", "...", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "generateKeyMaterial", "fills", "out", "with", "key", "material", "generated", "from", "tag", "K", "H", "and", "sessionId", "as", "specified", "in", "RFC", "4253", "section", "7", ".", "2", "." ]

[ "func", "exchangeVersions", "(", "rw", "io", ".", "ReadWriter", ",", "versionLine", "[", "]", "byte", ")", "(", "them", "[", "]", "byte", ",", "err", "error", ")", "{", "// Contrary to the RFC, we do not ignore lines that don't", "// start with \"SSH-2.0-\" to make the library usable with", "// nonconforming servers.", "for", "_", ",", "c", ":=", "range", "versionLine", "{", "// The spec disallows non US-ASCII chars, and", "// specifically forbids null chars.", "if", "c", "<", "32", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "if", "_", ",", "err", "=", "rw", ".", "Write", "(", "append", "(", "versionLine", ",", "'\\r'", ",", "'\\n'", ")", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n\n", "them", ",", "err", "=", "readVersion", "(", "rw", ")", "\n", "return", "them", ",", "err", "\n", "}" ]

[ "Sends", "and", "receives", "a", "version", "line", ".", "The", "versionLine", "string", "should", "be", "US", "ASCII", "start", "with", "SSH", "-", "2", ".", "0", "-", "and", "should", "not", "include", "a", "newline", ".", "exchangeVersions", "returns", "the", "other", "side", "s", "version", "line", "." ]

[ "func", "readVersion", "(", "r", "io", ".", "Reader", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "versionString", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "64", ")", "\n", "var", "ok", "bool", "\n", "var", "buf", "[", "1", "]", "byte", "\n\n", "for", "len", "(", "versionString", ")", "<", "maxVersionStringBytes", "{", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "r", ",", "buf", "[", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "// The RFC says that the version should be terminated with \\r\\n", "// but several SSH servers actually only send a \\n.", "if", "buf", "[", "0", "]", "==", "'\\n'", "{", "ok", "=", "true", "\n", "break", "\n", "}", "\n\n", "// non ASCII chars are disallowed, but we are lenient,", "// since Go doesn't use null-terminated strings.", "// The RFC allows a comment after a space, however,", "// all of it (version and comments) goes into the", "// session hash.", "versionString", "=", "append", "(", "versionString", ",", "buf", "[", "0", "]", ")", "\n", "}", "\n\n", "if", "!", "ok", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// There might be a '\\r' on the end which we should remove.", "if", "len", "(", "versionString", ")", ">", "0", "&&", "versionString", "[", "len", "(", "versionString", ")", "-", "1", "]", "==", "'\\r'", "{", "versionString", "=", "versionString", "[", ":", "len", "(", "versionString", ")", "-", "1", "]", "\n", "}", "\n", "return", "versionString", ",", "nil", "\n", "}" ]

[ "Read", "version", "string", "as", "specified", "by", "RFC", "4253", "section", "4", ".", "2", "." ]

[ "func", "AppEngineTokenSource", "(", "ctx", "context", ".", "Context", ",", "scope", "...", "string", ")", "oauth2", ".", "TokenSource", "{", "if", "appengineTokenFunc", "==", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "scopes", ":=", "append", "(", "[", "]", "string", "{", "}", ",", "scope", "...", ")", "\n", "sort", ".", "Strings", "(", "scopes", ")", "\n", "return", "&", "appEngineTokenSource", "{", "ctx", ":", "ctx", ",", "scopes", ":", "scopes", ",", "key", ":", "strings", ".", "Join", "(", "scopes", ",", "\"", "\"", ")", ",", "}", "\n", "}" ]

[ "AppEngineTokenSource", "returns", "a", "token", "source", "that", "fetches", "tokens", "issued", "to", "the", "current", "App", "Engine", "application", "s", "service", "account", ".", "If", "you", "are", "implementing", "a", "3", "-", "legged", "OAuth", "2", ".", "0", "flow", "on", "App", "Engine", "that", "involves", "user", "accounts", "see", "oauth2", ".", "Config", "instead", ".", "The", "provided", "context", "must", "have", "come", "from", "appengine", ".", "NewContext", "." ]

[ "func", "GetSysctl", "(", "sysctl", "string", ")", "(", "int", ",", "error", ")", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "path", ".", "Join", "(", "sysctlBase", ",", "sysctl", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n", "val", ",", "err", ":=", "strconv", ".", "Atoi", "(", "strings", ".", "Trim", "(", "string", "(", "data", ")", ",", "\"", "\\n", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n", "return", "val", ",", "nil", "\n", "}" ]

[ "GetSysctl", "returns", "the", "value", "for", "the", "specified", "sysctl", "setting" ]

[ "func", "SetSysctl", "(", "sysctl", "string", ",", "newVal", "int", ")", "error", "{", "return", "ioutil", ".", "WriteFile", "(", "path", ".", "Join", "(", "sysctlBase", ",", "sysctl", ")", ",", "[", "]", "byte", "(", "strconv", ".", "Itoa", "(", "newVal", ")", ")", ",", "0640", ")", "\n", "}" ]

[ "SetSysctl", "modifies", "the", "specified", "sysctl", "flag", "to", "the", "new", "value" ]

[ "func", "MustParse", "(", "str", "string", ")", "Quantity", "{", "q", ",", "err", ":=", "ParseQuantity", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "str", ",", "err", ")", ")", "\n", "}", "\n", "return", "*", "q", "\n", "}" ]

[ "MustParse", "turns", "the", "given", "string", "into", "a", "quantity", "or", "panics", ";", "for", "tests", "or", "others", "cases", "where", "you", "know", "the", "string", "is", "valid", "." ]

[ "func", "(", "q", "*", "Quantity", ")", "String", "(", ")", "string", "{", "number", ",", "suffix", ":=", "q", ".", "Canonicalize", "(", ")", "\n", "return", "number", "+", "string", "(", "suffix", ")", "\n", "}" ]

[ "String", "formats", "the", "Quantity", "as", "a", "string", "." ]

[ "func", "(", "q", "*", "Quantity", ")", "Set", "(", "value", "int64", ")", "{", "if", "q", ".", "Amount", "==", "nil", "{", "q", ".", "Amount", "=", "&", "inf", ".", "Dec", "{", "}", "\n", "}", "\n", "q", ".", "Amount", ".", "SetUnscaled", "(", "value", ")", "\n", "q", ".", "Amount", ".", "SetScale", "(", "0", ")", "\n", "}" ]

[ "Set", "sets", "q", "s", "value", "to", "be", "value", "." ]

[ "func", "parsePubKey", "(", "in", "[", "]", "byte", ",", "algo", "string", ")", "(", "pubKey", "PublicKey", ",", "rest", "[", "]", "byte", ",", "err", "error", ")", "{", "switch", "algo", "{", "case", "KeyAlgoRSA", ":", "return", "parseRSA", "(", "in", ")", "\n", "case", "KeyAlgoDSA", ":", "return", "parseDSA", "(", "in", ")", "\n", "case", "KeyAlgoECDSA256", ",", "KeyAlgoECDSA384", ",", "KeyAlgoECDSA521", ":", "return", "parseECDSA", "(", "in", ")", "\n", "case", "CertAlgoRSAv01", ",", "CertAlgoDSAv01", ",", "CertAlgoECDSA256v01", ",", "CertAlgoECDSA384v01", ",", "CertAlgoECDSA521v01", ":", "cert", ",", "err", ":=", "parseCert", "(", "in", ",", "certToPrivAlgo", "(", "algo", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n", "return", "cert", ",", "nil", ",", "nil", "\n", "}", "\n", "return", "nil", ",", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}" ]

[ "parsePubKey", "parses", "a", "public", "key", "of", "the", "given", "algorithm", ".", "Use", "ParsePublicKey", "for", "keys", "with", "prepended", "algorithm", "." ]

[ "func", "MarshalAuthorizedKey", "(", "key", "PublicKey", ")", "[", "]", "byte", "{", "b", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "b", ".", "WriteString", "(", "key", ".", "Type", "(", ")", ")", "\n", "b", ".", "WriteByte", "(", "' '", ")", "\n", "e", ":=", "base64", ".", "NewEncoder", "(", "base64", ".", "StdEncoding", ",", "b", ")", "\n", "e", ".", "Write", "(", "key", ".", "Marshal", "(", ")", ")", "\n", "e", ".", "Close", "(", ")", "\n", "b", ".", "WriteByte", "(", "'\\n'", ")", "\n", "return", "b", ".", "Bytes", "(", ")", "\n", "}" ]

[ "MarshalAuthorizedKey", "serializes", "key", "for", "inclusion", "in", "an", "OpenSSH", "authorized_keys", "file", ".", "The", "return", "value", "ends", "with", "newline", "." ]

[ "func", "parseRSA", "(", "in", "[", "]", "byte", ")", "(", "out", "PublicKey", ",", "rest", "[", "]", "byte", ",", "err", "error", ")", "{", "var", "w", "struct", "{", "E", "*", "big", ".", "Int", "\n", "N", "*", "big", ".", "Int", "\n", "Rest", "[", "]", "byte", "`ssh:\"rest\"`", "\n", "}", "\n", "if", "err", ":=", "Unmarshal", "(", "in", ",", "&", "w", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "if", "w", ".", "E", ".", "BitLen", "(", ")", ">", "24", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "e", ":=", "w", ".", "E", ".", "Int64", "(", ")", "\n", "if", "e", "<", "3", "||", "e", "&", "1", "==", "0", "{", "return", "nil", ",", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "key", "rsa", ".", "PublicKey", "\n", "key", ".", "E", "=", "int", "(", "e", ")", "\n", "key", ".", "N", "=", "w", ".", "N", "\n", "return", "(", "*", "rsaPublicKey", ")", "(", "&", "key", ")", ",", "w", ".", "Rest", ",", "nil", "\n", "}" ]

[ "parseRSA", "parses", "an", "RSA", "key", "according", "to", "RFC", "4253", "section", "6", ".", "6", "." ]

[ "func", "parseDSA", "(", "in", "[", "]", "byte", ")", "(", "out", "PublicKey", ",", "rest", "[", "]", "byte", ",", "err", "error", ")", "{", "var", "w", "struct", "{", "P", ",", "Q", ",", "G", ",", "Y", "*", "big", ".", "Int", "\n", "Rest", "[", "]", "byte", "`ssh:\"rest\"`", "\n", "}", "\n", "if", "err", ":=", "Unmarshal", "(", "in", ",", "&", "w", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "nil", ",", "err", "\n", "}", "\n\n", "key", ":=", "&", "dsaPublicKey", "{", "Parameters", ":", "dsa", ".", "Parameters", "{", "P", ":", "w", ".", "P", ",", "Q", ":", "w", ".", "Q", ",", "G", ":", "w", ".", "G", ",", "}", ",", "Y", ":", "w", ".", "Y", ",", "}", "\n", "return", "key", ",", "w", ".", "Rest", ",", "nil", "\n", "}" ]

[ "parseDSA", "parses", "an", "DSA", "key", "according", "to", "RFC", "4253", "section", "6", ".", "6", "." ]

[ "func", "ecHash", "(", "curve", "elliptic", ".", "Curve", ")", "crypto", ".", "Hash", "{", "bitSize", ":=", "curve", ".", "Params", "(", ")", ".", "BitSize", "\n", "switch", "{", "case", "bitSize", "<=", "256", ":", "return", "crypto", ".", "SHA256", "\n", "case", "bitSize", "<=", "384", ":", "return", "crypto", ".", "SHA384", "\n", "}", "\n", "return", "crypto", ".", "SHA512", "\n", "}" ]

[ "ecHash", "returns", "the", "hash", "to", "match", "the", "given", "elliptic", "curve", "see", "RFC", "5656", "section", "6", ".", "2", ".", "1" ]

[ "func", "NewSignerFromKey", "(", "k", "interface", "{", "}", ")", "(", "Signer", ",", "error", ")", "{", "var", "sshKey", "Signer", "\n", "switch", "t", ":=", "k", ".", "(", "type", ")", "{", "case", "*", "rsa", ".", "PrivateKey", ":", "sshKey", "=", "&", "rsaPrivateKey", "{", "t", "}", "\n", "case", "*", "dsa", ".", "PrivateKey", ":", "sshKey", "=", "&", "dsaPrivateKey", "{", "t", "}", "\n", "case", "*", "ecdsa", ".", "PrivateKey", ":", "if", "!", "supportedEllipticCurve", "(", "t", ".", "Curve", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "sshKey", "=", "&", "ecdsaPrivateKey", "{", "t", "}", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "return", "sshKey", ",", "nil", "\n", "}" ]

[ "NewSignerFromKey", "takes", "a", "pointer", "to", "rsa", "dsa", "or", "ecdsa", "PrivateKey", "returns", "a", "corresponding", "Signer", "instance", ".", "EC", "keys", "should", "use", "P256", "P384", "or", "P521", "." ]

[ "func", "NewPublicKey", "(", "k", "interface", "{", "}", ")", "(", "PublicKey", ",", "error", ")", "{", "var", "sshKey", "PublicKey", "\n", "switch", "t", ":=", "k", ".", "(", "type", ")", "{", "case", "*", "rsa", ".", "PublicKey", ":", "sshKey", "=", "(", "*", "rsaPublicKey", ")", "(", "t", ")", "\n", "case", "*", "ecdsa", ".", "PublicKey", ":", "if", "!", "supportedEllipticCurve", "(", "t", ".", "Curve", ")", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "sshKey", "=", "(", "*", "ecdsaPublicKey", ")", "(", "t", ")", "\n", "case", "*", "dsa", ".", "PublicKey", ":", "sshKey", "=", "(", "*", "dsaPublicKey", ")", "(", "t", ")", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", "\n", "}", "\n", "return", "sshKey", ",", "nil", "\n", "}" ]

[ "NewPublicKey", "takes", "a", "pointer", "to", "rsa", "dsa", "or", "ecdsa", "PublicKey", "and", "returns", "a", "corresponding", "ssh", "PublicKey", "instance", ".", "EC", "keys", "should", "use", "P256", "P384", "or", "P521", "." ]

[ "func", "ParsePrivateKey", "(", "pemBytes", "[", "]", "byte", ")", "(", "Signer", ",", "error", ")", "{", "key", ",", "err", ":=", "ParseRawPrivateKey", "(", "pemBytes", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "NewSignerFromKey", "(", "key", ")", "\n", "}" ]

[ "ParsePrivateKey", "returns", "a", "Signer", "from", "a", "PEM", "encoded", "private", "key", ".", "It", "supports", "the", "same", "keys", "as", "ParseRawPrivateKey", "." ]

[ "func", "ParseDSAPrivateKey", "(", "der", "[", "]", "byte", ")", "(", "*", "dsa", ".", "PrivateKey", ",", "error", ")", "{", "var", "k", "struct", "{", "Version", "int", "\n", "P", "*", "big", ".", "Int", "\n", "Q", "*", "big", ".", "Int", "\n", "G", "*", "big", ".", "Int", "\n", "Priv", "*", "big", ".", "Int", "\n", "Pub", "*", "big", ".", "Int", "\n", "}", "\n", "rest", ",", "err", ":=", "asn1", ".", "Unmarshal", "(", "der", ",", "&", "k", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "if", "len", "(", "rest", ")", ">", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "dsa", ".", "PrivateKey", "{", "PublicKey", ":", "dsa", ".", "PublicKey", "{", "Parameters", ":", "dsa", ".", "Parameters", "{", "P", ":", "k", ".", "P", ",", "Q", ":", "k", ".", "Q", ",", "G", ":", "k", ".", "G", ",", "}", ",", "Y", ":", "k", ".", "Priv", ",", "}", ",", "X", ":", "k", ".", "Pub", ",", "}", ",", "nil", "\n", "}" ]

[ "ParseDSAPrivateKey", "returns", "a", "DSA", "private", "key", "from", "its", "ASN", ".", "1", "DER", "encoding", "as", "specified", "by", "the", "OpenSSL", "DSA", "man", "page", "." ]

[ "func", "NewProxyServer", "(", "filebase", "string", ",", "apiProxyPrefix", "string", ",", "staticPrefix", "string", ",", "filter", "*", "FilterServer", ",", "cfg", "*", "client", ".", "Config", ")", "(", "*", "ProxyServer", ",", "error", ")", "{", "host", ":=", "cfg", ".", "Host", "\n", "if", "!", "strings", ".", "HasSuffix", "(", "host", ",", "\"", "\"", ")", "{", "host", "=", "host", "+", "\"", "\"", "\n", "}", "\n", "target", ",", "err", ":=", "url", ".", "Parse", "(", "host", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "proxy", ":=", "newProxy", "(", "target", ")", "\n", "if", "proxy", ".", "Transport", ",", "err", "=", "client", ".", "TransportFor", "(", "cfg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "proxyServer", ":=", "http", ".", "Handler", "(", "proxy", ")", "\n", "if", "filter", "!=", "nil", "{", "proxyServer", "=", "filter", ".", "HandlerFor", "(", "proxyServer", ")", "\n", "}", "\n\n", "if", "!", "strings", ".", "HasPrefix", "(", "apiProxyPrefix", ",", "\"", "\"", ")", "{", "proxyServer", "=", "stripLeaveSlash", "(", "apiProxyPrefix", ",", "proxyServer", ")", "\n", "}", "\n\n", "mux", ":=", "http", ".", "NewServeMux", "(", ")", "\n", "mux", ".", "Handle", "(", "apiProxyPrefix", ",", "proxyServer", ")", "\n", "if", "filebase", "!=", "\"", "\"", "{", "// Require user to explicitly request this behavior rather than", "// serving their working directory by default.", "mux", ".", "Handle", "(", "staticPrefix", ",", "newFileHandler", "(", "staticPrefix", ",", "filebase", ")", ")", "\n", "}", "\n", "return", "&", "ProxyServer", "{", "handler", ":", "mux", "}", ",", "nil", "\n", "}" ]

[ "NewProxyServer", "creates", "and", "installs", "a", "new", "ProxyServer", ".", "It", "automatically", "registers", "the", "created", "ProxyServer", "to", "http", ".", "DefaultServeMux", ".", "filter", "if", "non", "-", "nil", "protects", "requests", "to", "the", "api", "only", "." ]

[ "func", "(", "s", "*", "ProxyServer", ")", "ListenUnix", "(", "path", "string", ")", "(", "net", ".", "Listener", ",", "error", ")", "{", "// Remove any socket, stale or not, but fall through for other files", "fi", ",", "err", ":=", "os", ".", "Stat", "(", "path", ")", "\n", "if", "err", "==", "nil", "&&", "(", "fi", ".", "Mode", "(", ")", "&", "os", ".", "ModeSocket", ")", "!=", "0", "{", "os", ".", "Remove", "(", "path", ")", "\n", "}", "\n", "// Default to only user accessible socket, caller can open up later if desired", "oldmask", ",", "_", ":=", "util", ".", "Umask", "(", "0077", ")", "\n", "l", ",", "err", ":=", "net", ".", "Listen", "(", "\"", "\"", ",", "path", ")", "\n", "util", ".", "Umask", "(", "oldmask", ")", "\n", "return", "l", ",", "err", "\n", "}" ]

[ "ListenUnix", "does", "net", ".", "Listen", "for", "a", "unix", "socket" ]

[ "func", "(", "s", "*", "ProxyServer", ")", "ServeOnListener", "(", "l", "net", ".", "Listener", ")", "error", "{", "server", ":=", "http", ".", "Server", "{", "Handler", ":", "s", ".", "handler", ",", "}", "\n", "return", "server", ".", "Serve", "(", "l", ")", "\n", "}" ]

[ "Serve", "starts", "the", "server", "using", "given", "listener", "loops", "forever", "." ]

[ "func", "ExecuteTemplate", "(", "w", "io", ".", "Writer", ",", "templateText", "string", ",", "data", "interface", "{", "}", ")", "error", "{", "t", ":=", "template", ".", "New", "(", "\"", "\"", ")", "\n", "t", ".", "Funcs", "(", "template", ".", "FuncMap", "{", "\"", "\"", ":", "strings", ".", "TrimSpace", ",", "\"", "\"", ":", "wrap", ",", "}", ")", "\n", "template", ".", "Must", "(", "t", ".", "Parse", "(", "templateText", ")", ")", "\n", "return", "t", ".", "Execute", "(", "w", ",", "data", ")", "\n", "}" ]

[ "ExecuteTemplate", "executes", "templateText", "with", "data", "and", "output", "written", "to", "w", "." ]

[ "func", "NewScheme", "(", ")", "*", "Scheme", "{", "s", ":=", "&", "Scheme", "{", "gvkToType", ":", "map", "[", "unversioned", ".", "GroupVersionKind", "]", "reflect", ".", "Type", "{", "}", ",", "typeToGVK", ":", "map", "[", "reflect", ".", "Type", "]", "[", "]", "unversioned", ".", "GroupVersionKind", "{", "}", ",", "converter", ":", "NewConverter", "(", ")", ",", "cloner", ":", "NewCloner", "(", ")", ",", "// TODO remove this hard coded list. As step one, hardcode it here so this pull doesn't become even bigger", "InternalVersions", ":", "map", "[", "string", "]", "unversioned", ".", "GroupVersion", "{", "\"", "\"", ":", "{", "}", ",", "\"", "\"", ":", "{", "Group", ":", "\"", "\"", "}", ",", "\"", "\"", ":", "{", "Group", ":", "\"", "\"", "}", ",", "\"", "\"", ":", "{", "Group", ":", "\"", "\"", "}", ",", "}", ",", "MetaFactory", ":", "DefaultMetaFactory", ",", "}", "\n", "s", ".", "converter", ".", "nameFunc", "=", "s", ".", "nameFunc", "\n", "return", "s", "\n", "}" ]

[ "NewScheme", "manufactures", "a", "new", "scheme", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "AddGeneratedConversionFuncs", "(", "conversionFuncs", "...", "interface", "{", "}", ")", "error", "{", "for", "_", ",", "f", ":=", "range", "conversionFuncs", "{", "if", "err", ":=", "s", ".", "converter", ".", "RegisterGeneratedConversionFunc", "(", "f", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Similar", "to", "AddConversionFuncs", "but", "registers", "conversion", "functions", "that", "were", "automatically", "generated", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "AddDeepCopyFuncs", "(", "deepCopyFuncs", "...", "interface", "{", "}", ")", "error", "{", "for", "_", ",", "f", ":=", "range", "deepCopyFuncs", "{", "if", "err", ":=", "s", ".", "cloner", ".", "RegisterDeepCopyFunc", "(", "f", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "AddDeepCopyFuncs", "adds", "functions", "to", "the", "list", "of", "deep", "copy", "functions", ".", "Note", "that", "to", "copy", "sub", "-", "objects", "you", "can", "use", "the", "conversion", ".", "Cloner", "object", "that", "will", "be", "passed", "to", "your", "deep", "-", "copy", "function", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "AddGeneratedDeepCopyFuncs", "(", "deepCopyFuncs", "...", "interface", "{", "}", ")", "error", "{", "for", "_", ",", "f", ":=", "range", "deepCopyFuncs", "{", "if", "err", ":=", "s", ".", "cloner", ".", "RegisterGeneratedDeepCopyFunc", "(", "f", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Similar", "to", "AddDeepCopyFuncs", "but", "registers", "deep", "copy", "functions", "that", "were", "automatically", "generated", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "AddStructFieldConversion", "(", "srcFieldType", "interface", "{", "}", ",", "srcFieldName", "string", ",", "destFieldType", "interface", "{", "}", ",", "destFieldName", "string", ")", "error", "{", "return", "s", ".", "converter", ".", "SetStructFieldCopy", "(", "srcFieldType", ",", "srcFieldName", ",", "destFieldType", ",", "destFieldName", ")", "\n", "}" ]

[ "AddStructFieldConversion", "allows", "you", "to", "specify", "a", "mechanical", "copy", "for", "a", "moved", "or", "renamed", "struct", "field", "without", "writing", "an", "entire", "conversion", "function", ".", "See", "the", "comment", "in", "Converter", ".", "SetStructFieldCopy", "for", "parameter", "details", ".", "Call", "as", "many", "times", "as", "needed", "even", "on", "the", "same", "fields", "." ]

[ "func", "(", "t", "*", "Transport", ")", "rewriteResponse", "(", "req", "*", "http", ".", "Request", ",", "resp", "*", "http", ".", "Response", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "origBody", ":=", "resp", ".", "Body", "\n", "defer", "origBody", ".", "Close", "(", ")", "\n\n", "newContent", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "var", "reader", "io", ".", "Reader", "=", "origBody", "\n", "var", "writer", "io", ".", "Writer", "=", "newContent", "\n", "encoding", ":=", "resp", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "\n", "switch", "encoding", "{", "case", "\"", "\"", ":", "var", "err", "error", "\n", "reader", ",", "err", "=", "gzip", ".", "NewReader", "(", "reader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "gzw", ":=", "gzip", ".", "NewWriter", "(", "writer", ")", "\n", "defer", "gzw", ".", "Close", "(", ")", "\n", "writer", "=", "gzw", "\n", "// TODO: support flate, other encodings.", "case", "\"", "\"", ":", "// This is fine", "default", ":", "// Some encoding we don't understand-- don't try to parse this", "glog", ".", "Errorf", "(", "\"", "\"", ",", "encoding", ")", "\n", "return", "resp", ",", "nil", "\n", "}", "\n\n", "urlRewriter", ":=", "func", "(", "targetUrl", "string", ")", "string", "{", "return", "t", ".", "rewriteURL", "(", "targetUrl", ",", "req", ".", "URL", ")", "\n", "}", "\n", "err", ":=", "rewriteHTML", "(", "reader", ",", "writer", ",", "urlRewriter", ")", "\n", "if", "err", "!=", "nil", "{", "glog", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "resp", ",", "err", "\n", "}", "\n\n", "resp", ".", "Body", "=", "ioutil", ".", "NopCloser", "(", "newContent", ")", "\n", "// Update header node with new content-length", "// TODO: Remove any hash/signature headers here?", "resp", ".", "Header", ".", "Del", "(", "\"", "\"", ")", "\n", "resp", ".", "ContentLength", "=", "int64", "(", "newContent", ".", "Len", "(", ")", ")", "\n\n", "return", "resp", ",", "err", "\n", "}" ]

[ "rewriteResponse", "modifies", "an", "HTML", "response", "by", "updating", "absolute", "links", "referring", "to", "the", "original", "host", "to", "instead", "refer", "to", "the", "proxy", "transport", "." ]

[ "func", "(", "k", "*", "Key", ")", "String", "(", ")", "string", "{", "s", ":=", "string", "(", "k", ".", "Format", ")", "+", "\"", "\"", "+", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "k", ".", "Blob", ")", "\n\n", "if", "k", ".", "Comment", "!=", "\"", "\"", "{", "s", "+=", "\"", "\"", "+", "k", ".", "Comment", "\n", "}", "\n\n", "return", "s", "\n", "}" ]

[ "String", "returns", "the", "storage", "form", "of", "an", "agent", "key", "with", "the", "format", "base64", "encoded", "serialized", "key", "and", "the", "comment", "if", "it", "is", "not", "empty", "." ]

[ "func", "(", "k", "*", "Key", ")", "Verify", "(", "data", "[", "]", "byte", ",", "sig", "*", "ssh", ".", "Signature", ")", "error", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Verify", "satisfies", "the", "ssh", ".", "PublicKey", "interface", "but", "is", "not", "implemented", "for", "agent", "keys", "." ]

[ "func", "(", "c", "*", "client", ")", "call", "(", "req", "[", "]", "byte", ")", "(", "reply", "interface", "{", "}", ",", "err", "error", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "msg", ":=", "make", "(", "[", "]", "byte", ",", "4", "+", "len", "(", "req", ")", ")", "\n", "binary", ".", "BigEndian", ".", "PutUint32", "(", "msg", ",", "uint32", "(", "len", "(", "req", ")", ")", ")", "\n", "copy", "(", "msg", "[", "4", ":", "]", ",", "req", ")", "\n", "if", "_", ",", "err", "=", "c", ".", "conn", ".", "Write", "(", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "clientErr", "(", "err", ")", "\n", "}", "\n\n", "var", "respSizeBuf", "[", "4", "]", "byte", "\n", "if", "_", ",", "err", "=", "io", ".", "ReadFull", "(", "c", ".", "conn", ",", "respSizeBuf", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "clientErr", "(", "err", ")", "\n", "}", "\n", "respSize", ":=", "binary", ".", "BigEndian", ".", "Uint32", "(", "respSizeBuf", "[", ":", "]", ")", "\n", "if", "respSize", ">", "maxAgentResponseBytes", "{", "return", "nil", ",", "clientErr", "(", "err", ")", "\n", "}", "\n\n", "buf", ":=", "make", "(", "[", "]", "byte", ",", "respSize", ")", "\n", "if", "_", ",", "err", "=", "io", ".", "ReadFull", "(", "c", ".", "conn", ",", "buf", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "clientErr", "(", "err", ")", "\n", "}", "\n", "reply", ",", "err", "=", "unmarshal", "(", "buf", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "clientErr", "(", "err", ")", "\n", "}", "\n", "return", "reply", ",", "err", "\n", "}" ]

[ "call", "sends", "an", "RPC", "to", "the", "agent", ".", "On", "success", "the", "reply", "is", "unmarshaled", "into", "reply", "and", "replyType", "is", "set", "to", "the", "first", "byte", "of", "the", "reply", "which", "contains", "the", "type", "of", "the", "message", "." ]

[ "func", "unmarshal", "(", "packet", "[", "]", "byte", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "if", "len", "(", "packet", ")", "<", "1", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "msg", "interface", "{", "}", "\n", "switch", "packet", "[", "0", "]", "{", "case", "agentFailure", ":", "return", "new", "(", "failureAgentMsg", ")", ",", "nil", "\n", "case", "agentSuccess", ":", "return", "new", "(", "successAgentMsg", ")", ",", "nil", "\n", "case", "agentIdentitiesAnswer", ":", "msg", "=", "new", "(", "identitiesAnswerAgentMsg", ")", "\n", "case", "agentSignResponse", ":", "msg", "=", "new", "(", "signResponseAgentMsg", ")", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "packet", "[", "0", "]", ")", "\n", "}", "\n", "if", "err", ":=", "ssh", ".", "Unmarshal", "(", "packet", ",", "msg", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "msg", ",", "nil", "\n", "}" ]

[ "unmarshal", "parses", "an", "agent", "message", "in", "packet", "returning", "the", "parsed", "form", "and", "the", "message", "type", "of", "packet", "." ]

[ "func", "(", "c", "*", "client", ")", "insertKey", "(", "s", "interface", "{", "}", ",", "comment", "string", ")", "error", "{", "var", "req", "[", "]", "byte", "\n", "switch", "k", ":=", "s", ".", "(", "type", ")", "{", "case", "*", "rsa", ".", "PrivateKey", ":", "if", "len", "(", "k", ".", "Primes", ")", "!=", "2", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "len", "(", "k", ".", "Primes", ")", ")", "\n", "}", "\n", "k", ".", "Precompute", "(", ")", "\n", "req", "=", "ssh", ".", "Marshal", "(", "rsaKeyMsg", "{", "Type", ":", "ssh", ".", "KeyAlgoRSA", ",", "N", ":", "k", ".", "N", ",", "E", ":", "big", ".", "NewInt", "(", "int64", "(", "k", ".", "E", ")", ")", ",", "D", ":", "k", ".", "D", ",", "Iqmp", ":", "k", ".", "Precomputed", ".", "Qinv", ",", "P", ":", "k", ".", "Primes", "[", "0", "]", ",", "Q", ":", "k", ".", "Primes", "[", "1", "]", ",", "Comments", ":", "comment", ",", "}", ")", "\n", "case", "*", "dsa", ".", "PrivateKey", ":", "req", "=", "ssh", ".", "Marshal", "(", "dsaKeyMsg", "{", "Type", ":", "ssh", ".", "KeyAlgoDSA", ",", "P", ":", "k", ".", "P", ",", "Q", ":", "k", ".", "Q", ",", "G", ":", "k", ".", "G", ",", "Y", ":", "k", ".", "Y", ",", "X", ":", "k", ".", "X", ",", "Comments", ":", "comment", ",", "}", ")", "\n", "case", "*", "ecdsa", ".", "PrivateKey", ":", "nistID", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ".", "Params", "(", ")", ".", "BitSize", ")", "\n", "req", "=", "ssh", ".", "Marshal", "(", "ecdsaKeyMsg", "{", "Type", ":", "\"", "\"", "+", "nistID", ",", "Curve", ":", "nistID", ",", "KeyBytes", ":", "elliptic", ".", "Marshal", "(", "k", ".", "Curve", ",", "k", ".", "X", ",", "k", ".", "Y", ")", ",", "D", ":", "k", ".", "D", ",", "Comments", ":", "comment", ",", "}", ")", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "resp", ",", "err", ":=", "c", ".", "call", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "resp", ".", "(", "*", "successAgentMsg", ")", ";", "ok", "{", "return", "nil", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Insert", "adds", "a", "private", "key", "to", "the", "agent", "." ]

[ "func", "(", "c", "*", "client", ")", "Signers", "(", ")", "(", "[", "]", "ssh", ".", "Signer", ",", "error", ")", "{", "keys", ",", "err", ":=", "c", ".", "List", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "result", "[", "]", "ssh", ".", "Signer", "\n", "for", "_", ",", "k", ":=", "range", "keys", "{", "result", "=", "append", "(", "result", ",", "&", "agentKeyringSigner", "{", "c", ",", "k", "}", ")", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Signers", "provides", "a", "callback", "for", "client", "authentication", "." ]

[ "func", "yaml_parser_set_reader_error", "(", "parser", "*", "yaml_parser_t", ",", "problem", "string", ",", "offset", "int", ",", "value", "int", ")", "bool", "{", "parser", ".", "error", "=", "yaml_READER_ERROR", "\n", "parser", ".", "problem", "=", "problem", "\n", "parser", ".", "problem_offset", "=", "offset", "\n", "parser", ".", "problem_value", "=", "value", "\n", "return", "false", "\n", "}" ]

[ "Set", "the", "reader", "error", "and", "return", "0", "." ]

[ "func", "yaml_parser_determine_encoding", "(", "parser", "*", "yaml_parser_t", ")", "bool", "{", "// Ensure that we had enough bytes in the raw buffer.", "for", "!", "parser", ".", "eof", "&&", "len", "(", "parser", ".", "raw_buffer", ")", "-", "parser", ".", "raw_buffer_pos", "<", "3", "{", "if", "!", "yaml_parser_update_raw_buffer", "(", "parser", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "// Determine the encoding.", "buf", ":=", "parser", ".", "raw_buffer", "\n", "pos", ":=", "parser", ".", "raw_buffer_pos", "\n", "avail", ":=", "len", "(", "buf", ")", "-", "pos", "\n", "if", "avail", ">=", "2", "&&", "buf", "[", "pos", "]", "==", "bom_UTF16LE", "[", "0", "]", "&&", "buf", "[", "pos", "+", "1", "]", "==", "bom_UTF16LE", "[", "1", "]", "{", "parser", ".", "encoding", "=", "yaml_UTF16LE_ENCODING", "\n", "parser", ".", "raw_buffer_pos", "+=", "2", "\n", "parser", ".", "offset", "+=", "2", "\n", "}", "else", "if", "avail", ">=", "2", "&&", "buf", "[", "pos", "]", "==", "bom_UTF16BE", "[", "0", "]", "&&", "buf", "[", "pos", "+", "1", "]", "==", "bom_UTF16BE", "[", "1", "]", "{", "parser", ".", "encoding", "=", "yaml_UTF16BE_ENCODING", "\n", "parser", ".", "raw_buffer_pos", "+=", "2", "\n", "parser", ".", "offset", "+=", "2", "\n", "}", "else", "if", "avail", ">=", "3", "&&", "buf", "[", "pos", "]", "==", "bom_UTF8", "[", "0", "]", "&&", "buf", "[", "pos", "+", "1", "]", "==", "bom_UTF8", "[", "1", "]", "&&", "buf", "[", "pos", "+", "2", "]", "==", "bom_UTF8", "[", "2", "]", "{", "parser", ".", "encoding", "=", "yaml_UTF8_ENCODING", "\n", "parser", ".", "raw_buffer_pos", "+=", "3", "\n", "parser", ".", "offset", "+=", "3", "\n", "}", "else", "{", "parser", ".", "encoding", "=", "yaml_UTF8_ENCODING", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Determine", "the", "input", "stream", "encoding", "by", "checking", "the", "BOM", "symbol", ".", "If", "no", "BOM", "is", "found", "the", "UTF", "-", "8", "encoding", "is", "assumed", ".", "Return", "1", "on", "success", "0", "on", "failure", "." ]

[ "func", "yaml_parser_update_raw_buffer", "(", "parser", "*", "yaml_parser_t", ")", "bool", "{", "size_read", ":=", "0", "\n\n", "// Return if the raw buffer is full.", "if", "parser", ".", "raw_buffer_pos", "==", "0", "&&", "len", "(", "parser", ".", "raw_buffer", ")", "==", "cap", "(", "parser", ".", "raw_buffer", ")", "{", "return", "true", "\n", "}", "\n\n", "// Return on EOF.", "if", "parser", ".", "eof", "{", "return", "true", "\n", "}", "\n\n", "// Move the remaining bytes in the raw buffer to the beginning.", "if", "parser", ".", "raw_buffer_pos", ">", "0", "&&", "parser", ".", "raw_buffer_pos", "<", "len", "(", "parser", ".", "raw_buffer", ")", "{", "copy", "(", "parser", ".", "raw_buffer", ",", "parser", ".", "raw_buffer", "[", "parser", ".", "raw_buffer_pos", ":", "]", ")", "\n", "}", "\n", "parser", ".", "raw_buffer", "=", "parser", ".", "raw_buffer", "[", ":", "len", "(", "parser", ".", "raw_buffer", ")", "-", "parser", ".", "raw_buffer_pos", "]", "\n", "parser", ".", "raw_buffer_pos", "=", "0", "\n\n", "// Call the read handler to fill the buffer.", "size_read", ",", "err", ":=", "parser", ".", "read_handler", "(", "parser", ",", "parser", ".", "raw_buffer", "[", "len", "(", "parser", ".", "raw_buffer", ")", ":", "cap", "(", "parser", ".", "raw_buffer", ")", "]", ")", "\n", "parser", ".", "raw_buffer", "=", "parser", ".", "raw_buffer", "[", ":", "len", "(", "parser", ".", "raw_buffer", ")", "+", "size_read", "]", "\n", "if", "err", "==", "io", ".", "EOF", "{", "parser", ".", "eof", "=", "true", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "yaml_parser_set_reader_error", "(", "parser", ",", "\"", "\"", "+", "err", ".", "Error", "(", ")", ",", "parser", ".", "offset", ",", "-", "1", ")", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "Update", "the", "raw", "buffer", "." ]

[ "func", "yaml_parser_initialize", "(", "parser", "*", "yaml_parser_t", ")", "bool", "{", "*", "parser", "=", "yaml_parser_t", "{", "raw_buffer", ":", "make", "(", "[", "]", "byte", ",", "0", ",", "input_raw_buffer_size", ")", ",", "buffer", ":", "make", "(", "[", "]", "byte", ",", "0", ",", "input_buffer_size", ")", ",", "}", "\n", "return", "true", "\n", "}" ]

[ "Create", "a", "new", "parser", "object", "." ]

[ "func", "yaml_string_read_handler", "(", "parser", "*", "yaml_parser_t", ",", "buffer", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "if", "parser", ".", "input_pos", "==", "len", "(", "parser", ".", "input", ")", "{", "return", "0", ",", "io", ".", "EOF", "\n", "}", "\n", "n", "=", "copy", "(", "buffer", ",", "parser", ".", "input", "[", "parser", ".", "input_pos", ":", "]", ")", "\n", "parser", ".", "input_pos", "+=", "n", "\n", "return", "n", ",", "nil", "\n", "}" ]

[ "String", "read", "handler", "." ]

[ "func", "yaml_file_read_handler", "(", "parser", "*", "yaml_parser_t", ",", "buffer", "[", "]", "byte", ")", "(", "n", "int", ",", "err", "error", ")", "{", "return", "parser", ".", "input_file", ".", "Read", "(", "buffer", ")", "\n", "}" ]

[ "File", "read", "handler", "." ]

[ "func", "yaml_parser_set_input_string", "(", "parser", "*", "yaml_parser_t", ",", "input", "[", "]", "byte", ")", "{", "if", "parser", ".", "read_handler", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "parser", ".", "read_handler", "=", "yaml_string_read_handler", "\n", "parser", ".", "input", "=", "input", "\n", "parser", ".", "input_pos", "=", "0", "\n", "}" ]

[ "Set", "a", "string", "input", "." ]

[ "func", "yaml_parser_set_input_file", "(", "parser", "*", "yaml_parser_t", ",", "file", "*", "os", ".", "File", ")", "{", "if", "parser", ".", "read_handler", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "parser", ".", "read_handler", "=", "yaml_file_read_handler", "\n", "parser", ".", "input_file", "=", "file", "\n", "}" ]

[ "Set", "a", "file", "input", "." ]

[ "func", "yaml_parser_set_encoding", "(", "parser", "*", "yaml_parser_t", ",", "encoding", "yaml_encoding_t", ")", "{", "if", "parser", ".", "encoding", "!=", "yaml_ANY_ENCODING", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "parser", ".", "encoding", "=", "encoding", "\n", "}" ]

[ "Set", "the", "source", "encoding", "." ]

[ "func", "yaml_string_write_handler", "(", "emitter", "*", "yaml_emitter_t", ",", "buffer", "[", "]", "byte", ")", "error", "{", "*", "emitter", ".", "output_buffer", "=", "append", "(", "*", "emitter", ".", "output_buffer", ",", "buffer", "...", ")", "\n", "return", "nil", "\n", "}" ]

[ "String", "write", "handler", "." ]

[ "func", "yaml_file_write_handler", "(", "emitter", "*", "yaml_emitter_t", ",", "buffer", "[", "]", "byte", ")", "error", "{", "_", ",", "err", ":=", "emitter", ".", "output_file", ".", "Write", "(", "buffer", ")", "\n", "return", "err", "\n", "}" ]

[ "File", "write", "handler", "." ]

[ "func", "yaml_emitter_set_output_string", "(", "emitter", "*", "yaml_emitter_t", ",", "output_buffer", "*", "[", "]", "byte", ")", "{", "if", "emitter", ".", "write_handler", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "emitter", ".", "write_handler", "=", "yaml_string_write_handler", "\n", "emitter", ".", "output_buffer", "=", "output_buffer", "\n", "}" ]

[ "Set", "a", "string", "output", "." ]

[ "func", "yaml_emitter_set_output_file", "(", "emitter", "*", "yaml_emitter_t", ",", "file", "io", ".", "Writer", ")", "{", "if", "emitter", ".", "write_handler", "!=", "nil", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "emitter", ".", "write_handler", "=", "yaml_file_write_handler", "\n", "emitter", ".", "output_file", "=", "file", "\n", "}" ]

[ "Set", "a", "file", "output", "." ]

[ "func", "yaml_emitter_set_encoding", "(", "emitter", "*", "yaml_emitter_t", ",", "encoding", "yaml_encoding_t", ")", "{", "if", "emitter", ".", "encoding", "!=", "yaml_ANY_ENCODING", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "emitter", ".", "encoding", "=", "encoding", "\n", "}" ]

[ "Set", "the", "output", "encoding", "." ]

[ "func", "yaml_emitter_set_width", "(", "emitter", "*", "yaml_emitter_t", ",", "width", "int", ")", "{", "if", "width", "<", "0", "{", "width", "=", "-", "1", "\n", "}", "\n", "emitter", ".", "best_width", "=", "width", "\n", "}" ]

[ "Set", "the", "preferred", "line", "width", "." ]

[ "func", "yaml_document_start_event_initialize", "(", "event", "*", "yaml_event_t", ",", "version_directive", "*", "yaml_version_directive_t", ",", "tag_directives", "[", "]", "yaml_tag_directive_t", ",", "implicit", "bool", ")", "bool", "{", "*", "event", "=", "yaml_event_t", "{", "typ", ":", "yaml_DOCUMENT_START_EVENT", ",", "version_directive", ":", "version_directive", ",", "tag_directives", ":", "tag_directives", ",", "implicit", ":", "implicit", ",", "}", "\n", "return", "true", "\n", "}" ]

[ "Create", "DOCUMENT", "-", "START", "." ]

[ "func", "yaml_document_end_event_initialize", "(", "event", "*", "yaml_event_t", ",", "implicit", "bool", ")", "bool", "{", "*", "event", "=", "yaml_event_t", "{", "typ", ":", "yaml_DOCUMENT_END_EVENT", ",", "implicit", ":", "implicit", ",", "}", "\n", "return", "true", "\n", "}" ]

[ "Create", "DOCUMENT", "-", "END", "." ]

[ "func", "yaml_sequence_start_event_initialize", "(", "event", "*", "yaml_event_t", ",", "anchor", ",", "tag", "[", "]", "byte", ",", "implicit", "bool", ",", "style", "yaml_sequence_style_t", ")", "bool", "{", "*", "event", "=", "yaml_event_t", "{", "typ", ":", "yaml_SEQUENCE_START_EVENT", ",", "anchor", ":", "anchor", ",", "tag", ":", "tag", ",", "implicit", ":", "implicit", ",", "style", ":", "yaml_style_t", "(", "style", ")", ",", "}", "\n", "return", "true", "\n", "}" ]

[ "Create", "SEQUENCE", "-", "START", "." ]

[ "func", "RunInResourceContainer", "(", "containerName", "string", ")", "error", "{", "manager", ":=", "fs", ".", "Manager", "{", "Cgroups", ":", "&", "configs", ".", "Cgroup", "{", "Name", ":", "containerName", ",", "AllowAllDevices", ":", "true", ",", "}", ",", "}", "\n\n", "return", "manager", ".", "Apply", "(", "os", ".", "Getpid", "(", ")", ")", "\n", "}" ]

[ "Creates", "resource", "-", "only", "containerName", "if", "it", "does", "not", "already", "exist", "and", "moves", "the", "current", "process", "to", "it", ".", "containerName", "must", "be", "an", "absolute", "container", "name", "." ]

[ "func", "(", "h", "*", "DeploymentHistoryViewer", ")", "History", "(", "namespace", ",", "name", "string", ")", "(", "HistoryInfo", ",", "error", ")", "{", "historyInfo", ":=", "HistoryInfo", "{", "RevisionToTemplate", ":", "make", "(", "map", "[", "int64", "]", "*", "api", ".", "PodTemplateSpec", ")", ",", "}", "\n", "deployment", ",", "err", ":=", "h", ".", "c", ".", "Extensions", "(", ")", ".", "Deployments", "(", "namespace", ")", ".", "Get", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "historyInfo", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "_", ",", "allOldRSs", ",", "err", ":=", "deploymentutil", ".", "GetOldReplicaSets", "(", "*", "deployment", ",", "h", ".", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "historyInfo", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "newRS", ",", "err", ":=", "deploymentutil", ".", "GetNewReplicaSet", "(", "*", "deployment", ",", "h", ".", "c", ")", "\n", "if", "err", "!=", "nil", "{", "return", "historyInfo", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ",", "err", ")", "\n", "}", "\n", "allRSs", ":=", "append", "(", "allOldRSs", ",", "newRS", ")", "\n", "for", "_", ",", "rs", ":=", "range", "allRSs", "{", "v", ",", "err", ":=", "deploymentutil", ".", "Revision", "(", "rs", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "historyInfo", ".", "RevisionToTemplate", "[", "v", "]", "=", "rs", ".", "Spec", ".", "Template", "\n", "changeCause", ":=", "getChangeCause", "(", "rs", ")", "\n", "if", "historyInfo", ".", "RevisionToTemplate", "[", "v", "]", ".", "Annotations", "==", "nil", "{", "historyInfo", ".", "RevisionToTemplate", "[", "v", "]", ".", "Annotations", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "}", "\n", "historyInfo", ".", "RevisionToTemplate", "[", "v", "]", ".", "Annotations", "[", "ChangeCauseAnnotation", "]", "=", "changeCause", "\n", "}", "\n", "return", "historyInfo", ",", "nil", "\n", "}" ]

[ "History", "returns", "a", "revision", "-", "to", "-", "replicaset", "map", "as", "the", "revision", "history", "of", "a", "deployment" ]

[ "func", "PrintRolloutHistory", "(", "historyInfo", "HistoryInfo", ",", "resource", ",", "name", "string", ")", "(", "string", ",", "error", ")", "{", "if", "len", "(", "historyInfo", ".", "RevisionToTemplate", ")", "==", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "resource", ",", "name", ")", ",", "nil", "\n", "}", "\n", "// Sort the revisionToChangeCause map by revision", "var", "revisions", "[", "]", "string", "\n", "for", "k", ":=", "range", "historyInfo", ".", "RevisionToTemplate", "{", "revisions", "=", "append", "(", "revisions", ",", "strconv", ".", "FormatInt", "(", "k", ",", "10", ")", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "revisions", ")", "\n\n", "return", "tabbedString", "(", "func", "(", "out", "io", ".", "Writer", ")", "error", "{", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\n", "\"", ",", "resource", ",", "name", ")", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ")", "\n", "errs", ":=", "[", "]", "error", "{", "}", "\n", "for", "_", ",", "r", ":=", "range", "revisions", "{", "// Find the change-cause of revision r", "r64", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "r", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "errs", "=", "append", "(", "errs", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "changeCause", ":=", "historyInfo", ".", "RevisionToTemplate", "[", "r64", "]", ".", "Annotations", "[", "ChangeCauseAnnotation", "]", "\n", "if", "len", "(", "changeCause", ")", "==", "0", "{", "changeCause", "=", "\"", "\"", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "out", ",", "\"", "\\t", "\\n", "\"", ",", "r", ",", "changeCause", ")", "\n", "}", "\n", "return", "errors", ".", "NewAggregate", "(", "errs", ")", "\n", "}", ")", "\n", "}" ]

[ "PrintRolloutHistory", "prints", "a", "formatted", "table", "of", "the", "input", "revision", "history", "of", "the", "deployment" ]

[ "func", "Parse", "(", "allTestData", "map", "[", "string", "]", "TestToBuildData", ",", "testInfo", "*", "TestInfo", ",", "job", "string", ",", "source", "Downloader", ")", "error", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "*", "datasource", ",", "job", ")", "\n\n", "grabbedLastBuild", ":=", "allGrabbedLastBuild", "[", "job", "]", "\n\n", "lastBuildNumber", ",", "err", ":=", "source", ".", "GetLastestBuildNumber", "(", "job", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "job", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "lastBuildNumber", ",", "job", ")", "\n\n", "startBuildNumber", ":=", "int", "(", "math", ".", "Max", "(", "math", ".", "Max", "(", "float64", "(", "lastBuildNumber", "-", "*", "builds", ")", ",", "0", ")", ",", "float64", "(", "grabbedLastBuild", ")", ")", ")", "+", "1", "\n", "for", "buildNumber", ":=", "lastBuildNumber", ";", "buildNumber", ">=", "startBuildNumber", ";", "buildNumber", "--", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "buildNumber", ",", "job", ")", "\n", "if", "err", ":=", "populateDataForOneBuild", "(", "allTestData", "[", "job", "]", ",", "testInfo", ",", "job", ",", "buildNumber", ",", "source", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "allGrabbedLastBuild", "[", "job", "]", "=", "lastBuildNumber", "\n", "return", "nil", "\n", "}" ]

[ "Parse", "fetches", "data", "from", "the", "source", "and", "populates", "allTestData", "and", "testInfo", "for", "the", "given", "test", "job", "." ]

[ "func", "populateMetadata", "(", "testInfo", "*", "TestInfo", ",", "testTime", "*", "TestTime", ",", "labels", "map", "[", "string", "]", "string", ")", "error", "{", "test", ":=", "labels", "[", "\"", "\"", "]", "\n\n", "// Populate testInfo with the test description.", "testInfo", ".", "Info", "[", "test", "]", "=", "labels", "[", "\"", "\"", "]", "\n\n", "// Populate testTime with the test end timestamp.", "t", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "labels", "[", "\"", "\"", "]", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "labels", "[", "\"", "\"", "]", ",", "err", ")", "\n", "}", "\n", "timestamp", ":=", "time", ".", "Unix", "(", "t", ",", "0", ")", ".", "UTC", "(", ")", ".", "Format", "(", "testLogTimeFormat", ")", "\n", "testTime", ".", "Add", "(", "test", ",", "labels", "[", "\"", "\"", "]", ",", "timestamp", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "populateMetadata", "populates", "the", "test", "description", "in", "testInfo", "and", "the", "test", "end", "timestamp", "in", "testTime", "using", "the", "information", "in", "the", "given", "labels", "." ]

[ "func", "populateTimeSeriesData", "(", "testData", "TestToBuildData", ",", "testInfo", "*", "TestInfo", ",", "testTime", "*", "TestTime", ",", "job", ",", "build", "string", ",", "source", "Downloader", ")", "error", "{", "contents", ",", "err", ":=", "getDataFromFiles", "(", "job", ",", "build", ",", "\"", "\"", ",", "source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "data", ":=", "range", "contents", "{", "// Decode the data into obj.", "var", "obj", "nodeperftype", ".", "NodeTimeSeries", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "data", ",", "&", "obj", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\\n", "\\n", "\"", ",", "err", ",", "string", "(", "data", ")", ")", "\n", "}", "\n\n", "// Ignore the metrics with unsupported versions.", "if", "obj", ".", "Version", "!=", "supportedMetricVersion", "{", "continue", "\n", "}", "\n\n", "// Populate the metadata (testInfo and testTime) with the", "// version and labels in the perf data.", "if", "err", ":=", "populateMetadata", "(", "testInfo", ",", "testTime", ",", "obj", ".", "Labels", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Populate the result (testData) with the perf data.", "node", ":=", "formatNodeName", "(", "obj", ".", "Labels", ",", "job", ")", "\n", "test", ":=", "obj", ".", "Labels", "[", "\"", "\"", "]", "\n", "data", ":=", "testData", ".", "GetDataPerBuild", "(", "job", ",", "build", ",", "test", ",", "node", ")", "\n", "data", ".", "Series", "=", "append", "(", "data", ".", "Series", ",", "obj", ")", "\n\n", "removeStaledBuilds", "(", "testData", ",", "job", ",", "test", ",", "node", ",", "build", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "populateTimeSeriesData", "populates", "the", "time", "series", "data", "in", "testData", "and", "the", "metadata", "in", "testInfo", "and", "testTime", "for", "the", "given", "test", "job", "at", "the", "given", "build", "using", "the", "data", "fetched", "from", "source", "." ]

[ "func", "populateDataForOneBuild", "(", "testData", "TestToBuildData", ",", "testInfo", "*", "TestInfo", ",", "job", "string", ",", "buildNumber", "int", ",", "source", "Downloader", ")", "error", "{", "build", ":=", "strconv", ".", "Itoa", "(", "buildNumber", ")", "\n", "testTime", ":=", "TestTime", "{", "}", "\n", "if", "err", ":=", "populatePerformanceData", "(", "testData", ",", "testInfo", ",", "&", "testTime", ",", "job", ",", "build", ",", "source", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "populateTimeSeriesData", "(", "testData", ",", "testInfo", ",", "&", "testTime", ",", "job", ",", "build", ",", "source", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "*", "tracing", "{", "// Grab and convert tracing data from Kubelet log into time series data format.", "tracingData", ":=", "ParseKubeletLog", "(", "source", ",", "job", ",", "buildNumber", ",", "testTime", ")", "\n", "// Parse time series data.", "parseTracingData", "(", "bufio", ".", "NewScanner", "(", "strings", ".", "NewReader", "(", "tracingData", ")", ")", ",", "job", ",", "buildNumber", ",", "testData", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "populateDataForOneBuild", "populates", "perf", "and", "time", "series", "data", "in", "testData", "and", "test", "description", "in", "testinfo", "for", "the", "given", "test", "job", "at", "given", "buildNumber", "with", "the", "data", "fetched", "from", "source", "." ]

[ "func", "parseTracingData", "(", "scanner", "*", "bufio", ".", "Scanner", ",", "job", "string", ",", "buildNumber", "int", ",", "result", "TestToBuildData", ")", "{", "buff", ":=", "&", "bytes", ".", "Buffer", "{", "}", "\n", "state", ":=", "scanning", "\n", "build", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "buildNumber", ")", "\n\n", "for", "scanner", ".", "Scan", "(", ")", "{", "line", ":=", "scanner", ".", "Text", "(", ")", "\n", "if", "state", "==", "processing", "{", "if", "strings", ".", "Contains", "(", "line", ",", "timeSeriesEnd", ")", "{", "state", "=", "scanning", "\n\n", "obj", ":=", "nodeperftype", ".", "NodeTimeSeries", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "buff", ".", "Bytes", "(", ")", ",", "&", "obj", ")", ";", "err", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\\n", "\"", ",", "buildNumber", ",", "err", ",", "buff", ".", "String", "(", ")", ")", "\n", "continue", "\n", "}", "\n\n", "// We do not check the obj's version against", "// the supportedMetricVersion because this data", "// is generated internally by", "// ParseKubeletLog().", "testName", ",", "nodeName", ":=", "obj", ".", "Labels", "[", "\"", "\"", "]", ",", "formatNodeName", "(", "obj", ".", "Labels", ",", "job", ")", "\n\n", "if", "_", ",", "found", ":=", "result", "[", "testName", "]", ";", "!", "found", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "testName", ")", "\n", "continue", "\n", "}", "\n", "if", "_", ",", "found", ":=", "result", "[", "testName", "]", ".", "Data", "[", "nodeName", "]", ";", "!", "found", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "nodeName", ")", "\n", "continue", "\n", "}", "\n", "if", "_", ",", "found", ":=", "result", "[", "testName", "]", ".", "Data", "[", "nodeName", "]", "[", "build", "]", ";", "!", "found", "{", "fmt", ".", "Fprintf", "(", "os", ".", "Stderr", ",", "\"", "\\n", "\"", ",", "build", ")", "\n", "continue", "\n", "}", "\n\n", "data", ":=", "result", ".", "GetDataPerBuild", "(", "job", ",", "build", ",", "testName", ",", "nodeName", ")", "\n", "data", ".", "Series", "=", "append", "(", "data", ".", "Series", ",", "obj", ")", "\n\n", "buff", ".", "Reset", "(", ")", "\n", "}", "\n", "}", "\n", "if", "strings", ".", "Contains", "(", "line", ",", "timeSeriesTag", ")", "{", "state", "=", "processing", "\n", "line", "=", "line", "[", "strings", ".", "Index", "(", "line", ",", "\"", "\"", ")", ":", "]", "\n", "}", "\n", "if", "state", "==", "processing", "{", "buff", ".", "WriteString", "(", "line", "+", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "parseTracingData", "extracts", "and", "converts", "tracing", "data", "into", "time", "series", "data", "." ]

[ "func", "(", "c", "*", "replicaSets", ")", "Get", "(", "name", "string", ")", "(", "result", "*", "extensions", ".", "ReplicaSet", ",", "err", "error", ")", "{", "result", "=", "&", "extensions", ".", "ReplicaSet", "{", "}", "\n", "err", "=", "c", ".", "client", ".", "Get", "(", ")", ".", "Namespace", "(", "c", ".", "ns", ")", ".", "Resource", "(", "\"", "\"", ")", ".", "Name", "(", "name", ")", ".", "Do", "(", ")", ".", "Into", "(", "result", ")", "\n", "return", "\n", "}" ]

[ "Get", "returns", "information", "about", "a", "particular", "ReplicaSet", "." ]

[ "func", "NewCloner", "(", ")", "*", "Cloner", "{", "c", ":=", "&", "Cloner", "{", "deepCopyFuncs", ":", "map", "[", "reflect", ".", "Type", "]", "reflect", ".", "Value", "{", "}", ",", "generatedDeepCopyFuncs", ":", "map", "[", "reflect", ".", "Type", "]", "reflect", ".", "Value", "{", "}", ",", "}", "\n", "if", "err", ":=", "c", ".", "RegisterDeepCopyFunc", "(", "byteSliceDeepCopy", ")", ";", "err", "!=", "nil", "{", "// If one of the deep-copy functions is malformed, detect it immediately.", "panic", "(", "err", ")", "\n", "}", "\n", "return", "c", "\n", "}" ]

[ "NewCloner", "creates", "a", "new", "Cloner", "object", "." ]

[ "func", "byteSliceDeepCopy", "(", "in", "[", "]", "byte", ",", "out", "*", "[", "]", "byte", ",", "c", "*", "Cloner", ")", "error", "{", "if", "in", "!=", "nil", "{", "*", "out", "=", "make", "(", "[", "]", "byte", ",", "len", "(", "in", ")", ")", "\n", "copy", "(", "*", "out", ",", "in", ")", "\n", "}", "else", "{", "*", "out", "=", "nil", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Prevent", "recursing", "into", "every", "byte", "..." ]

[ "func", "verifyDeepCopyFunctionSignature", "(", "ft", "reflect", ".", "Type", ")", "error", "{", "if", "ft", ".", "Kind", "(", ")", "!=", "reflect", ".", "Func", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ft", ")", "\n", "}", "\n", "if", "ft", ".", "NumIn", "(", ")", "!=", "3", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ft", ")", "\n", "}", "\n", "if", "ft", ".", "NumOut", "(", ")", "!=", "1", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ft", ")", "\n", "}", "\n", "if", "ft", ".", "In", "(", "1", ")", ".", "Kind", "(", ")", "!=", "reflect", ".", "Ptr", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ft", ")", "\n", "}", "\n", "if", "ft", ".", "In", "(", "1", ")", ".", "Elem", "(", ")", "!=", "ft", ".", "In", "(", "0", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ft", ")", "\n", "}", "\n", "var", "forClonerType", "Cloner", "\n", "if", "expected", ":=", "reflect", ".", "TypeOf", "(", "&", "forClonerType", ")", ";", "ft", ".", "In", "(", "2", ")", "!=", "expected", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "expected", ",", "ft", ".", "In", "(", "2", ")", ")", "\n", "}", "\n", "var", "forErrorType", "error", "\n", "// This convolution is necessary, otherwise TypeOf picks up on the fact", "// that forErrorType is nil", "errorType", ":=", "reflect", ".", "TypeOf", "(", "&", "forErrorType", ")", ".", "Elem", "(", ")", "\n", "if", "ft", ".", "Out", "(", "0", ")", "!=", "errorType", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ft", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Verifies", "whether", "a", "deep", "-", "copy", "function", "has", "a", "correct", "signature", "." ]

[ "func", "(", "c", "*", "Cloner", ")", "RegisterGeneratedDeepCopyFunc", "(", "deepCopyFunc", "interface", "{", "}", ")", "error", "{", "fv", ":=", "reflect", ".", "ValueOf", "(", "deepCopyFunc", ")", "\n", "ft", ":=", "fv", ".", "Type", "(", ")", "\n", "if", "err", ":=", "verifyDeepCopyFunctionSignature", "(", "ft", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "c", ".", "generatedDeepCopyFuncs", "[", "ft", ".", "In", "(", "0", ")", "]", "=", "fv", "\n", "return", "nil", "\n", "}" ]

[ "Similar", "to", "RegisterDeepCopyFunc", "but", "registers", "deep", "copy", "function", "that", "were", "automatically", "generated", "." ]

[ "func", "(", "c", "*", "Cloner", ")", "DeepCopy", "(", "in", "interface", "{", "}", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "// Can be invalid if we run DeepCopy(X) where X is a nil interface type.", "// For example, we get an invalid value when someone tries to deep-copy", "// a nil labels.Selector.", "// This does not occur if X is nil and is a pointer to a concrete type.", "if", "in", "==", "nil", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "inValue", ":=", "reflect", ".", "ValueOf", "(", "in", ")", "\n", "outValue", ",", "err", ":=", "c", ".", "deepCopy", "(", "inValue", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "outValue", ".", "Interface", "(", ")", ",", "nil", "\n", "}" ]

[ "DeepCopy", "will", "perform", "a", "deep", "copy", "of", "a", "given", "object", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "KnownTypes", "(", "gv", "unversioned", ".", "GroupVersion", ")", "map", "[", "string", "]", "reflect", ".", "Type", "{", "types", ":=", "make", "(", "map", "[", "string", "]", "reflect", ".", "Type", ")", "\n", "for", "gvk", ",", "t", ":=", "range", "s", ".", "gvkToType", "{", "if", "gv", "!=", "gvk", ".", "GroupVersion", "(", ")", "{", "continue", "\n", "}", "\n\n", "types", "[", "gvk", ".", "Kind", "]", "=", "t", "\n", "}", "\n", "return", "types", "\n", "}" ]

[ "KnownTypes", "returns", "the", "types", "known", "for", "the", "given", "version", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "ObjectKind", "(", "obj", "Object", ")", "(", "unversioned", ".", "GroupVersionKind", ",", "error", ")", "{", "gvks", ",", "err", ":=", "s", ".", "ObjectKinds", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "unversioned", ".", "GroupVersionKind", "{", "}", ",", "err", "\n", "}", "\n", "return", "gvks", "[", "0", "]", ",", "nil", "\n", "}" ]

[ "ObjectKind", "returns", "the", "group", "version", "kind", "of", "the", "go", "object", "or", "an", "error", "if", "it", "s", "not", "a", "pointer", "or", "is", "unregistered", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "ObjectKinds", "(", "obj", "Object", ")", "(", "[", "]", "unversioned", ".", "GroupVersionKind", ",", "error", ")", "{", "v", ",", "err", ":=", "conversion", ".", "EnforcePtr", "(", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "t", ":=", "v", ".", "Type", "(", ")", "\n\n", "gvks", ",", "ok", ":=", "s", ".", "typeToGVK", "[", "t", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "&", "notRegisteredErr", "{", "t", ":", "t", "}", "\n", "}", "\n\n", "return", "gvks", ",", "nil", "\n", "}" ]

[ "ObjectKinds", "returns", "all", "possible", "group", "version", "kind", "of", "the", "go", "object", "or", "an", "error", "if", "it", "s", "not", "a", "pointer", "or", "is", "unregistered", "." ]

[ "func", "(", "s", "*", "Scheme", ")", "Copy", "(", "src", "Object", ")", "(", "Object", ",", "error", ")", "{", "dst", ",", "err", ":=", "s", ".", "DeepCopy", "(", "src", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "dst", ".", "(", "Object", ")", ",", "nil", "\n", "}" ]

[ "Copy", "does", "a", "deep", "copy", "of", "an", "API", "object", "." ]