void
PrinterFile::Implementation::print_object (const FrameModel& value,
const Library& library,
const FrameModel *const original,
int indent)
{
const symbol element = value.type_name ();
if (!library.check (element))
{
out << "<unknown " << element << ">";
return;
}
// Check original.
if (original && original->type_name () == element)
{
out << "original";
// Check if we added something over the original.
if (value.subset (metalib, *original))
return;
out << " ";
print_alist (value, original, indent + 9, false);
return;
}
const FrameModel& element_frame = library.model (element);
// Check if we added something over the library.
if (value.subset (metalib, element_frame))
{
// We didn't.
print_symbol (element);
return;
}
// Library element with additional attributes.
print_symbol (element);
out << " ";
print_alist (value, &element_frame,
indent + 1 + element.name ().length ()
// Buglet: Wrong indentation for elements with strange chars.
+ (is_identifier (element.name ()) ? 0 : 2),
false);
}
void
PrinterFile::Implementation
/**/::print_parameterization (const symbol library_name, const symbol name,
bool print_description)
{
Library& library = metalib.library (library_name);
const FrameModel& frame = library.model (name);
if (frame.type_name () != name)
{
daisy_bug ("Asking for '" + name + "' getting '" + frame.type_name ()
+ "' (base " + frame.base_name () + ")");
}
const FrameModel& root = library.model ("component");
out << "(def" << library_name << " ";
print_symbol (name);
out << " ";
const symbol super = frame.base_name ();
if (super != Attribute::None ())
{
print_symbol (super);
if (!library.check (super))
{
out << " ;; unknown superclass\n ";
print_alist (frame, &root, 2, true);
}
else
print_alist (frame, &library.model (super), 2, true);
}
else
{
out << "<unknown>\n ";
print_alist (frame, &root, 2, true);
}
out << ")\n";
}
void
PrinterFile::Implementation::print_entry (const Frame& frame,
const Frame *const super,
const symbol key,
int indent, bool need_wrapper)
{
daisy_assert (frame.check (key));
Attribute::type type = frame.lookup (key);
const bool do_wrap
= (need_wrapper && is_complex (frame, super, key));
if (do_wrap)
{
out << "(";
indent++;
}
if (frame.type_size (key) == Attribute::Singleton)
{
switch (type)
{
case Attribute::Number:
out << frame.number (key);
print_dimension (frame, key, frame.dimension (key));
break;
case Attribute::Submodel:
if (super && super->check (key))
print_alist (frame.submodel (key), &super->submodel (key),
indent, false);
else
print_alist (frame.submodel (key), frame.default_frame (key).get (),
indent, false);
break;
case Attribute::PLF:
print_plf (frame.plf (key), indent);
break;
case Attribute::Boolean:
print_bool (frame.flag (key));
break;
case Attribute::String:
print_symbol (frame.name (key));
break;
case Attribute::Integer:
out << frame.integer (key);
break;
case Attribute::Model:
{
const symbol component = frame.component (key);
const Library& library = metalib.library (component);
if (super && super->check (key))
print_object (frame.model (key), library,
&super->model (key), indent);
else
print_object (frame.model (key), library,
NULL, indent);
}
break;
case Attribute::Scalar:
case Attribute::Reference:
case Attribute::Error:
default:
out << "<Unknown: " << Attribute::type_name (frame.lookup (key))
<< ">";
}
}
else
{
switch (type)
{
case Attribute::Number:
{
const std::vector<double>& value = frame.number_sequence (key);
for (unsigned int i = 0; i < value.size (); i++)
{
if (i > 0)
out << " ";
out << value[i];
}
print_dimension (frame, key, frame.dimension (key));
}
break;
case Attribute::Submodel:
{
const FrameSubmodel& other = *frame.default_frame (key);
const std::vector<boost::shared_ptr<const FrameSubmodel>/**/>& value
= frame.submodel_sequence (key);
for (unsigned int i = 0; i < value.size (); i++)
{
if (i > 0)
out << "\n" << std::string (indent, ' ');
out << "(";
print_alist (*value[i], &other, indent + 1, false);
out << ")";
}
}
break;
case Attribute::PLF:
{
const std::vector<boost::shared_ptr<const PLF>/**/>& value
= frame.plf_sequence (key);
for (unsigned int i = 0; i < value.size (); i++)
{
if (i > 0)
out << "\n" << std::string (indent, ' ');
out << "(";
print_plf (*value[i], indent + 1);
out << ")";
}
}
break;
case Attribute::Boolean:
{
const std::vector<bool>& value = frame.flag_sequence (key);
for (unsigned int i = 0; i < value.size (); i++)
{
if (i > 0)
out << " ";
print_bool (value[i]);
}
}
break;
case Attribute::String:
{
const std::vector<symbol>& value
= frame.name_sequence (key);
for (unsigned int i = 0; i < value.size (); i++)
{
if (i > 0)
out << " ";
print_symbol (value[i]);
}
}
break;
case Attribute::Integer:
{
const std::vector<int>& value = frame.integer_sequence (key);
for (unsigned int i = 0; i < value.size (); i++)
{
if (i > 0)
out << " ";
out << value[i];
}
}
break;
case Attribute::Model:
{
const symbol component = frame.component (key);
const Library& library = metalib.library (component);
const std::vector<boost::shared_ptr<const FrameModel>/**/>& value
= frame.model_sequence (key);
// We really should check original value.
const std::vector<boost::shared_ptr<const FrameModel>/**/>& super_value
= (super && super->check (key))
? super->model_sequence (key)
: std::vector<boost::shared_ptr<const FrameModel>/**/> ();
for (unsigned int i = 0; i < value.size (); i++)
{
const FrameModel& me = *value[i];
const FrameModel* other = super_value.size () > i
? super_value[i].get ()
: NULL;
if (i > 0)
out << "\n" << std::string (indent, ' ');
if ((other && me.subset (metalib, *other))
|| !is_complex_object (me, library))
print_object (me, library, other, indent);
else
{
out << "(";
print_object (me, library, other, indent + 1);
out << ")";
}
}
}
break;
case Attribute::Scalar:
case Attribute::Reference:
case Attribute::Error:
default:
out << "<" << Attribute::type_name (frame.lookup (key))
<< " sequence>";
}
}
if (do_wrap)
{
out << ")";
}
}
void
OutputWorldBuilder::add_groundmap(const std::string& type, const AList& alist)
{
std::cout << "OutputWorldBuilder: groundmap: " << type << std::endl;
print_alist(alist);
}
void
OutputWorldBuilder::add_building(const std::string& type, const AList& alist)
{
std::cout << "OutputWorldBuilder: building: " << type << std::endl;
print_alist(alist);
}
void
OutputWorldBuilder::add_brush(const std::string& resname, const AList& alist)
{
std::cout << "OutputWorldBuilder: brush: " << resname << std::endl;
print_alist(alist);
}
void
OutputWorldBuilder::add_object(const std::string& type, const AList& alist)
{
std::cout << "OutputWorldBuilder: gameobj: " << type << std::endl;
print_alist(alist);
}
