TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-02 09:52:27 -04:00
Code Issues Packages Projects Releases Wiki Activity

XFileDataObjectTemplate -> XFileDataNodeTemplate

Browse Source
This commit is contained in:
David Rose 2004-10-08 19:25:41 +00:00
parent 5ca8fa4a23
commit 09fc928fb8
14 changed files with 89 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pandatool/src/xfile/Sources.pp
View File

@ -23,9 +23,9 @@
xFileDataObjectArray.cxx xFileDataObjectArray.I xFileDataObjectArray.h \ xFileDataObjectArray.cxx xFileDataObjectArray.I xFileDataObjectArray.h \
xFileDataObjectDouble.cxx xFileDataObjectDouble.I xFileDataObjectDouble.h \ xFileDataObjectDouble.cxx xFileDataObjectDouble.I xFileDataObjectDouble.h \
xFileDataObjectInteger.cxx xFileDataObjectInteger.I xFileDataObjectInteger.h \ xFileDataObjectInteger.cxx xFileDataObjectInteger.I xFileDataObjectInteger.h \
xFileDataObjectTemplate.cxx xFileDataObjectTemplate.I xFileDataObjectTemplate.h \
xFileDataNode.cxx xFileDataNode.I xFileDataNode.h \ xFileDataNode.cxx xFileDataNode.I xFileDataNode.h \
xFileDataNodeReference.cxx xFileDataNodeReference.I xFileDataNodeReference.h \ xFileDataNodeReference.cxx xFileDataNodeReference.I xFileDataNodeReference.h \
xFileDataNodeTemplate.cxx xFileDataNodeTemplate.I xFileDataNodeTemplate.h \
xFileNode.cxx xFileNode.I xFileNode.h \ xFileNode.cxx xFileNode.I xFileNode.h \
xFileParseData.cxx xFileParseData.I xFileParseData.h \ xFileParseData.cxx xFileParseData.I xFileParseData.h \
xFileTemplate.cxx xFileTemplate.I xFileTemplate.h xFileTemplate.cxx xFileTemplate.I xFileTemplate.h

4
pandatool/src/xfile/config_xfile.cxx
View File

@ -23,9 +23,9 @@
#include "xFileDataObjectArray.h" #include "xFileDataObjectArray.h"
#include "xFileDataObjectDouble.h" #include "xFileDataObjectDouble.h"
#include "xFileDataObjectInteger.h" #include "xFileDataObjectInteger.h"
#include "xFileDataObjectTemplate.h"
#include "xFileDataNode.h" #include "xFileDataNode.h"
#include "xFileDataNodeReference.h" #include "xFileDataNodeReference.h"
#include "xFileDataNodeTemplate.h"
#include "xFileNode.h" #include "xFileNode.h"
#include "xFileTemplate.h" #include "xFileTemplate.h"
@ -66,9 +66,9 @@ init_libxfile() {
XFileDataObjectArray::init_type(); XFileDataObjectArray::init_type();
XFileDataObjectDouble::init_type(); XFileDataObjectDouble::init_type();
XFileDataObjectInteger::init_type(); XFileDataObjectInteger::init_type();
XFileDataObjectTemplate::init_type();
XFileDataNode::init_type(); XFileDataNode::init_type();
XFileDataNodeReference::init_type(); XFileDataNodeReference::init_type();
XFileDataNodeTemplate::init_type();
XFileNode::init_type(); XFileNode::init_type();
XFileTemplate::init_type(); XFileTemplate::init_type();
} }

14
pandatool/src/xfile/xFile.cxx
View File

