const Options& options)

: descriptor_(descriptor),

classname_(ClassName(descriptor, false)),

options_(options) {

map<string, string> vars;

vars["classname"] = classname_;

vars["short_name"] = descriptor_->name();

//printer->Print(vars, "enum $classname$ {\n");

printer->Print(vars, "$classname$ = {\n");

printer->Indent();

const EnumValueDescriptor* min_value = descriptor_->value(0);

const EnumValueDescriptor* max_value = descriptor_->value(0);

for (int i = 0; i < descriptor_->value_count(); i++) {

vars["name"] = descriptor_->value(i)->name();

vars["number"] = SimpleItoa(descriptor_->value(i)->number());

vars["prefix"] = (descriptor_->containing_type() == NULL) ?

"" : classname_ + "_";

if (i > 0) printer->Print(",\n");

printer->Print(vars, "$prefix$$name$ = $number$");

if (descriptor_->value(i)->number() < min_value->number()) {

min_value = descriptor_->value(i);

}

if (descriptor_->value(i)->number() > max_value->number()) {

max_value = descriptor_->value(i);

}

}

printer->Outdent();

printer->Print("\n};\n\n\n");

vars["min_name"] = min_value->name();

vars["max_name"] = max_value->name();

if (HasDescriptorMethods(descriptor_->file())) {

printer->Print(

"template <>\n"

"inline const EnumDescriptor* GetEnumDescriptor< $classname$>() {\n"

" return $classname$_descriptor();\n"

"}\n",

"classname", ClassName(descriptor_, true));

}

map<string, string> vars;

io::Printer* printer, int index) {

map<string, string> vars;

vars["classname"] = classname_;

vars["index"] = SimpleItoa(index);

if (descriptor_->containing_type() == NULL) {

printer->Print(vars,

"$classname$_descriptor_ = file->enum_type($index$);\n");

} else {

vars["parent"] = ClassName(descriptor_->containing_type(), false);

printer->Print(vars,

"$classname$_descriptor_ = $parent$_descriptor_->enum_type($index$);\n");

}

//map<string, string> vars;

//vars["classname"] = classname_;

//if (HasDescriptorMethods(descriptor_->file())) {

// printer->Print(vars,

// "const ::google::protobuf::EnumDescriptor* $classname$_descriptor() {\n"

// " protobuf_AssignDescriptorsOnce();\n"

// " return $classname$_descriptor_;\n"

// "}\n");

//}

//printer->Print(vars,

// "bool $classname$_IsValid(int value) {\n"

// " switch(value) {\n");

//// Multiple values may have the same number. Make sure we only cover

//// each number once by first constructing a set containing all valid

//// numbers, then printing a case statement for each element.

//set<int> numbers;

//for (int j = 0; j < descriptor_->value_count(); j++) {

// const EnumValueDescriptor* value = descriptor_->value(j);

// numbers.insert(value->number());

//}

//for (set<int>::iterator iter = numbers.begin();

// iter != numbers.end(); ++iter) {

// printer->Print(

// " case $number$:\n",

// "number", SimpleItoa(*iter));

//}

//printer->Print(vars,

// " return true;\n"

// " default:\n"

// " return false;\n"

// " }\n"

// "}\n"

// "\n");

//if (descriptor_->containing_type() != NULL) {

// // We need to "define" the static constants which were declared in the

// // header, to give the linker a place to put them. Or at least the C++

// // standard says we have to. MSVC actually insists tha we do _not_ define

// // them again in the .cc file.

// printer->Print("#ifndef _MSC_VER\n");

// vars["parent"] = ClassName(descriptor_->containing_type(), false);

// vars["nested_name"] = descriptor_->name();

// for (int i = 0; i < descriptor_->value_count(); i++) {

// vars["value"] = descriptor_->value(i)->name();

// printer->Print(vars,

// "const $classname$ $parent$::$value$;\n");

// }

// printer->Print(vars,

// "const $classname$ $parent$::$nested_name$_MIN;\n"

// "const $classname$ $parent$::$nested_name$_MAX;\n"

// "const int $parent$::$nested_name$_ARRAYSIZE;\n");

// printer->Print("#endif // _MSC_VER\n");

//}