@ -20,7 +20,7 @@
#include "xParserDefs.h" #include "xParserDefs.h"
#include "xLexerDefs.h" #include "xLexerDefs.h"
#include "xFileTemplate.h" #include "xFileTemplate.h"
#include "xFileDataObjectTemplate.h" #include "xFileDataNodeTemplate.h"
#include "config_xfile.h" #include "config_xfile.h"
#include "standard_templates.h" #include "standard_templates.h"
#include "zStream.h" #include "zStream.h"
@ -250,12 +250,12 @@ find_template(const WindowsGuid &guid) const {
// Description: Returns the data object associated with the indicated // Description: Returns the data object associated with the indicated
// name, if any, or NULL if none. // name, if any, or NULL if none.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
XFileDataObjectTemplate *XFile:: XFileDataNodeTemplate *XFile::
find_data_object(const string &name) const { find_data_object(const string &name) const {
XFileNode *child = find_descendent(name); XFileNode *child = find_descendent(name);
if (child != (XFileNode *)NULL && if (child != (XFileNode *)NULL &&
child->is_of_type(XFileDataObjectTemplate::get_class_type())) { child->is_of_type(XFileDataNodeTemplate::get_class_type())) {
return DCAST(XFileDataObjectTemplate, child); return DCAST(XFileDataNodeTemplate, child);
} }
return NULL; return NULL;
@ -267,13 +267,13 @@ find_data_object(const string &name) const {
// Description: Returns the data object associated with the indicated // Description: Returns the data object associated with the indicated
// GUID, if any, or NULL if none. // GUID, if any, or NULL if none.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
XFileDataObjectTemplate *XFile:: XFileDataNodeTemplate *XFile::
find_data_object(const WindowsGuid &guid) const { find_data_object(const WindowsGuid &guid) const {
NodesByGuid::const_iterator gi; NodesByGuid::const_iterator gi;
gi = _nodes_by_guid.find(guid); gi = _nodes_by_guid.find(guid);
if (gi != _nodes_by_guid.end() && if (gi != _nodes_by_guid.end() &&
(*gi).second->is_of_type(XFileDataObjectTemplate::get_class_type())) { (*gi).second->is_of_type(XFileDataNodeTemplate::get_class_type())) {
return DCAST(XFileDataObjectTemplate, (*gi).second); return DCAST(XFileDataNodeTemplate, (*gi).second);
} }
return NULL; return NULL;

6
pandatool/src/xfile/xFile.h
View File

@ -27,7 +27,7 @@
#include "pointerTo.h" #include "pointerTo.h"
class XFileTemplate; class XFileTemplate;
class XFileDataObjectTemplate; class XFileDataNodeTemplate;
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Class : XFile // Class : XFile
@ -51,8 +51,8 @@ public:
XFileTemplate *find_template(const string &name) const; XFileTemplate *find_template(const string &name) const;
XFileTemplate *find_template(const WindowsGuid &guid) const; XFileTemplate *find_template(const WindowsGuid &guid) const;
XFileDataObjectTemplate *find_data_object(const string &name) const; XFileDataNodeTemplate *find_data_object(const string &name) const;
XFileDataObjectTemplate *find_data_object(const WindowsGuid &guid) const; XFileDataNodeTemplate *find_data_object(const WindowsGuid &guid) const;
virtual void write_text(ostream &out, int indent_level) const; virtual void write_text(ostream &out, int indent_level) const;

6
pandatool/src/xfile/xFileDataDef.cxx
View File

@ -22,7 +22,7 @@
#include "xFileParseData.h" #include "xFileParseData.h"
#include "xFileDataObjectInteger.h" #include "xFileDataObjectInteger.h"
#include "xFileDataObjectDouble.h" #include "xFileDataObjectDouble.h"
#include "xFileDataObjectTemplate.h" #include "xFileDataNodeTemplate.h"
#include "xFileDataObjectArray.h" #include "xFileDataObjectArray.h"
TypeHandle XFileDataDef::_type_handle; TypeHandle XFileDataDef::_type_handle;
@ -294,8 +294,8 @@ PT(XFileDataObject) XFileDataDef::
unpack_template_value(const XFileParseDataList &parse_data_list, unpack_template_value(const XFileParseDataList &parse_data_list,
const XFileDataDef::PrevData &prev_data, const XFileDataDef::PrevData &prev_data,
size_t &index, size_t &sub_index) const { size_t &index, size_t &sub_index) const {
PT(XFileDataObjectTemplate) data_value = PT(XFileDataNodeTemplate) data_value =
new XFileDataObjectTemplate(get_x_file(), get_name(), _template); new XFileDataNodeTemplate(get_x_file(), get_name(), _template);
PrevData nested_prev_data(prev_data); PrevData nested_prev_data(prev_data);
if (!_template->repack_data(data_value, parse_data_list, if (!_template->repack_data(data_value, parse_data_list,

2
pandatool/src/xfile/xFileDataNodeReference.I
View File

@ -32,7 +32,7 @@ get_template() const {
// Access: Public // Access: Public
// Description: Returns the actual data object being referenced. // Description: Returns the actual data object being referenced.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
INLINE XFileDataObjectTemplate *XFileDataNodeReference:: INLINE XFileDataNodeTemplate *XFileDataNodeReference::
get_object() const { get_object() const {
return _object; return _object;
} }

2
pandatool/src/xfile/xFileDataNodeReference.cxx
View File

@ -27,7 +27,7 @@ TypeHandle XFileDataNodeReference::_type_handle;
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
XFileDataNodeReference:: XFileDataNodeReference::
XFileDataNodeReference(XFileDataObjectTemplate *object) : XFileDataNodeReference(XFileDataNodeTemplate *object) :
XFileDataNode(object->get_x_file(), object->get_name()), XFileDataNode(object->get_x_file(), object->get_name()),
_object(object) _object(object)
{ {

8
pandatool/src/xfile/xFileDataNodeReference.h
View File

@ -20,7 +20,7 @@
#define XFILEDATANODEREFERENCE_H #define XFILEDATANODEREFERENCE_H
#include "pandatoolbase.h" #include "pandatoolbase.h"
#include "xFileDataObjectTemplate.h" #include "xFileDataNodeTemplate.h"
#include "pointerTo.h" #include "pointerTo.h"
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -30,10 +30,10 @@
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
class XFileDataNodeReference : public XFileDataNode { class XFileDataNodeReference : public XFileDataNode {
public: public:
XFileDataNodeReference(XFileDataObjectTemplate *object); XFileDataNodeReference(XFileDataNodeTemplate *object);
INLINE XFileTemplate *get_template() const; INLINE XFileTemplate *get_template() const;
INLINE XFileDataObjectTemplate *get_object() const; INLINE XFileDataNodeTemplate *get_object() const;
virtual bool is_complex_object() const; virtual bool is_complex_object() const;
@ -45,7 +45,7 @@ protected:
virtual const XFileDataObject *get_element(const string &name) const; virtual const XFileDataObject *get_element(const string &name) const;
private: private:
PT(XFileDataObjectTemplate) _object; PT(XFileDataNodeTemplate) _object;
public: public:
static TypeHandle get_class_type() { static TypeHandle get_class_type() {

6
pandatool/src/xfile/xFileDataObjectTemplate.I → pandatool/src/xfile/xFileDataNodeTemplate.I
View File

@ -1,4 +1,4 @@
// Filename: xFileDataObjectTemplate.I // Filename: xFileDataNodeTemplate.I
// Created by: drose (03Oct04) // Created by: drose (03Oct04)
// //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -18,11 +18,11 @@
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::get_template // Function: XFileDataNodeTemplate::get_template
// Access: Public // Access: Public
// Description: Returns the template used to define this data object. // Description: Returns the template used to define this data object.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
INLINE XFileTemplate *XFileDataObjectTemplate:: INLINE XFileTemplate *XFileDataNodeTemplate::
get_template() const { get_template() const {
return _template; return _template;
} }

56
pandatool/src/xfile/xFileDataObjectTemplate.cxx → pandatool/src/xfile/xFileDataNodeTemplate.cxx
View File

@ -1,4 +1,4 @@
// Filename: xFileDataObjectTemplate.cxx // Filename: xFileDataNodeTemplate.cxx
// Created by: drose (03Oct04) // Created by: drose (03Oct04)
// //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -16,20 +16,20 @@
// //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
#include "xFileDataObjectTemplate.h" #include "xFileDataNodeTemplate.h"
#include "indent.h" #include "indent.h"
#include "xFileParseData.h" #include "xFileParseData.h"
#include "xLexerDefs.h" #include "xLexerDefs.h"
TypeHandle XFileDataObjectTemplate::_type_handle; TypeHandle XFileDataNodeTemplate::_type_handle;
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::Constructor // Function: XFileDataNodeTemplate::Constructor
// Access: Public // Access: Public
// Description: // Description:
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
XFileDataObjectTemplate:: XFileDataNodeTemplate::
XFileDataObjectTemplate(XFile *x_file, const string &name, XFileDataNodeTemplate(XFile *x_file, const string &name,
XFileTemplate *xtemplate) : XFileTemplate *xtemplate) :
XFileDataNode(x_file, name), XFileDataNode(x_file, name),
_template(xtemplate) _template(xtemplate)
@ -37,25 +37,25 @@ XFileDataObjectTemplate(XFile *x_file, const string &name,
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::is_complex_object // Function: XFileDataNodeTemplate::is_complex_object
// Access: Public, Virtual // Access: Public, Virtual
// Description: Returns true if this kind of data object is a complex // Description: Returns true if this kind of data object is a complex
// object that can hold nested data elements, false // object that can hold nested data elements, false
// otherwise. // otherwise.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
bool XFileDataObjectTemplate:: bool XFileDataNodeTemplate::
is_complex_object() const { is_complex_object() const {
return true; return true;
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::add_parse_double // Function: XFileDataNodeTemplate::add_parse_double
// Access: Public // Access: Public
// Description: Adds the indicated list of doubles as a data element // Description: Adds the indicated list of doubles as a data element
// encountered in the parser. It will later be // encountered in the parser. It will later be
// processed by finalize_parse_data(). // processed by finalize_parse_data().
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void XFileDataObjectTemplate:: void XFileDataNodeTemplate::
add_parse_double(PTA_double double_list) { add_parse_double(PTA_double double_list) {
XFileParseData pdata; XFileParseData pdata;
pdata._double_list = double_list; pdata._double_list = double_list;
@ -65,13 +65,13 @@ add_parse_double(PTA_double double_list) {
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::add_parse_int // Function: XFileDataNodeTemplate::add_parse_int
// Access: Public // Access: Public
// Description: Adds the indicated list of ints as a data element // Description: Adds the indicated list of ints as a data element
// encountered in the parser. It will later be // encountered in the parser. It will later be
// processed by finalize_parse_data(). // processed by finalize_parse_data().
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void XFileDataObjectTemplate:: void XFileDataNodeTemplate::
add_parse_int(PTA_int int_list) { add_parse_int(PTA_int int_list) {
XFileParseData pdata; XFileParseData pdata;
pdata._int_list = int_list; pdata._int_list = int_list;
@ -81,13 +81,13 @@ add_parse_int(PTA_int int_list) {
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::add_parse_string // Function: XFileDataNodeTemplate::add_parse_string
// Access: Public // Access: Public
// Description: Adds the indicated string as a data element // Description: Adds the indicated string as a data element
// encountered in the parser. It will later be // encountered in the parser. It will later be
// processed by finalize_parse_data(). // processed by finalize_parse_data().
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void XFileDataObjectTemplate:: void XFileDataNodeTemplate::
add_parse_string(const string &str) { add_parse_string(const string &str) {
XFileParseData pdata; XFileParseData pdata;
pdata._string = str; pdata._string = str;
@ -97,7 +97,7 @@ add_parse_string(const string &str) {
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::finalize_parse_data // Function: XFileDataNodeTemplate::finalize_parse_data
// Access: Public // Access: Public
// Description: Processes all of the data elements added by // Description: Processes all of the data elements added by
// add_parse_*(), checks them for syntactic and semantic // add_parse_*(), checks them for syntactic and semantic
@ -105,7 +105,7 @@ add_parse_string(const string &str) {
// stores the appropriate child data elements. Returns // stores the appropriate child data elements. Returns
// true on success, false if there is a mismatch. // true on success, false if there is a mismatch.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
bool XFileDataObjectTemplate:: bool XFileDataNodeTemplate::
finalize_parse_data() { finalize_parse_data() {
// Recursively walk through our template definition, while // Recursively walk through our template definition, while
// simultaneously walking through the list of parse data elements we // simultaneously walking through the list of parse data elements we
@ -128,26 +128,26 @@ finalize_parse_data() {
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::add_element // Function: XFileDataNodeTemplate::add_element
// Access: Public, Virtual // Access: Public, Virtual
// Description: Adds the indicated element as a nested data element, // Description: Adds the indicated element as a nested data element,
// if this data object type supports it. Returns true // if this data object type supports it. Returns true
// if added successfully, false if the data object type // if added successfully, false if the data object type
// does not support nested data elements. // does not support nested data elements.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
bool XFileDataObjectTemplate:: bool XFileDataNodeTemplate::
add_element(XFileDataObject *element) { add_element(XFileDataObject *element) {
_nested_elements.push_back(element); _nested_elements.push_back(element);
return true; return true;
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::write_text // Function: XFileDataNodeTemplate::write_text
// Access: Public, Virtual // Access: Public, Virtual
// Description: Writes a suitable representation of this node to an // Description: Writes a suitable representation of this node to an
// .x file in text mode. // .x file in text mode.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void XFileDataObjectTemplate:: void XFileDataNodeTemplate::
write_text(ostream &out, int indent_level) const { write_text(ostream &out, int indent_level) const {
indent(out, indent_level) indent(out, indent_level)
<< _template->get_name(); << _template->get_name();
@ -167,12 +167,12 @@ write_text(ostream &out, int indent_level) const {
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::write_data // Function: XFileDataNodeTemplate::write_data
// Access: Public, Virtual // Access: Public, Virtual
// Description: Writes a suitable representation of this node to an // Description: Writes a suitable representation of this node to an
// .x file in text mode. // .x file in text mode.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
void XFileDataObjectTemplate:: void XFileDataNodeTemplate::
write_data(ostream &out, int indent_level, const char *separator) const { write_data(ostream &out, int indent_level, const char *separator) const {
if (!_nested_elements.empty()) { if (!_nested_elements.empty()) {
bool indented = false; bool indented = false;
@ -217,36 +217,36 @@ write_data(ostream &out, int indent_level, const char *separator) const {
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::get_num_elements // Function: XFileDataNodeTemplate::get_num_elements
// Access: Protected, Virtual // Access: Protected, Virtual
// Description: Returns the number of nested data elements within the // Description: Returns the number of nested data elements within the
// object. This may be, e.g. the size of the array, if // object. This may be, e.g. the size of the array, if
// it is an array. // it is an array.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
int XFileDataObjectTemplate:: int XFileDataNodeTemplate::
get_num_elements() const { get_num_elements() const {
return _nested_elements.size(); return _nested_elements.size();
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::get_element // Function: XFileDataNodeTemplate::get_element
// Access: Protected, Virtual // Access: Protected, Virtual
// Description: Returns the nth nested data element within the // Description: Returns the nth nested data element within the
// object. // object.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
const XFileDataObject *XFileDataObjectTemplate:: const XFileDataObject *XFileDataNodeTemplate::
get_element(int n) const { get_element(int n) const {
nassertr(n >= 0 && n < (int)_nested_elements.size(), NULL); nassertr(n >= 0 && n < (int)_nested_elements.size(), NULL);
return _nested_elements[n]; return _nested_elements[n];
} }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: XFileDataObjectTemplate::get_element // Function: XFileDataNodeTemplate::get_element
// Access: Protected, Virtual // Access: Protected, Virtual
// Description: Returns the nested data element within the // Description: Returns the nested data element within the
// object that has the indicated name. // object that has the indicated name.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
const XFileDataObject *XFileDataObjectTemplate:: const XFileDataObject *XFileDataNodeTemplate::
get_element(const string &name) const { get_element(const string &name) const {
return NULL; return NULL;
} }

16
pandatool/src/xfile/xFileDataObjectTemplate.h → pandatool/src/xfile/xFileDataNodeTemplate.h
View File

@ -1,4 +1,4 @@
// Filename: xFileDataObjectTemplate.h // Filename: xFileDataNodeTemplate.h
// Created by: drose (03Oct04) // Created by: drose (03Oct04)
// //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
@ -16,8 +16,8 @@
// //
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
#ifndef XFILEDATAOBJECTTEMPLATE_H #ifndef XFILEDATANODETEMPLATE_H
#define XFILEDATAOBJECTTEMPLATE_H #define XFILEDATANODETEMPLATE_H
#include "pandatoolbase.h" #include "pandatoolbase.h"
#include "xFileDataNode.h" #include "xFileDataNode.h"
@ -28,16 +28,16 @@
#include "pta_double.h" #include "pta_double.h"
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Class : XFileDataObjectTemplate // Class : XFileDataNodeTemplate
// Description : A data element that represents a combination of // Description : A data element that represents a combination of
// multiple data elements as defined by a template. The // multiple data elements as defined by a template. The
// individual data elements of the template may be // individual data elements of the template may be
// obtained by walking through the children of this // obtained by walking through the children of this
// object. // object.
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
class XFileDataObjectTemplate : public XFileDataNode { class XFileDataNodeTemplate : public XFileDataNode {
public: public:
XFileDataObjectTemplate(XFile *x_file, const string &name, XFileDataNodeTemplate(XFile *x_file, const string &name,
XFileTemplate *xtemplate); XFileTemplate *xtemplate);
INLINE XFileTemplate *get_template() const; INLINE XFileTemplate *get_template() const;
@ -74,7 +74,7 @@ public:
} }
static void init_type() { static void init_type() {
XFileDataNode::init_type(); XFileDataNode::init_type();
register_type(_type_handle, "XFileDataObjectTemplate", register_type(_type_handle, "XFileDataNodeTemplate",
XFileDataNode::get_class_type()); XFileDataNode::get_class_type());
} }
virtual TypeHandle get_type() const { virtual TypeHandle get_type() const {
@ -86,7 +86,7 @@ private:
static TypeHandle _type_handle; static TypeHandle _type_handle;
}; };
#include "xFileDataObjectTemplate.I" #include "xFileDataNodeTemplate.I"
#endif #endif

4
pandatool/src/xfile/xFileParseData.h
View File

@ -29,10 +29,10 @@
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Class : XFileParseData // Class : XFileParseData
// Description : This class is used to fill up the data into an // Description : This class is used to fill up the data into an
// XFileDataObjectTemplate object as the data values are // XFileDataNodeTemplate object as the data values are
// parsed out of the X file. It only has a temporary // parsed out of the X file. It only has a temporary
// lifespan; it will be converted into actual data by // lifespan; it will be converted into actual data by
// XFileDataObjectTemplate::finalize_parse_data(). // XFileDataNodeTemplate::finalize_parse_data().
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
class XFileParseData { class XFileParseData {
public: public:

26
pandatool/src/xfile/xParser.cxx.prebuilt
View File

@ -50,7 +50,7 @@
#include "xFileTemplate.h" #include "xFileTemplate.h"
#include "xFileDataDef.h" #include "xFileDataDef.h"
#include "xFileArrayDef.h" #include "xFileArrayDef.h"
#include "xFileDataObjectTemplate.h" #include "xFileDataNodeTemplate.h"
#include "xFileDataNodeReference.h" #include "xFileDataNodeReference.h"
#include "pointerTo.h" #include "pointerTo.h"
#include "dcast.h" #include "dcast.h"
@ -1215,8 +1215,8 @@ case 49:
if (xtemplate == (XFileTemplate *)NULL) { if (xtemplate == (XFileTemplate *)NULL) {
yyerror("Unknown template: " + yyvsp[-2].str); yyerror("Unknown template: " + yyvsp[-2].str);
} else { } else {
XFileDataObjectTemplate *templ = XFileDataNodeTemplate *templ =
new XFileDataObjectTemplate(x_file, yyvsp[-1].str, xtemplate); new XFileDataNodeTemplate(x_file, yyvsp[-1].str, xtemplate);
current_node->add_child(templ); current_node->add_child(templ);
current_node = templ; current_node = templ;
} }
@ -1225,8 +1225,8 @@ case 49:
case 50: case 50:
#line 349 "xParser.yxx" #line 349 "xParser.yxx"
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->finalize_parse_data(); current_template->finalize_parse_data();
yyval.u.node = current_node; yyval.u.node = current_node;
@ -1249,24 +1249,24 @@ case 54:
case 55: case 55:
#line 375 "xParser.yxx" #line 375 "xParser.yxx"
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->add_parse_int(yyvsp[0].int_list); current_template->add_parse_int(yyvsp[0].int_list);
} }
break; break;
case 56: case 56:
#line 381 "xParser.yxx" #line 381 "xParser.yxx"
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->add_parse_double(yyvsp[0].double_list); current_template->add_parse_double(yyvsp[0].double_list);
} }
break; break;
case 57: case 57:
#line 387 "xParser.yxx" #line 387 "xParser.yxx"
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->add_parse_string(yyvsp[-1].str); current_template->add_parse_string(yyvsp[-1].str);
} }
break; break;
@ -1278,7 +1278,7 @@ case 58:
case 64: case 64:
#line 416 "xParser.yxx" #line 416 "xParser.yxx"
{ {
XFileDataObjectTemplate *data_object = x_file->find_data_object(yyvsp[0].str); XFileDataNodeTemplate *data_object = x_file->find_data_object(yyvsp[0].str);
if (data_object == (XFileDataObject *)NULL) { if (data_object == (XFileDataObject *)NULL) {
yyerror("Unknown data_object: " + yyvsp[0].str); yyerror("Unknown data_object: " + yyvsp[0].str);
} }
@ -1289,7 +1289,7 @@ case 64:
case 65: case 65:
#line 425 "xParser.yxx" #line 425 "xParser.yxx"
{ {
XFileDataObjectTemplate *data_object = x_file->find_data_object(yyvsp[0].guid); XFileDataNodeTemplate *data_object = x_file->find_data_object(yyvsp[0].guid);
if (data_object == (XFileDataObject *)NULL) { if (data_object == (XFileDataObject *)NULL) {
yyerror("Unknown data_object: " + yyvsp[-1].str); yyerror("Unknown data_object: " + yyvsp[-1].str);
} else { } else {

26
pandatool/src/xfile/xParser.yxx
View File

@ -16,7 +16,7 @@
#include "xFileTemplate.h" #include "xFileTemplate.h"
#include "xFileDataDef.h" #include "xFileDataDef.h"
#include "xFileArrayDef.h" #include "xFileArrayDef.h"
#include "xFileDataObjectTemplate.h" #include "xFileDataNodeTemplate.h"
#include "xFileDataNodeReference.h" #include "xFileDataNodeReference.h"
#include "pointerTo.h" #include "pointerTo.h"
#include "dcast.h" #include "dcast.h"
@ -339,16 +339,16 @@ object:
if (xtemplate == (XFileTemplate *)NULL) { if (xtemplate == (XFileTemplate *)NULL) {
yyerror("Unknown template: " + $1); yyerror("Unknown template: " + $1);
} else { } else {
XFileDataObjectTemplate *templ = XFileDataNodeTemplate *templ =
new XFileDataObjectTemplate(x_file, $2, xtemplate); new XFileDataNodeTemplate(x_file, $2, xtemplate);
current_node->add_child(templ); current_node->add_child(templ);
current_node = templ; current_node = templ;
} }
} }
optional_class_id data_parts_list TOKEN_CBRACE optional_class_id data_parts_list TOKEN_CBRACE
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->finalize_parse_data(); current_template->finalize_parse_data();
$$ = current_node; $$ = current_node;
@ -373,20 +373,20 @@ data_part:
} }
| integer_list | integer_list
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->add_parse_int($1); current_template->add_parse_int($1);
} }
| realnum_list | realnum_list
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->add_parse_double($1); current_template->add_parse_double($1);
} }
| string list_separator | string list_separator
{ {
XFileDataObjectTemplate *current_template = XFileDataNodeTemplate *current_template =
DCAST(XFileDataObjectTemplate, current_node); DCAST(XFileDataNodeTemplate, current_node);
current_template->add_parse_string($1); current_template->add_parse_string($1);
} }
| list_separator | list_separator
@ -414,7 +414,7 @@ list_separator:
data_reference: data_reference:
name name
{ {
XFileDataObjectTemplate *data_object = x_file->find_data_object($1); XFileDataNodeTemplate *data_object = x_file->find_data_object($1);
if (data_object == (XFileDataObject *)NULL) { if (data_object == (XFileDataObject *)NULL) {
yyerror("Unknown data_object: " + $1); yyerror("Unknown data_object: " + $1);
} }
@ -423,7 +423,7 @@ data_reference:
} }
| name class_id | name class_id
{ {
XFileDataObjectTemplate *data_object = x_file->find_data_object($2); XFileDataNodeTemplate *data_object = x_file->find_data_object($2);
if (data_object == (XFileDataObject *)NULL) { if (data_object == (XFileDataObject *)NULL) {
yyerror("Unknown data_object: " + $1); yyerror("Unknown data_object: " + $1);
} else { } else {